feat: add support to generate unsigned txs in sui scripts

sui/deploy-contract.js

@@ -1,9 +1,8 @@
 const { Command, Option } = require('commander');
 const { getLocalDependencies, updateMoveToml, TxBuilder, bcsStructs } = require('@axelar-network/axelar-cgp-sui');
-const { toB64 } = require('@mysten/sui/utils');
 const { bcs } = require('@mysten/sui/bcs');
 const { Transaction } = require('@mysten/sui/transactions');
-const { saveConfig, printInfo, validateParameters, writeJSON, getDomainSeparator, loadConfig, getChainConfig } = require('../common');
+const { saveConfig, printInfo, validateParameters, getDomainSeparator, loadConfig, getChainConfig } = require('../common');
 const {
     addBaseOptions,
     addOptionsToCommands,
@@ -342,16 +341,6 @@ async function mainProcessor(args, options, processor) {
     await processor(keypair, client, ...args, config, sui, options);
 
     saveConfig(config, options.env);
-
-    if (options.offline) {
-        const { txFilePath } = options;
-        validateParameters({ isNonEmptyString: { txFilePath } });
-
-        const txB64Bytes = toB64(options.txBytes);
-
-        writeJSON({ message: options.offlineMessage, status: 'PENDING', unsignedTx: txB64Bytes }, txFilePath);
-        printInfo(`Unsigned transaction`, txFilePath);
-    }
 }
 
 /**

sui/gateway.js

@@ -18,6 +18,7 @@ const {
     getRawPrivateKey,
     broadcast,
     suiClockAddress,
+    saveGeneratedTx,
 } = require('./utils');
 const secp256k1 = require('secp256k1');
 
@@ -140,7 +141,10 @@ async function callContract(keypair, client, config, chain, contractConfig, args
         });
     }
 
-    await broadcast(client, keypair, tx, 'Message sent');
+    return {
+        tx,
+        message: 'Message sent',
+    };
 }
 
 async function approve(keypair, client, config, chain, contractConfig, args, options) {
@@ -173,7 +177,10 @@ async function approve(keypair, client, config, chain, contractConfig, args, opt
         ],
     });
 
-    await broadcast(client, keypair, tx, 'Approved Messages');
+    return {
+        tx,
+        message: 'Approved Messages',
+    };
 }
 
 async function submitProof(keypair, client, config, chain, contractConfig, args, options) {
@@ -216,7 +223,10 @@ async function submitProof(keypair, client, config, chain, contractConfig, args,
         throw new Error(`Unknown payload type: ${payload}`);
     }
 
-    await broadcast(client, keypair, tx, 'Submitted Amplifier Proof');
+    return {
+        tx,
+        message: 'Submitted Amplifier Proof',
+    };
 }
 
 async function rotate(keypair, client, config, chain, contractConfig, args, options) {
@@ -243,7 +253,10 @@ async function rotate(keypair, client, config, chain, contractConfig, args, opti
         ],
     });
 
-    await broadcast(client, keypair, tx, 'Rotated Signers');
+    return {
+        tx,
+        message: 'Rotated Signers',
+    };
 }
 
 async function mainProcessor(processor, args, options) {
@@ -257,9 +270,17 @@ async function mainProcessor(processor, args, options) {
         throw new Error('Axelar Gateway package not found.');
     }
 
-    await processor(keypair, client, config, chain, chain.contracts.AxelarGateway, args, options);
+    const { tx, message } = await processor(keypair, client, config, chain, chain.contracts.AxelarGateway, args, options);
 
     saveConfig(config, options.env);
+
+    if (options.offline) {
+        const sender = options.sender || keypair.toSuiAddress();
+        tx.setSender(sender);
+        await saveGeneratedTx(tx, message, client, options);
+    } else {
+        await broadcast(client, keypair, tx, message);
+    }
 }
 
 if (require.main === module) {
@@ -302,7 +323,7 @@ if (require.main === module) {
             mainProcessor(callContract, [destinationChain, destinationAddress, payload], options);
         });
 
-    addOptionsToCommands(program, addBaseOptions);
+    addOptionsToCommands(program, addBaseOptions, { offline: true });
 
     program.parse();
 }

sui/its.js

@@ -1,7 +1,7 @@
 const { Command } = require('commander');
 const { TxBuilder } = require('@axelar-network/axelar-cgp-sui');
 const { loadConfig, saveConfig, getChainConfig } = require('../common/utils');
-const { addBaseOptions, addOptionsToCommands, getWallet, printWalletInfo, broadcastFromTxBuilder } = require('./utils');
+const { addBaseOptions, addOptionsToCommands, getWallet, printWalletInfo, broadcastFromTxBuilder, saveGeneratedTx } = require('./utils');
 
 async function setupTrustedAddress(keypair, client, contracts, args, options) {
     const [trustedChain, trustedAddress] = args;
@@ -22,13 +22,20 @@ async function setupTrustedAddress(keypair, client, contracts, args, options) {
         arguments: [ITS, OwnerCap, trustedAddressesObject],
     });
 
-    await broadcastFromTxBuilder(txBuilder, keypair, 'Setup Trusted Address');
+    if (options.offline) {
+        const tx = txBuilder.tx;
+        const sender = options.sender || keypair.toSuiAddress();
+        tx.setSender(sender);
+        await saveGeneratedTx(tx, `Set trusted address for ${trustedChain} to ${trustedAddress}`, client, options);
+    } else {
+        await broadcastFromTxBuilder(txBuilder, keypair, 'Setup Trusted Address');
 
-    // Add trusted address to ITS config
-    if (!contracts.ITS.trustedAddresses) contracts.ITS.trustedAddresses = {};
-    if (!contracts.ITS.trustedAddresses[trustedChain]) contracts.ITS.trustedAddresses[trustedChain] = [];
+        // Add trusted address to ITS config
+        if (!contracts.ITS.trustedAddresses) contracts.ITS.trustedAddresses = {};
+        if (!contracts.ITS.trustedAddresses[trustedChain]) contracts.ITS.trustedAddresses[trustedChain] = [];
 
-    contracts.ITS.trustedAddresses[trustedChain].push(trustedAddress);
+        contracts.ITS.trustedAddresses[trustedChain].push(trustedAddress);
+    }
 }
 
 async function processCommand(command, chain, args, options) {
@@ -62,7 +69,7 @@ if (require.main === module) {
 
     program.addCommand(setupTrustedAddressProgram);
 
-    addOptionsToCommands(program, addBaseOptions);
+    addOptionsToCommands(program, addBaseOptions, { offline: true });
 
     program.parse();
 }

sui/operators.js

@@ -1,6 +1,6 @@
 const { Command, Option } = require('commander');
 const { Transaction } = require('@mysten/sui/transactions');
-const { printError, loadConfig, getChainConfig } = require('../common/utils');
+const { loadConfig, getChainConfig } = require('../common/utils');
 const {
     addBaseOptions,
     addOptionsToCommands,
@@ -9,6 +9,7 @@ const {
     printWalletInfo,
     broadcast,
     findOwnedObjectIdByType,
+    saveGeneratedTx,
 } = require('./utils');
 
 function operatorMoveCall(contractConfig, gasServiceConfig, operatorCapId, tx, moveCall) {
@@ -50,7 +51,10 @@ async function collectGas(keypair, client, gasServiceConfig, contractConfig, arg
         });
     });
 
-    await broadcast(client, keypair, tx, 'Gas Collected');
+    return {
+        tx,
+        message: 'Gas Collected',
+    };
 }
 
 async function refund(keypair, client, gasServiceConfig, contractConfig, args, options) {
@@ -78,7 +82,10 @@ async function refund(keypair, client, gasServiceConfig, contractConfig, args, o
         });
     });
 
-    await broadcast(client, keypair, tx, 'Refunded Gas');
+    return {
+        tx,
+        message: 'Refunded Gas',
+    };
 }
 
 async function storeCap(keypair, client, gasServiceConfig, contractConfig, args, options) {
@@ -95,7 +102,10 @@ async function storeCap(keypair, client, gasServiceConfig, contractConfig, args,
         typeArguments: [`${gasServiceConfig.address}::gas_service::GasCollectorCap`],
     });
 
-    await broadcast(client, keypair, tx, 'Stored Capability');
+    return {
+        tx,
+        message: 'Stored Capability',
+    };
 }
 
 async function addOperator(keypair, client, gasServiceConfig, contractConfig, args, options) {
@@ -111,7 +121,10 @@ async function addOperator(keypair, client, gasServiceConfig, contractConfig, ar
         arguments: [tx.object(operatorsObjectId), tx.object(ownerCapObjectId), tx.pure.address(newOperatorAddress)],
     });
 
-    await broadcast(client, keypair, tx, 'Added Operator');
+    return {
+        tx,
+        message: 'Added Operator',
+    };
 }
 
 async function removeCap(keypair, client, gasServiceConfig, contractConfig, args, options) {
@@ -132,11 +145,10 @@ async function removeCap(keypair, client, gasServiceConfig, contractConfig, args
 
     tx.transferObjects([cap], capReceiver);
 
-    try {
-        await broadcast(client, keypair, tx, 'Removed Capability');
-    } catch (e) {
-        printError('RemoveCap Error', e.message);
-    }
+    return {
+        tx,
+        message: 'Removed Capability',
+    };
 }
 
 async function removeOperator(keypair, client, gasServiceConfig, contractConfig, args, options) {
@@ -152,7 +164,10 @@ async function removeOperator(keypair, client, gasServiceConfig, contractConfig,
         arguments: [tx.object(operatorsObjectId), tx.object(ownerCapObjectId), tx.pure.address(operatorAddress)],
     });
 
-    await broadcast(client, keypair, tx, 'Removed Operator');
+    return {
+        tx,
+        message: 'Removed Operator',
+    };
 }
 
 async function mainProcessor(processor, args, options) {
@@ -172,7 +187,16 @@ async function mainProcessor(processor, args, options) {
 
     const [keypair, client] = getWallet(chain, options);
     await printWalletInfo(keypair, client, chain, options);
-    await processor(keypair, client, gasServiceConfig, contractConfig, args, options);
+
+    const { tx, message } = await processor(keypair, client, gasServiceConfig, contractConfig, args, options);
+
+    if (options.offline) {
+        const sender = options.sender || keypair.toSuiAddress();
+        tx.setSender(sender);
+        await saveGeneratedTx(tx, message, client, options);
+    } else {
+        await broadcast(client, keypair, tx, message);
+    }
 }
 
 if (require.main === module) {
@@ -231,7 +255,7 @@ if (require.main === module) {
             .action((messageId, options) => mainProcessor(refund, [messageId], options)),
     );
 
-    addOptionsToCommands(program, addBaseOptions);
+    addOptionsToCommands(program, addBaseOptions, { offline: true });
 
     program.parse();
 }

sui/transfer-object.js

@@ -1,7 +1,7 @@
 const { Transaction } = require('@mysten/sui/transactions');
 const { Command, Option } = require('commander');
 const { loadConfig, validateParameters, getChainConfig } = require('../common/utils');
-const { getWallet, printWalletInfo, addExtendedOptions, broadcast } = require('./utils');
+const { getWallet, printWalletInfo, addExtendedOptions, broadcast, saveGeneratedTx } = require('./utils');
 
 async function processCommand(chain, options) {
     const [keypair, client] = getWallet(chain, options);
@@ -38,7 +38,13 @@ async function processCommand(chain, options) {
     const tx = new Transaction();
     tx.transferObjects([`${objectId}`], tx.pure.address(recipient));
 
-    await broadcast(client, keypair, tx, 'Transferred Object');
+    if (options.offline) {
+        const sender = options.sender || keypair.toSuiAddress();
+        tx.setSender(sender);
+        await saveGeneratedTx(tx, 'Transferred Object', client, options);
+    } else {
+        await broadcast(client, keypair, tx, 'Transferred Object');
+    }
 }
 
 async function mainProcessor(options, processor) {
@@ -57,6 +63,9 @@ if (require.main === module) {
     program.addOption(new Option('--objectId <objectId>', 'object id to be transferred'));
     program.addOption(new Option('--objectName <objectName>', 'object name to be transferred'));
     program.addOption(new Option('--recipient <recipient>', 'recipient to transfer object to').makeOptionMandatory(true));
+    program.addOption(new Option('--sender <sender>', 'transaction sender'));
+    program.addOption(new Option('--offline', 'store tx block for sign'));
+    program.addOption(new Option('--txFilePath <file>', 'unsigned transaction will be stored'));
 
     program.action(async (options) => {
         mainProcessor(options, processCommand);

sui/utils/cli-utils.js

@@ -35,6 +35,12 @@ const addBaseOptions = (program, options = {}) => {
         program.addOption(new Option('--address <address>', 'override contract address'));
     }
 
+    if (options.offline) {
+        program.addOption(new Option('--sender <sender>', 'transaction sender'));
+        program.addOption(new Option('--offline', 'store tx block for sign'));
+        program.addOption(new Option('--txFilePath <file>', 'unsigned transaction will be stored'));
+    }
+
     return program;
 };
 

sui/utils/upgrade-utils.js

@@ -1,7 +1,7 @@
 const { bcs } = require('@mysten/bcs');
 const { fromB64 } = require('@mysten/bcs');
 const { printInfo, validateParameters } = require('../../common/utils');
-const { getObjectIdsByObjectTypes, suiPackageAddress, moveDir } = require('./utils');
+const { getObjectIdsByObjectTypes, suiPackageAddress, moveDir, saveGeneratedTx } = require('./utils');
 const UPGRADE_POLICIES = {
     code_upgrade: 'only_additive_upgrades',
     dependency_upgrade: 'only_dep_upgrades',
@@ -24,7 +24,6 @@ async function upgradePackage(client, keypair, packageToUpgrade, contractConfig,
     const { packageDir, packageName } = packageToUpgrade;
     const { modules, dependencies, digest } = await builder.getContractBuild(packageDir, moveDir);
     const { offline } = options;
-    const sender = options.sender || keypair.toSuiAddress();
     const upgradeCap = contractConfig.objects?.UpgradeCap;
     const digestHash = options.digest ? fromB64(options.digest) : digest;
     const policy = getUpgradePolicyId(options.policy);
@@ -50,13 +49,12 @@ async function upgradePackage(client, keypair, packageToUpgrade, contractConfig,
         arguments: [cap, receipt],
     });
 
-    tx.setSender(sender);
-    const txBytes = await tx.build({ client });
-
     if (offline) {
-        options.txBytes = txBytes;
-        options.offlineMessage = `Transaction to upgrade ${packageDir}`;
+        const sender = options.sender || keypair.toSuiAddress();
+        tx.setSender(sender);
+        await saveGeneratedTx(tx, `Transaction to upgrade ${packageDir}`, client, options);
     } else {
+        const txBytes = await tx.build({ client });
         const signature = (await keypair.signTransaction(txBytes)).signature;
         const result = await client.executeTransactionBlock({
             transactionBlock: txBytes,

sui/utils/utils.js

@@ -2,14 +2,14 @@
 
 const { ethers } = require('hardhat');
 const toml = require('toml');
-const { printInfo, printError, printWarn } = require('../../common/utils');
+const { printInfo, printError, printWarn, validateParameters, writeJSON } = require('../../common/utils');
 const {
     BigNumber,
     utils: { arrayify, hexlify, toUtf8Bytes, keccak256 },
     constants: { HashZero },
 } = ethers;
 const fs = require('fs');
-const { fromB64 } = require('@mysten/bcs');
+const { fromB64, toB64 } = require('@mysten/bcs');
 const { CosmWasmClient } = require('@cosmjs/cosmwasm-stargate');
 const {
     updateMoveToml,
@@ -270,6 +270,17 @@ const checkTrustedAddresses = (trustedAddresses, destinationChain) => {
     }
 };
 
+const saveGeneratedTx = async (tx, message, client, options) => {
+    const { txFilePath } = options;
+    validateParameters({ isNonEmptyString: { txFilePath } });
+
+    const txBytes = await tx.build({ client });
+    const txB64Bytes = toB64(txBytes);
+
+    writeJSON({ message, status: 'PENDING', unsignedTx: txB64Bytes }, txFilePath);
+    printInfo(`Unsigned transaction`, txFilePath);
+};
+
 module.exports = {
     suiCoinId,
     getAmplifierSigners,
@@ -294,4 +305,5 @@ module.exports = {
     checkTrustedAddresses,
     parseDiscoveryInfo,
     parseGatewayInfo,
+    saveGeneratedTx,
 };