approveZRC20

Author: fadeev

examples/call/commands/common.ts

@@ -2,6 +2,7 @@ import path from "path";
 import fs from "fs";
 import { ethers } from "ethers";
 import { Command } from "commander";
+import ZRC20ABI from "@zetachain/protocol-contracts/abi/ZRC20.sol/ZRC20.json";
 
 export const getAbi = (name: string) => {
   const abiPath = path.resolve(
@@ -27,6 +28,45 @@ export const createRevertOptions = (options: {
   };
 };
 
+export const approveZRC20 = async (
+  zrc20Address: string,
+  contract: string,
+  amount: string,
+  signer: ethers.Wallet,
+  gasLimit?: number
+) => {
+  const zrc20 = new ethers.Contract(zrc20Address, ZRC20ABI.abi, signer);
+  const [gasZRC20, gasFee] = gasLimit
+    ? await zrc20.withdrawGasFeeWithGasLimit(gasLimit)
+    : await zrc20.withdrawGasFee();
+
+  const zrc20TransferTx = await zrc20.approve(contract, gasFee);
+  await zrc20TransferTx.wait();
+
+  const decimals = await zrc20.decimals();
+  if (gasZRC20 === zrc20.target) {
+    const targetTokenApprove = await zrc20.approve(
+      contract,
+      gasFee + ethers.parseUnits(amount, decimals)
+    );
+    await targetTokenApprove.wait();
+  } else {
+    const targetTokenApprove = await zrc20.approve(
+      contract,
+      ethers.parseUnits(amount, decimals)
+    );
+    await targetTokenApprove.wait();
+    const gasZRC20Contract = new ethers.Contract(
+      gasZRC20,
+      ZRC20ABI.abi,
+      signer
+    );
+    const gasFeeApprove = await gasZRC20Contract.approve(contract, gasFee);
+    await gasFeeApprove.wait();
+  }
+  return { decimals };
+};
+
 export const createCommand = (name: string) => {
   return new Command(name)
     .requiredOption(
@@ -54,11 +94,12 @@ export const createCommand = (name: string) => {
       "Gas limit for revert tx",
       "500000"
     )
-    .option("-n, --name <contract>", "Contract name", "Connected")
+    .option("-n, --name <contract>", "Contract name")
     .option(
       "--rpc <url>",
       "RPC endpoint",
       "https://zetachain-athens-evm.blockpi.network/v1/rpc/public"
     )
+    .option("--gas-limit <number>", "Gas limit for the transaction", "1000000")
     .option("--private-key <key>", "Private key to sign the transaction");
 };

examples/call/commands/connected/call.ts

@@ -17,7 +17,8 @@ const main = async (options: any) => {
   const tx = await contract.call(
     options.receiver,
     message,
-    createRevertOptions(options)
+    createRevertOptions(options),
+    { gasLimit: options.gasLimit }
   );
   await tx.wait();
 

examples/call/commands/connected/deposit.ts

@@ -12,7 +12,7 @@ const main = async (options: any) => {
   const tx = await contract.deposit(
     options.receiver,
     createRevertOptions(options),
-    { value: ethers.parseEther(options.amount) }
+    { value: ethers.parseEther(options.amount), gasLimit: options.gasLimit }
   );
   await tx.wait();
 

examples/call/commands/connected/depositAndCall.ts

@@ -18,7 +18,7 @@ const main = async (options: any) => {
     options.receiver,
     message,
     createRevertOptions(options),
-    { value: ethers.parseEther(options.amount) }
+    { value: ethers.parseEther(options.amount), gasLimit: options.gasLimit }
   );
   await tx.wait();
 

examples/call/commands/index.ts

@@ -6,14 +6,16 @@ import { connectedDepositCommand } from "./connected/deposit";
 import { connectedDepositAndCallCommand } from "./connected/depositAndCall";
 import { universalCallCommand } from "./universal/call";
 import { universalWithdrawCommand } from "./universal/withdraw";
+import { universalWithdrawAndCallCommand } from "./universal/withdrawAndCall";
 
 const program = new Command()
   .helpCommand(false)
   .addCommand(connectedCallCommand)
   .addCommand(connectedDepositCommand)
   .addCommand(connectedDepositAndCallCommand)
   .addCommand(universalCallCommand)
-  .addCommand(universalWithdrawCommand);
+  .addCommand(universalWithdrawCommand)
+  .addCommand(universalWithdrawAndCallCommand);
 
 if (require.main === module) program.parse();
 

examples/call/commands/universal/call.ts

@@ -36,7 +36,7 @@ const main = async (options: any) => {
       isArbitraryCall: options.callOptionsIsArbitraryCall,
     },
     createRevertOptions(options),
-    { gasLimit: 2000000 }
+    { gasLimit: options.gasLimit }
   );
   await tx.wait();
 

examples/call/commands/universal/withdraw.ts

@@ -1,7 +1,11 @@
 import { ethers } from "ethers";
 
-import { createCommand, createRevertOptions, getAbi } from "../common";
-import ZRC20ABI from "@zetachain/protocol-contracts/abi/ZRC20.sol/ZRC20.json";
+import {
+  approveZRC20,
+  createCommand,
+  createRevertOptions,
+  getAbi,
+} from "../common";
 
 const main = async (options: any) => {
   const provider = new ethers.JsonRpcProvider(options.rpc);
@@ -10,35 +14,19 @@ const main = async (options: any) => {
   const { abi } = getAbi(options.name);
   const contract = new ethers.Contract(options.contract, abi, signer);
 
-  const zrc20 = new ethers.Contract(options.zrc20, ZRC20ABI.abi, signer);
-  const [gasZRC20, gasFee] = await zrc20.withdrawGasFee();
-
-  const zrc20TransferTx = await zrc20.approve(options.contract, gasFee);
-
-  await zrc20TransferTx.wait();
-
-  const decimals = await zrc20.decimals();
-  if (gasZRC20 === options.zrc20) {
-    const targetTokenApprove = await zrc20.approve(
-      options.contract,
-      gasFee + ethers.parseUnits(options.amount, decimals)
-    );
-    await targetTokenApprove.wait();
-  } else {
-    const targetTokenApprove = await zrc20.approve(
-      options.contract,
-      ethers.parseUnits(options.amount, decimals)
-    );
-    await targetTokenApprove.wait();
-    const gasFeeApprove = await gasZRC20.approve(options.contract, gasFee);
-    await gasFeeApprove.wait();
-  }
+  const { decimals } = await approveZRC20(
+    options.zrc20,
+    options.contract,
+    options.amount,
+    signer
+  );
 
   const tx = await contract.withdraw(
     options.receiver,
     ethers.parseUnits(options.amount, decimals),
     options.zrc20,
-    createRevertOptions(options)
+    createRevertOptions(options),
+    { gasLimit: options.gasLimit }
   );
   await tx.wait();
 

examples/call/commands/universal/withdrawAndCall.ts

@@ -0,0 +1,64 @@
+import { ethers } from "ethers";
+
+import {
+  approveZRC20,
+  createCommand,
+  createRevertOptions,
+  getAbi,
+} from "../common";
+
+const main = async (options: any) => {
+  const provider = new ethers.JsonRpcProvider(options.rpc);
+  const signer = new ethers.Wallet(options.privateKey, provider);
+
+  const message = ethers.AbiCoder.defaultAbiCoder().encode(
+    options.types,
+    options.values
+  );
+
+  const functionSignature = ethers.id(options.function).slice(0, 10);
+
+  const payload = ethers.hexlify(ethers.concat([functionSignature, message]));
+
+  const { abi } = getAbi(options.name);
+  const contract = new ethers.Contract(options.contract, abi, signer);
+
+  const { decimals } = await approveZRC20(
+    options.zrc20,
+    options.contract,
+    options.amount,
+    signer,
+    options.callOptionsGasLimit
+  );
+
+  const tx = await contract.withdrawAndCall(
+    options.receiver,
+    ethers.parseUnits(options.amount, decimals),
+    options.zrc20,
+    payload,
+    {
+      gasLimit: options.callOptionsGasLimit,
+      isArbitraryCall: options.callOptionsIsArbitraryCall,
+    },
+    createRevertOptions(options),
+    { gasLimit: options.gasLimit }
+  );
+  await tx.wait();
+
+  console.log(`✅ Transaction sent: ${tx.hash}`);
+};
+
+export const universalWithdrawAndCallCommand = createCommand(
+  "universal-withdraw-and-call"
+)
+  .requiredOption("-t, --types <types...>", "Parameter types as JSON string")
+  .requiredOption("-v, --values <values...>", "The values of the parameters")
+  .option("--call-options-is-arbitrary-call", "Call any function", false)
+  .option("--call-options-gas-limit", "The gas limit for the call", "500000")
+  .option(
+    "--function <function>",
+    `Function to call (example: "hello(string)")`
+  )
+  .requiredOption("--amount <number>", "Amount to withdraw")
+  .option("--zrc20 <address>", "The address of ZRC-20 to pay fees")
+  .action(main);