feat(sui)!: add script option to pause sui contracts

.github/workflows/test-sui.yaml

@@ -141,8 +141,8 @@ jobs:
       - name: Deploy ABI
         run: node sui/deploy-contract deploy Abi
 
-      - name: Deploy ITS
-        run: node sui/deploy-contract deploy ITS
+      - name: Deploy InterchainTokenService
+        run: node sui/deploy-contract deploy InterchainTokenService --itsHubAddress "hub_address"
 
       - name: Deploy Example
         run: node sui/deploy-contract deploy Example
@@ -196,7 +196,7 @@ jobs:
           echo "emptyTokenName=Empty" >> $GITHUB_ENV
           echo "emptyTokenDecimals=6" >> $GITHUB_ENV
           config=$(cat axelar-chains-config/info/local.json)
-          echo "channelId=$(echo $config | jq -r '.chains.sui.contracts.ITS.objects.ChannelId')" >> $GITHUB_ENV
+          echo "channelId=$(echo $config | jq -r '.chains.sui.contracts.InterchainTokenService.objects.ChannelId')" >> $GITHUB_ENV
           echo "destinationContractAddress=$(echo $config | jq -r '.chains.sui.contracts.Example.objects.ItsChannelId')" >> $GITHUB_ENV
 
       - name: Deploy Test Tokens
@@ -205,8 +205,8 @@ jobs:
           node sui/its-example deploy-token ${{ env.emptyTokenSymbol }} ${{ env.emptyTokenName }} ${{ env.emptyTokenDecimals }}
 
           # Prepare additional parameters for the example:
-          transferInfo=$(node sui/its-example.js print-receive-transfer ${{ env.symbol }} ${{ env.sourceAddress }} ${{ env.amount }})
-          deploymentInfo=$(node sui/its-example.js print-receive-deployment ${{ env.emptyTokenName }} ${{ env.emptyTokenSymbol }} ${{ env.emptyTokenDecimals }})
+          transferInfo=$(node sui/its-example.js print-receive-transfer ${{ env.sourceChain }} ${{ env.symbol }} ${{ env.sourceAddress }} ${{ env.amount }})
+          deploymentInfo=$(node sui/its-example.js print-receive-deployment ${{ env.sourceChain }} ${{ env.emptyTokenName }} ${{ env.emptyTokenSymbol }} ${{ env.emptyTokenDecimals }})
 
           echo "transferPayloadHash=$(echo $transferInfo | jq -r .payloadHash)" >> $GITHUB_ENV
           echo "transferPayload=$(echo $transferInfo | jq -r .payload)" >> $GITHUB_ENV
@@ -223,17 +223,17 @@ jobs:
 
       - name: Receive Token from another chain
         run: |
-          node sui/gateway.js approve --proof wallet $sourceChain $transferMessageId $sourceAddress $channelId $transferPayloadHash
-          node sui/its-example receive-token $sourceChain $transferMessageId $sourceAddress $symbol $transferPayload
+          node sui/gateway.js approve --proof wallet axelar $transferMessageId hub_address $channelId $transferPayloadHash
+          node sui/its-example receive-token axelar $transferMessageId hub_address $symbol $transferPayload
 
       - name: Send Token Deployment to another chain
         run: |
           node sui/its-example send-deployment $symbol $sourceChain 0.1 10
 
       - name: Receive Token Deployment from another chain
         run: |
-          node sui/gateway.js approve --proof wallet $sourceChain $deployMessageId $sourceAddress $channelId $deployPayloadHash
-          node sui/its-example receive-deployment $sourceChain $deployMessageId $sourceAddress $emptyTokenSymbol $deployPayload
+          node sui/gateway.js approve --proof wallet axelar $deployMessageId hub_address $channelId $deployPayloadHash
+          node sui/its-example receive-deployment axelar $deployMessageId hub_address $emptyTokenSymbol $deployPayload
 
       ###### Command: Operators ######
 

evm/interchainTokenFactory.js

@@ -224,22 +224,23 @@ async function processCommand(config, chain, options) {
         }
 
         case 'registerCustomToken': {
-            const { tokenAddress, tokenManagerType, operator } = options;
+            const { tokenAddress, tokenManagerType, operator, gasValue } = options;
 
             const deploymentSalt = getDeploymentSalt(options);
 
             validateParameters({
                 isValidAddress: { tokenAddress },
                 isAddress: { operator },
-                isValidNumber: { tokenManagerType },
+                isValidNumber: { tokenManagerType, gasValue },
             });
 
             const tx = await interchainTokenFactory.registerCustomToken(
                 deploymentSalt,
                 tokenAddress,
                 tokenManagerType,
                 operator,
-                gasOptions,
+                gasValue,
+                { value: gasValue, ...gasOptions },
             );
             const tokenId = await interchainTokenFactory.linkedTokenId(wallet.address, deploymentSalt);
             printInfo('tokenId', tokenId);

package.json

@@ -25,9 +25,9 @@
   "homepage": "https://github.com/axelarnetwork/axelar-contract-deployments#readme",
   "dependencies": {
     "@axelar-network/axelar-cgp-solidity": "6.4.0",
-    "@axelar-network/axelar-cgp-sui": "1.0.3",
+    "@axelar-network/axelar-cgp-sui": "0.0.0-snapshot.02915b7",
     "@axelar-network/axelar-gmp-sdk-solidity": "6.0.4",
-    "@axelar-network/interchain-token-service": "2.1.0",
+    "@axelar-network/interchain-token-service": "0.0.0-snapshot.869b412",
     "@cosmjs/cosmwasm-stargate": "^0.32.1",
     "@ledgerhq/hw-app-eth": "6.32.2",
     "@mysten/ledgerjs-hw-app-sui": "^0.4.1",

sui/deploy-contract.js

@@ -48,7 +48,7 @@ const PACKAGE_DIRS = [
     'operators',
     'abi',
     'governance',
-    'its',
+    'interchain_token_service',
     'squid',
     'interchain_token',
 ];
@@ -59,14 +59,15 @@ const PACKAGE_DIRS = [
 const PACKAGE_CONFIGS = {
     cmdOptions: {
         AxelarGateway: () => GATEWAY_CMD_OPTIONS,
+        InterchainTokenService: () => ITS_CMD_OPTIONS,
     },
     postDeployFunctions: {
         AxelarGateway: postDeployAxelarGateway,
         RelayerDiscovery: postDeployRelayerDiscovery,
         GasService: postDeployGasService,
         Example: postDeployExample,
         Operators: postDeployOperators,
-        ITS: postDeployIts,
+        InterchainTokenService: postDeployIts,
         Squid: postDeploySquid,
         Utils: postDeployUtils,
     },
@@ -136,8 +137,8 @@ async function postDeployExample(published, keypair, client, config, chain, opti
     // GMP Example Params
     const [gmpSingletonObjectId] = getObjectIdsByObjectTypes(published.publishTxn, [`${published.packageId}::gmp::Singleton`]);
 
-    // ITS Example Params
-    const itsObjectId = chain.contracts.ITS?.objects?.ITS;
+    // InterchainTokenService Example Params
+    const itsObjectId = chain.contracts.InterchainTokenService?.objects?.InterchainTokenService;
     const [itsSingletonObjectId] = getObjectIdsByObjectTypes(published.publishTxn, [`${published.packageId}::its::Singleton`]);
 
     const tx = new Transaction();
@@ -246,27 +247,41 @@ async function postDeployAxelarGateway(published, keypair, client, config, chain
 async function postDeployIts(published, keypair, client, config, chain, options) {
     const relayerDiscovery = chain.contracts.RelayerDiscovery?.objects?.RelayerDiscovery;
 
-    const [itsObjectId, itsv0ObjectId, ownerCapObjectId, upgradeCapObjectId] = getObjectIdsByObjectTypes(published.publishTxn, [
-        `${published.packageId}::its::ITS`,
-        `${published.packageId}::its_v0::ITS_v0`,
+    const { chainName, itsHubAddress } = options;
+
+    const [ownerCapObjectId, creatorCapObjectId, upgradeCapObjectId] = getObjectIdsByObjectTypes(published.publishTxn, [
         `${published.packageId}::owner_cap::OwnerCap`,
+        `${published.packageId}::creator_cap::CreatorCap`,
         `${suiPackageAddress}::package::UpgradeCap`,
     ]);
 
-    const channelId = await getItsChannelId(client, itsv0ObjectId);
+    let tx = new Transaction();
+    tx.moveCall({
+        target: `${published.packageId}::interchain_token_service::setup`,
+        arguments: [tx.object(creatorCapObjectId), tx.pure.string(chainName), tx.pure.string(itsHubAddress)],
+    });
+
+    const setupReceipt = await broadcast(client, keypair, tx, 'Setup');
+
+    const [InterchainTokenServiceObjectId, InterchainTokenServiceV0ObjectId] = getObjectIdsByObjectTypes(setupReceipt, [
+        `${published.packageId}::interchain_token_service::InterchainTokenService`,
+        `${published.packageId}::interchain_token_service_v0::InterchainTokenService_v0`,
+    ]);
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    const channelId = await getItsChannelId(client, InterchainTokenServiceV0ObjectId);
 
-    chain.contracts.ITS.objects = {
-        ITS: itsObjectId,
-        ITSv0: itsv0ObjectId,
+    chain.contracts.InterchainTokenService.objects = {
+        InterchainTokenService: InterchainTokenServiceObjectId,
+        InterchainTokenServicev0: InterchainTokenServiceV0ObjectId,
         ChannelId: channelId,
         OwnerCap: ownerCapObjectId,
         UpgradeCap: upgradeCapObjectId,
     };
 
-    const tx = new Transaction();
+    tx = new Transaction();
     tx.moveCall({
         target: `${published.packageId}::discovery::register_transaction`,
-        arguments: [tx.object(itsObjectId), tx.object(relayerDiscovery)],
+        arguments: [tx.object(InterchainTokenServiceObjectId), tx.object(relayerDiscovery)],
     });
 
     await broadcast(client, keypair, tx, 'Registered Transaction');
@@ -285,7 +300,11 @@ async function postDeploySquid(published, keypair, client, config, chain, option
     const tx = new Transaction();
     tx.moveCall({
         target: `${published.packageId}::discovery::register_transaction`,
-        arguments: [tx.object(squidObjectId), tx.object(chain.contracts.ITS.objects.ITS), tx.object(relayerDiscovery)],
+        arguments: [
+            tx.object(squidObjectId),
+            tx.object(chain.contracts.InterchainTokenService.objects.InterchainTokenService),
+            tx.object(relayerDiscovery),
+        ],
     });
 
     await broadcast(client, keypair, tx, 'Registered Transaction');
@@ -404,6 +423,8 @@ const GATEWAY_CMD_OPTIONS = [
     new Option('--previousSigners <previousSigners>', 'number of previous signers to retain').default('15'),
 ];
 
+const ITS_CMD_OPTIONS = [new Option('--itsHubAddress <itsHubAddress>', 'The address of the ITS HUB').env('ITS_HUB_ADDRESS')];
+
 const addDeployOptions = (program) => {
     // Get the package name from the program name
     const packageName = program.name();

sui/gateway.js

@@ -8,7 +8,7 @@ const {
     constants: { HashZero },
 } = ethers;
 
-const { saveConfig, printInfo, loadConfig, getMultisigProof, getChainConfig } = require('../common/utils');
+const { saveConfig, printInfo, loadConfig, getMultisigProof, getChainConfig, writeJSON } = require('../common/utils');
 const {
     addBaseOptions,
     addOptionsToCommands,
@@ -23,6 +23,7 @@ const {
 } = require('./utils');
 const secp256k1 = require('secp256k1');
 const chalk = require('chalk');
+const { readJSON } = require(`${__dirname}/../axelar-chains-config`);
 
 const COMMAND_TYPE_APPROVE_MESSAGES = 0;
 const COMMAND_TYPE_ROTATE_SIGNERS = 1;
@@ -153,6 +154,7 @@ async function approve(keypair, client, config, chain, contractConfig, args, opt
     const packageId = contractConfig.address;
     const [sourceChain, messageId, sourceAddress, destinationId, payloadHash] = args;
 
+    console.log([sourceChain, messageId, sourceAddress, destinationId, payloadHash]);
     const encodedMessages = bcs
         .vector(bcsStructs.gateway.Message)
         .serialize([
@@ -292,7 +294,6 @@ async function allowFunctions(keypair, client, config, chain, contractConfig, ar
     if (versions.length !== functionNames.length) throw new Error('Versions and Function Names must have a matching length');
 
     const tx = new Transaction();
-    console.log(contractConfig.objects);
 
     for (const i in versions) {
         tx.moveCall({
@@ -323,7 +324,6 @@ async function disallowFunctions(keypair, client, config, chain, contractConfig,
     if (versions.length !== functionNames.length) throw new Error('Versions and Function Names must have a matching length');
 
     const tx = new Transaction();
-    console.log(contractConfig.objects);
 
     for (const i in versions) {
         tx.moveCall({
@@ -509,6 +509,65 @@ async function testNewField(value, options) {
     console.log(`Set the value to ${value} and it was set to ${returnedValue}.`);
 }
 
+async function pause(keypair, client, config, chain, contracts, args, options) {
+    const response = await client.getObject({
+        id: contracts.objects.Gatewayv0,
+        options: {
+            showContent: true,
+            showBcs: true,
+        },
+    });
+    let allowedFunctionsArray = response.data.content.fields.value.fields.version_control.fields.allowed_functions;
+    allowedFunctionsArray = allowedFunctionsArray.map((allowedFunctions) => allowedFunctions.fields.contents);
+
+    const versionsArg = [];
+    const allowedFunctionsArg = [];
+
+    for (const version in allowedFunctionsArray) {
+        const allowedFunctions = allowedFunctionsArray[version];
+
+        // Do not dissalow `allow_function` because that locks the gateway forever.
+        if (Number(version) === allowedFunctionsArray.length - 1) {
+            const index = allowedFunctions.indexOf('allow_function');
+
+            if (index > -1) {
+                // only splice array when item is found
+                allowedFunctions.splice(index, 1); // 2nd parameter means remove one item only
+            }
+        }
+
+        printInfo(`Functions that will be disallowed for version ${version}`, allowedFunctions);
+
+        versionsArg.push(new Array(allowedFunctions.length).fill(version).join());
+        allowedFunctionsArg.push(allowedFunctions.join());
+    }
+
+    // Write the
+    writeJSON(
+        {
+            versions: versionsArg,
+            disallowedFunctions: allowedFunctionsArg,
+        },
+        `${__dirname}/../axelar-chains-config/info/sui-gateway-allowed-functions-${options.env}.json`,
+    );
+
+    return disallowFunctions(keypair, client, config, chain, contracts, [versionsArg.join(), allowedFunctionsArg.join()], options);
+}
+
+async function unpause(keypair, client, config, chain, contracts, args, options) {
+    const dissalowedFunctions = readJSON(`${__dirname}/../axelar-chains-config/info/sui-gateway-allowed-functions-${options.env}.json`);
+
+    return allowFunctions(
+        keypair,
+        client,
+        config,
+        chain,
+        contracts,
+        [dissalowedFunctions.versions.join(), dissalowedFunctions.disallowedFunctions.join()],
+        options,
+    );
+}
+
 async function mainProcessor(processor, args, options) {
     const config = loadConfig(options.env);
 
@@ -611,6 +670,20 @@ if (require.main === module) {
             testNewField(value, options);
         });
 
+    program
+        .command('pause')
+        .description('Pause the gateway')
+        .action((options) => {
+            mainProcessor(pause, [], options);
+        });
+
+    program
+        .command('unpause')
+        .description('Unpause the gateway')
+        .action((options) => {
+            mainProcessor(unpause, [], options);
+        });
+
     addOptionsToCommands(program, addBaseOptions, { offline: true });
 
     program.parse();