@typemove/aptos 1.0.0-rc.16 → 1.0.0-rc.18

package/dist/builtin/0x1.js

@@ -88,11 +88,12 @@ export var code;
     let entry;
     (function (entry) {
         async function publishPackageTxn(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::code::publish_package_txn", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::code::publish_package_txn", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -194,41 +195,45 @@ export var coin;
     let entry;
     (function (entry) {
         async function freezeCoinStore(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::coin::freeze_coin_store", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::coin::freeze_coin_store", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.freezeCoinStore = freezeCoinStore;
         async function transfer(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::coin::transfer", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::coin::transfer", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.transfer = transfer;
         async function unfreezeCoinStore(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::coin::unfreeze_coin_store", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::coin::unfreeze_coin_store", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.unfreezeCoinStore = unfreezeCoinStore;
         async function upgradeSupply(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::coin::upgrade_supply", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::coin::upgrade_supply", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -237,57 +242,85 @@ export var coin;
     let view;
     (function (view) {
         async function balance(client, request, version) {
-            const data = { ...request, function: "0x1::coin::balance" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::coin::balance",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::coin::balance");
             return (await coder.decodeArray(res, type.return));
         }
         view.balance = balance;
         async function decimals(client, request, version) {
-            const data = { ...request, function: "0x1::coin::decimals" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::coin::decimals",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::coin::decimals");
             return (await coder.decodeArray(res, type.return));
         }
         view.decimals = decimals;
         async function isAccountRegistered(client, request, version) {
-            const data = { ...request, function: "0x1::coin::is_account_registered" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::coin::is_account_registered",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::coin::is_account_registered");
             return (await coder.decodeArray(res, type.return));
         }
         view.isAccountRegistered = isAccountRegistered;
         async function isCoinInitialized(client, request, version) {
-            const data = { ...request, function: "0x1::coin::is_coin_initialized" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::coin::is_coin_initialized",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::coin::is_coin_initialized");
             return (await coder.decodeArray(res, type.return));
         }
         view.isCoinInitialized = isCoinInitialized;
         async function name(client, request, version) {
-            const data = { ...request, function: "0x1::coin::name" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::coin::name",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::coin::name");
             return (await coder.decodeArray(res, type.return));
         }
         view.name = name;
         async function supply(client, request, version) {
-            const data = { ...request, function: "0x1::coin::supply" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::coin::supply",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::coin::supply");
             return (await coder.decodeArray(res, type.return));
         }
         view.supply = supply;
         async function symbol(client, request, version) {
-            const data = { ...request, function: "0x1::coin::symbol" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::coin::symbol",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::coin::symbol");
             return (await coder.decodeArray(res, type.return));
         }
@@ -347,23 +380,25 @@ export var block;
     let view;
     (function (view) {
         async function getCurrentBlockHeight(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::block::get_current_block_height",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::block::get_current_block_height");
             return (await coder.decodeArray(res, type.return));
         }
         view.getCurrentBlockHeight = getCurrentBlockHeight;
         async function getEpochIntervalSecs(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::block::get_epoch_interval_secs",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::block::get_epoch_interval_secs");
             return (await coder.decodeArray(res, type.return));
         }
@@ -585,131 +620,144 @@ export var stake;
     let entry;
     (function (entry) {
         async function addStake(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::add_stake", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::add_stake", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.addStake = addStake;
         async function increaseLockup(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::increase_lockup", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::increase_lockup", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.increaseLockup = increaseLockup;
         async function initializeStakeOwner(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::initialize_stake_owner", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::initialize_stake_owner", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.initializeStakeOwner = initializeStakeOwner;
         async function initializeValidator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::initialize_validator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::initialize_validator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.initializeValidator = initializeValidator;
         async function joinValidatorSet(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::join_validator_set", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::join_validator_set", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.joinValidatorSet = joinValidatorSet;
         async function leaveValidatorSet(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::leave_validator_set", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::leave_validator_set", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.leaveValidatorSet = leaveValidatorSet;
         async function reactivateStake(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::reactivate_stake", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::reactivate_stake", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.reactivateStake = reactivateStake;
         async function rotateConsensusKey(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::rotate_consensus_key", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::rotate_consensus_key", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.rotateConsensusKey = rotateConsensusKey;
         async function setDelegatedVoter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::set_delegated_voter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::set_delegated_voter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setDelegatedVoter = setDelegatedVoter;
         async function setOperator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::set_operator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::set_operator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setOperator = setOperator;
         async function unlock(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::unlock", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::unlock", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.unlock = unlock;
         async function updateNetworkAndFullnodeAddresses(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::update_network_and_fullnode_addresses", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::update_network_and_fullnode_addresses", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.updateNetworkAndFullnodeAddresses = updateNetworkAndFullnodeAddresses;
         async function withdraw(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::stake::withdraw", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::stake::withdraw", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -718,98 +766,133 @@ export var stake;
     let view;
     (function (view) {
         async function getCurrentEpochProposalCounts(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::stake::get_current_epoch_proposal_counts",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::stake::get_current_epoch_proposal_counts");
             return (await coder.decodeArray(res, type.return));
         }
         view.getCurrentEpochProposalCounts = getCurrentEpochProposalCounts;
         async function getCurrentEpochVotingPower(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::stake::get_current_epoch_voting_power",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::stake::get_current_epoch_voting_power");
             return (await coder.decodeArray(res, type.return));
         }
         view.getCurrentEpochVotingPower = getCurrentEpochVotingPower;
         async function getDelegatedVoter(client, request, version) {
-            const data = { ...request, function: "0x1::stake::get_delegated_voter" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::stake::get_delegated_voter",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::stake::get_delegated_voter");
             return (await coder.decodeArray(res, type.return));
         }
         view.getDelegatedVoter = getDelegatedVoter;
         async function getLockupSecs(client, request, version) {
-            const data = { ...request, function: "0x1::stake::get_lockup_secs" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::stake::get_lockup_secs",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::stake::get_lockup_secs");
             return (await coder.decodeArray(res, type.return));
         }
         view.getLockupSecs = getLockupSecs;
         async function getOperator(client, request, version) {
-            const data = { ...request, function: "0x1::stake::get_operator" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::stake::get_operator",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::stake::get_operator");
             return (await coder.decodeArray(res, type.return));
         }
         view.getOperator = getOperator;
         async function getRemainingLockupSecs(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::stake::get_remaining_lockup_secs",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::stake::get_remaining_lockup_secs");
             return (await coder.decodeArray(res, type.return));
         }
         view.getRemainingLockupSecs = getRemainingLockupSecs;
         async function getStake(client, request, version) {
-            const data = { ...request, function: "0x1::stake::get_stake" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::stake::get_stake",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::stake::get_stake");
             return (await coder.decodeArray(res, type.return));
         }
         view.getStake = getStake;
         async function getValidatorConfig(client, request, version) {
-            const data = { ...request, function: "0x1::stake::get_validator_config" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::stake::get_validator_config",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::stake::get_validator_config");
             return (await coder.decodeArray(res, type.return));
         }
         view.getValidatorConfig = getValidatorConfig;
         async function getValidatorIndex(client, request, version) {
-            const data = { ...request, function: "0x1::stake::get_validator_index" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::stake::get_validator_index",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::stake::get_validator_index");
             return (await coder.decodeArray(res, type.return));
         }
         view.getValidatorIndex = getValidatorIndex;
         async function getValidatorState(client, request, version) {
-            const data = { ...request, function: "0x1::stake::get_validator_state" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::stake::get_validator_state",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::stake::get_validator_state");
             return (await coder.decodeArray(res, type.return));
         }
         view.getValidatorState = getValidatorState;
         async function stakePoolExists(client, request, version) {
-            const data = { ...request, function: "0x1::stake::stake_pool_exists" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::stake::stake_pool_exists",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::stake::stake_pool_exists");
             return (await coder.decodeArray(res, type.return));
         }
@@ -932,31 +1015,34 @@ export var object_;
     let entry;
     (function (entry) {
         async function transfer(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::object::transfer", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::object::transfer", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.transfer = transfer;
         async function transferCall(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::object::transfer_call", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::object::transfer_call", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.transferCall = transferCall;
         async function transferToObject(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::object::transfer_to_object", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::object::transfer_to_object", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -1055,104 +1141,133 @@ export var voting;
     let view;
     (function (view) {
         async function getEarlyResolutionVoteThreshold(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::voting::get_early_resolution_vote_threshold",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::voting::get_early_resolution_vote_threshold");
             return (await coder.decodeArray(res, type.return));
         }
         view.getEarlyResolutionVoteThreshold = getEarlyResolutionVoteThreshold;
         async function getExecutionHash(client, request, version) {
-            const data = { ...request, function: "0x1::voting::get_execution_hash" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::voting::get_execution_hash",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::voting::get_execution_hash");
             return (await coder.decodeArray(res, type.return));
         }
         view.getExecutionHash = getExecutionHash;
         async function getMinVoteThreshold(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::voting::get_min_vote_threshold",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::voting::get_min_vote_threshold");
             return (await coder.decodeArray(res, type.return));
         }
         view.getMinVoteThreshold = getMinVoteThreshold;
         async function getProposalCreationSecs(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::voting::get_proposal_creation_secs",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::voting::get_proposal_creation_secs");
             return (await coder.decodeArray(res, type.return));
         }
         view.getProposalCreationSecs = getProposalCreationSecs;
         async function getProposalExpirationSecs(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::voting::get_proposal_expiration_secs",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::voting::get_proposal_expiration_secs");
             return (await coder.decodeArray(res, type.return));
         }
         view.getProposalExpirationSecs = getProposalExpirationSecs;
         async function getProposalState(client, request, version) {
-            const data = { ...request, function: "0x1::voting::get_proposal_state" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::voting::get_proposal_state",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::voting::get_proposal_state");
             return (await coder.decodeArray(res, type.return));
         }
         view.getProposalState = getProposalState;
         async function getVotes(client, request, version) {
-            const data = { ...request, function: "0x1::voting::get_votes" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::voting::get_votes",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::voting::get_votes");
             return (await coder.decodeArray(res, type.return));
         }
         view.getVotes = getVotes;
         async function isMultiStepProposalInExecution(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::voting::is_multi_step_proposal_in_execution",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::voting::is_multi_step_proposal_in_execution");
             return (await coder.decodeArray(res, type.return));
         }
         view.isMultiStepProposalInExecution = isMultiStepProposalInExecution;
         async function isResolved(client, request, version) {
-            const data = { ...request, function: "0x1::voting::is_resolved" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::voting::is_resolved",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::voting::is_resolved");
             return (await coder.decodeArray(res, type.return));
         }
         view.isResolved = isResolved;
         async function isVotingClosed(client, request, version) {
-            const data = { ...request, function: "0x1::voting::is_voting_closed" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::voting::is_voting_closed",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::voting::is_voting_closed");
             return (await coder.decodeArray(res, type.return));
         }
         view.isVotingClosed = isVotingClosed;
         async function nextProposalId(client, request, version) {
-            const data = { ...request, function: "0x1::voting::next_proposal_id" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::voting::next_proposal_id",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::voting::next_proposal_id");
             return (await coder.decodeArray(res, type.return));
         }
@@ -1272,81 +1387,89 @@ export var account;
     let entry;
     (function (entry) {
         async function offerRotationCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::account::offer_rotation_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::account::offer_rotation_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.offerRotationCapability = offerRotationCapability;
         async function offerSignerCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::account::offer_signer_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::account::offer_signer_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.offerSignerCapability = offerSignerCapability;
         async function revokeAnyRotationCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::account::revoke_any_rotation_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::account::revoke_any_rotation_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.revokeAnyRotationCapability = revokeAnyRotationCapability;
         async function revokeAnySignerCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::account::revoke_any_signer_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::account::revoke_any_signer_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.revokeAnySignerCapability = revokeAnySignerCapability;
         async function revokeRotationCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::account::revoke_rotation_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::account::revoke_rotation_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.revokeRotationCapability = revokeRotationCapability;
         async function revokeSignerCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::account::revoke_signer_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::account::revoke_signer_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.revokeSignerCapability = revokeSignerCapability;
         async function rotateAuthenticationKey(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::account::rotate_authentication_key", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::account::rotate_authentication_key", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.rotateAuthenticationKey = rotateAuthenticationKey;
         async function rotateAuthenticationKeyWithRotationCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::account::rotate_authentication_key_with_rotation_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::account::rotate_authentication_key_with_rotation_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -1355,64 +1478,73 @@ export var account;
     let view;
     (function (view) {
         async function existsAt(client, request, version) {
-            const data = { ...request, function: "0x1::account::exists_at" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::account::exists_at",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::account::exists_at");
             return (await coder.decodeArray(res, type.return));
         }
         view.existsAt = existsAt;
         async function getAuthenticationKey(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::account::get_authentication_key",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::account::get_authentication_key");
             return (await coder.decodeArray(res, type.return));
         }
         view.getAuthenticationKey = getAuthenticationKey;
         async function getGuidNextCreationNum(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::account::get_guid_next_creation_num",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::account::get_guid_next_creation_num");
             return (await coder.decodeArray(res, type.return));
         }
         view.getGuidNextCreationNum = getGuidNextCreationNum;
         async function getSequenceNumber(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::account::get_sequence_number",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::account::get_sequence_number");
             return (await coder.decodeArray(res, type.return));
         }
         view.getSequenceNumber = getSequenceNumber;
         async function getSignerCapabilityOfferFor(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::account::get_signer_capability_offer_for",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::account::get_signer_capability_offer_for");
             return (await coder.decodeArray(res, type.return));
         }
         view.getSignerCapabilityOfferFor = getSignerCapabilityOfferFor;
         async function isSignerCapabilityOffered(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::account::is_signer_capability_offered",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::account::is_signer_capability_offered");
             return (await coder.decodeArray(res, type.return));
         }
@@ -1520,11 +1652,12 @@ export var version;
     let entry;
     (function (entry) {
         async function setVersion(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::version::set_version", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::version::set_version", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -1671,161 +1804,177 @@ export var vesting;
     let entry;
     (function (entry) {
         async function adminWithdraw(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::admin_withdraw", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::admin_withdraw", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.adminWithdraw = adminWithdraw;
         async function distribute(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::distribute", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::distribute", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.distribute = distribute;
         async function distributeMany(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::distribute_many", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::distribute_many", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.distributeMany = distributeMany;
         async function resetBeneficiary(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::reset_beneficiary", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::reset_beneficiary", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.resetBeneficiary = resetBeneficiary;
         async function resetLockup(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::reset_lockup", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::reset_lockup", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.resetLockup = resetLockup;
         async function setBeneficiary(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::set_beneficiary", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::set_beneficiary", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setBeneficiary = setBeneficiary;
         async function setBeneficiaryResetter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::set_beneficiary_resetter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::set_beneficiary_resetter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setBeneficiaryResetter = setBeneficiaryResetter;
         async function setManagementRole(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::set_management_role", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::set_management_role", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setManagementRole = setManagementRole;
         async function terminateVestingContract(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::terminate_vesting_contract", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::terminate_vesting_contract", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.terminateVestingContract = terminateVestingContract;
         async function unlockRewards(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::unlock_rewards", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::unlock_rewards", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.unlockRewards = unlockRewards;
         async function unlockRewardsMany(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::unlock_rewards_many", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::unlock_rewards_many", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.unlockRewardsMany = unlockRewardsMany;
         async function updateOperator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::update_operator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::update_operator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.updateOperator = updateOperator;
         async function updateOperatorWithSameCommission(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::update_operator_with_same_commission", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::update_operator_with_same_commission", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.updateOperatorWithSameCommission = updateOperatorWithSameCommission;
         async function updateVoter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::update_voter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::update_voter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.updateVoter = updateVoter;
         async function vest(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::vest", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::vest", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.vest = vest;
         async function vestMany(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::vesting::vest_many", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::vesting::vest_many", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -1834,125 +1983,169 @@ export var vesting;
     let view;
     (function (view) {
         async function accumulatedRewards(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::vesting::accumulated_rewards",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::vesting::accumulated_rewards");
             return (await coder.decodeArray(res, type.return));
         }
         view.accumulatedRewards = accumulatedRewards;
         async function beneficiary(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::beneficiary" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::beneficiary",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::beneficiary");
             return (await coder.decodeArray(res, type.return));
         }
         view.beneficiary = beneficiary;
         async function operator(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::operator" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::operator",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::operator");
             return (await coder.decodeArray(res, type.return));
         }
         view.operator = operator;
         async function operatorCommissionPercentage(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::vesting::operator_commission_percentage",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::vesting::operator_commission_percentage");
             return (await coder.decodeArray(res, type.return));
         }
         view.operatorCommissionPercentage = operatorCommissionPercentage;
         async function periodDurationSecs(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::vesting::period_duration_secs",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::vesting::period_duration_secs");
             return (await coder.decodeArray(res, type.return));
         }
         view.periodDurationSecs = periodDurationSecs;
         async function remainingGrant(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::remaining_grant" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::remaining_grant",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::remaining_grant");
             return (await coder.decodeArray(res, type.return));
         }
         view.remainingGrant = remainingGrant;
         async function shareholder(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::shareholder" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::shareholder",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::shareholder");
             return (await coder.decodeArray(res, type.return));
         }
         view.shareholder = shareholder;
         async function shareholders(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::shareholders" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::shareholders",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::shareholders");
             return (await coder.decodeArray(res, type.return));
         }
         view.shareholders = shareholders;
         async function stakePoolAddress(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::stake_pool_address" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::stake_pool_address",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::stake_pool_address");
             return (await coder.decodeArray(res, type.return));
         }
         view.stakePoolAddress = stakePoolAddress;
         async function totalAccumulatedRewards(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::vesting::total_accumulated_rewards",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::vesting::total_accumulated_rewards");
             return (await coder.decodeArray(res, type.return));
         }
         view.totalAccumulatedRewards = totalAccumulatedRewards;
         async function vestingContracts(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::vesting_contracts" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::vesting_contracts",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::vesting_contracts");
             return (await coder.decodeArray(res, type.return));
         }
         view.vestingContracts = vestingContracts;
         async function vestingSchedule(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::vesting_schedule" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::vesting_schedule",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::vesting_schedule");
             return (await coder.decodeArray(res, type.return));
         }
         view.vestingSchedule = vestingSchedule;
         async function vestingStartSecs(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::vesting_start_secs" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::vesting_start_secs",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::vesting_start_secs");
             return (await coder.decodeArray(res, type.return));
         }
         view.vestingStartSecs = vestingStartSecs;
         async function voter(client, request, version) {
-            const data = { ...request, function: "0x1::vesting::voter" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::vesting::voter",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::vesting::voter");
             return (await coder.decodeArray(res, type.return));
         }
@@ -2030,9 +2223,13 @@ export var chain_id;
     let view;
     (function (view) {
         async function get(client, request, version) {
-            const data = { ...request, function: "0x1::chain_id::get" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::chain_id::get",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::chain_id::get");
             return (await coder.decodeArray(res, type.return));
         }
@@ -2098,17 +2295,25 @@ export var timestamp;
     let view;
     (function (view) {
         async function nowMicroseconds(client, request, version) {
-            const data = { ...request, function: "0x1::timestamp::now_microseconds" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::timestamp::now_microseconds",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::timestamp::now_microseconds");
             return (await coder.decodeArray(res, type.return));
         }
         view.nowMicroseconds = nowMicroseconds;
         async function nowSeconds(client, request, version) {
-            const data = { ...request, function: "0x1::timestamp::now_seconds" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::timestamp::now_seconds",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::timestamp::now_seconds");
             return (await coder.decodeArray(res, type.return));
         }
@@ -2180,31 +2385,34 @@ export var aptos_coin;
     let entry;
     (function (entry) {
         async function claimMintCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_coin::claim_mint_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_coin::claim_mint_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.claimMintCapability = claimMintCapability;
         async function delegateMintCapability(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_coin::delegate_mint_capability", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_coin::delegate_mint_capability", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.delegateMintCapability = delegateMintCapability;
         async function mint(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_coin::mint", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_coin::mint", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -2390,17 +2598,25 @@ export var chain_status;
     let view;
     (function (view) {
         async function isGenesis(client, request, version) {
-            const data = { ...request, function: "0x1::chain_status::is_genesis" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::chain_status::is_genesis",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::chain_status::is_genesis");
             return (await coder.decodeArray(res, type.return));
         }
         view.isGenesis = isGenesis;
         async function isOperating(client, request, version) {
-            const data = { ...request, function: "0x1::chain_status::is_operating" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::chain_status::is_operating",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::chain_status::is_operating");
             return (await coder.decodeArray(res, type.return));
         }
@@ -2463,41 +2679,45 @@ export var managed_coin;
     let entry;
     (function (entry) {
         async function burn(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::managed_coin::burn", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::managed_coin::burn", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.burn = burn;
         async function initialize(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::managed_coin::initialize", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::managed_coin::initialize", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.initialize = initialize;
         async function mint(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::managed_coin::mint", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::managed_coin::mint", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.mint = mint;
         async function register(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::managed_coin::register", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::managed_coin::register", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -2599,61 +2819,67 @@ export var aptos_account;
     let entry;
     (function (entry) {
         async function batchTransfer(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_account::batch_transfer", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_account::batch_transfer", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.batchTransfer = batchTransfer;
         async function batchTransferCoins(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_account::batch_transfer_coins", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_account::batch_transfer_coins", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.batchTransferCoins = batchTransferCoins;
         async function createAccount(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_account::create_account", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_account::create_account", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createAccount = createAccount;
         async function setAllowDirectCoinTransfers(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_account::set_allow_direct_coin_transfers", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_account::set_allow_direct_coin_transfers", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setAllowDirectCoinTransfers = setAllowDirectCoinTransfers;
         async function transfer(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_account::transfer", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_account::transfer", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.transfer = transfer;
         async function transferCoins(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_account::transfer_coins", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_account::transfer_coins", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -2662,12 +2888,13 @@ export var aptos_account;
     let view;
     (function (view) {
         async function canReceiveDirectCoinTransfers(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::aptos_account::can_receive_direct_coin_transfers",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::aptos_account::can_receive_direct_coin_transfers");
             return (await coder.decodeArray(res, type.return));
         }
@@ -2733,81 +2960,89 @@ export var staking_proxy;
     let entry;
     (function (entry) {
         async function setOperator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_proxy::set_operator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_proxy::set_operator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setOperator = setOperator;
         async function setStakePoolOperator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_proxy::set_stake_pool_operator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_proxy::set_stake_pool_operator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setStakePoolOperator = setStakePoolOperator;
         async function setStakePoolVoter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_proxy::set_stake_pool_voter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_proxy::set_stake_pool_voter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setStakePoolVoter = setStakePoolVoter;
         async function setStakingContractOperator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_proxy::set_staking_contract_operator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_proxy::set_staking_contract_operator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setStakingContractOperator = setStakingContractOperator;
         async function setStakingContractVoter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_proxy::set_staking_contract_voter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_proxy::set_staking_contract_voter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setStakingContractVoter = setStakingContractVoter;
         async function setVestingContractOperator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_proxy::set_vesting_contract_operator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_proxy::set_vesting_contract_operator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setVestingContractOperator = setVestingContractOperator;
         async function setVestingContractVoter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_proxy::set_vesting_contract_voter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_proxy::set_vesting_contract_voter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setVestingContractVoter = setVestingContractVoter;
         async function setVoter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_proxy::set_voter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_proxy::set_voter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -2960,11 +3195,12 @@ export var fungible_asset;
     let entry;
     (function (entry) {
         async function transfer(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::fungible_asset::transfer", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::fungible_asset::transfer", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -2973,79 +3209,109 @@ export var fungible_asset;
     let view;
     (function (view) {
         async function balance(client, request, version) {
-            const data = { ...request, function: "0x1::fungible_asset::balance" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::fungible_asset::balance",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::fungible_asset::balance");
             return (await coder.decodeArray(res, type.return));
         }
         view.balance = balance;
         async function decimals(client, request, version) {
-            const data = { ...request, function: "0x1::fungible_asset::decimals" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::fungible_asset::decimals",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::fungible_asset::decimals");
             return (await coder.decodeArray(res, type.return));
         }
         view.decimals = decimals;
         async function isFrozen(client, request, version) {
-            const data = { ...request, function: "0x1::fungible_asset::is_frozen" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::fungible_asset::is_frozen",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::fungible_asset::is_frozen");
             return (await coder.decodeArray(res, type.return));
         }
         view.isFrozen = isFrozen;
         async function maximum(client, request, version) {
-            const data = { ...request, function: "0x1::fungible_asset::maximum" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::fungible_asset::maximum",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::fungible_asset::maximum");
             return (await coder.decodeArray(res, type.return));
         }
         view.maximum = maximum;
         async function name(client, request, version) {
-            const data = { ...request, function: "0x1::fungible_asset::name" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::fungible_asset::name",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::fungible_asset::name");
             return (await coder.decodeArray(res, type.return));
         }
         view.name = name;
         async function storeExists(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::fungible_asset::store_exists",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::fungible_asset::store_exists");
             return (await coder.decodeArray(res, type.return));
         }
         view.storeExists = storeExists;
         async function storeMetadata(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::fungible_asset::store_metadata",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::fungible_asset::store_metadata");
             return (await coder.decodeArray(res, type.return));
         }
         view.storeMetadata = storeMetadata;
         async function supply(client, request, version) {
-            const data = { ...request, function: "0x1::fungible_asset::supply" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::fungible_asset::supply",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::fungible_asset::supply");
             return (await coder.decodeArray(res, type.return));
         }
         view.supply = supply;
         async function symbol(client, request, version) {
-            const data = { ...request, function: "0x1::fungible_asset::symbol" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::fungible_asset::symbol",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::fungible_asset::symbol");
             return (await coder.decodeArray(res, type.return));
         }
@@ -3150,81 +3416,89 @@ export var delegation_pool;
     let entry;
     (function (entry) {
         async function addStake(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::delegation_pool::add_stake", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::delegation_pool::add_stake", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.addStake = addStake;
         async function initializeDelegationPool(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::delegation_pool::initialize_delegation_pool", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::delegation_pool::initialize_delegation_pool", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.initializeDelegationPool = initializeDelegationPool;
         async function reactivateStake(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::delegation_pool::reactivate_stake", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::delegation_pool::reactivate_stake", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.reactivateStake = reactivateStake;
         async function setDelegatedVoter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::delegation_pool::set_delegated_voter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::delegation_pool::set_delegated_voter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setDelegatedVoter = setDelegatedVoter;
         async function setOperator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::delegation_pool::set_operator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::delegation_pool::set_operator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.setOperator = setOperator;
         async function synchronizeDelegationPool(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::delegation_pool::synchronize_delegation_pool", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::delegation_pool::synchronize_delegation_pool", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.synchronizeDelegationPool = synchronizeDelegationPool;
         async function unlock(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::delegation_pool::unlock", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::delegation_pool::unlock", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.unlock = unlock;
         async function withdraw(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::delegation_pool::withdraw", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::delegation_pool::withdraw", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -3233,119 +3507,133 @@ export var delegation_pool;
     let view;
     (function (view) {
         async function canWithdrawPendingInactive(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::can_withdraw_pending_inactive",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::can_withdraw_pending_inactive");
             return (await coder.decodeArray(res, type.return));
         }
         view.canWithdrawPendingInactive = canWithdrawPendingInactive;
         async function delegationPoolExists(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::delegation_pool_exists",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::delegation_pool_exists");
             return (await coder.decodeArray(res, type.return));
         }
         view.delegationPoolExists = delegationPoolExists;
         async function getAddStakeFee(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::get_add_stake_fee",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::get_add_stake_fee");
             return (await coder.decodeArray(res, type.return));
         }
         view.getAddStakeFee = getAddStakeFee;
         async function getDelegationPoolStake(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::get_delegation_pool_stake",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::get_delegation_pool_stake");
             return (await coder.decodeArray(res, type.return));
         }
         view.getDelegationPoolStake = getDelegationPoolStake;
         async function getOwnedPoolAddress(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::get_owned_pool_address",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::get_owned_pool_address");
             return (await coder.decodeArray(res, type.return));
         }
         view.getOwnedPoolAddress = getOwnedPoolAddress;
         async function getPendingWithdrawal(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::get_pending_withdrawal",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::get_pending_withdrawal");
             return (await coder.decodeArray(res, type.return));
         }
         view.getPendingWithdrawal = getPendingWithdrawal;
         async function getStake(client, request, version) {
-            const data = { ...request, function: "0x1::delegation_pool::get_stake" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::delegation_pool::get_stake",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::delegation_pool::get_stake");
             return (await coder.decodeArray(res, type.return));
         }
         view.getStake = getStake;
         async function observedLockupCycle(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::observed_lockup_cycle",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::observed_lockup_cycle");
             return (await coder.decodeArray(res, type.return));
         }
         view.observedLockupCycle = observedLockupCycle;
         async function operatorCommissionPercentage(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::operator_commission_percentage",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::operator_commission_percentage");
             return (await coder.decodeArray(res, type.return));
         }
         view.operatorCommissionPercentage = operatorCommissionPercentage;
         async function ownerCapExists(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::owner_cap_exists",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::owner_cap_exists");
             return (await coder.decodeArray(res, type.return));
         }
         view.ownerCapExists = ownerCapExists;
         async function shareholdersCountActivePool(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::delegation_pool::shareholders_count_active_pool",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::delegation_pool::shareholders_count_active_pool");
             return (await coder.decodeArray(res, type.return));
         }
@@ -3489,41 +3777,45 @@ export var aptos_governance;
     let entry;
     (function (entry) {
         async function addApprovedScriptHashScript(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_governance::add_approved_script_hash_script", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_governance::add_approved_script_hash_script", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.addApprovedScriptHashScript = addApprovedScriptHashScript;
         async function createProposal(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_governance::create_proposal", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_governance::create_proposal", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createProposal = createProposal;
         async function createProposalV2(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_governance::create_proposal_v2", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_governance::create_proposal_v2", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createProposalV2 = createProposalV2;
         async function vote(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::aptos_governance::vote", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::aptos_governance::vote", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -3532,34 +3824,37 @@ export var aptos_governance;
     let view;
     (function (view) {
         async function getMinVotingThreshold(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::aptos_governance::get_min_voting_threshold",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::aptos_governance::get_min_voting_threshold");
             return (await coder.decodeArray(res, type.return));
         }
         view.getMinVotingThreshold = getMinVotingThreshold;
         async function getRequiredProposerStake(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::aptos_governance::get_required_proposer_stake",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::aptos_governance::get_required_proposer_stake");
             return (await coder.decodeArray(res, type.return));
         }
         view.getRequiredProposerStake = getRequiredProposerStake;
         async function getVotingDurationSecs(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::aptos_governance::get_voting_duration_secs",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::aptos_governance::get_voting_duration_secs");
             return (await coder.decodeArray(res, type.return));
         }
@@ -3850,151 +4145,166 @@ export var multisig_account;
     let entry;
     (function (entry) {
         async function addOwner(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::add_owner", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::add_owner", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.addOwner = addOwner;
         async function addOwners(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::add_owners", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::add_owners", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.addOwners = addOwners;
         async function approveTransaction(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::approve_transaction", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::approve_transaction", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.approveTransaction = approveTransaction;
         async function create(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::create", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::create", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.create = create;
         async function createTransaction(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::create_transaction", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::create_transaction", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createTransaction = createTransaction;
         async function createTransactionWithHash(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::create_transaction_with_hash", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::create_transaction_with_hash", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createTransactionWithHash = createTransactionWithHash;
         async function createWithExistingAccount(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::create_with_existing_account", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::create_with_existing_account", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createWithExistingAccount = createWithExistingAccount;
         async function createWithOwners(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::create_with_owners", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::create_with_owners", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createWithOwners = createWithOwners;
         async function executeRejectedTransaction(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::execute_rejected_transaction", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::execute_rejected_transaction", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.executeRejectedTransaction = executeRejectedTransaction;
         async function rejectTransaction(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::reject_transaction", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::reject_transaction", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.rejectTransaction = rejectTransaction;
         async function removeOwner(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::remove_owner", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::remove_owner", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.removeOwner = removeOwner;
         async function removeOwners(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::remove_owners", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::remove_owners", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.removeOwners = removeOwners;
         async function updateMetadata(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::update_metadata", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::update_metadata", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.updateMetadata = updateMetadata;
         async function updateSignaturesRequired(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::update_signatures_required", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::update_signatures_required", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.updateSignaturesRequired = updateSignaturesRequired;
         async function voteTransanction(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::multisig_account::vote_transanction", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::multisig_account::vote_transanction", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -4003,124 +4313,145 @@ export var multisig_account;
     let view;
     (function (view) {
         async function canBeExecuted(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::can_be_executed",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::can_be_executed");
             return (await coder.decodeArray(res, type.return));
         }
         view.canBeExecuted = canBeExecuted;
         async function canBeRejected(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::can_be_rejected",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::can_be_rejected");
             return (await coder.decodeArray(res, type.return));
         }
         view.canBeRejected = canBeRejected;
         async function getNextMultisigAccountAddress(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::get_next_multisig_account_address",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::get_next_multisig_account_address");
             return (await coder.decodeArray(res, type.return));
         }
         view.getNextMultisigAccountAddress = getNextMultisigAccountAddress;
         async function getNextTransactionPayload(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::get_next_transaction_payload",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::get_next_transaction_payload");
             return (await coder.decodeArray(res, type.return));
         }
         view.getNextTransactionPayload = getNextTransactionPayload;
         async function getPendingTransactions(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::get_pending_transactions",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::get_pending_transactions");
             return (await coder.decodeArray(res, type.return));
         }
         view.getPendingTransactions = getPendingTransactions;
         async function getTransaction(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::get_transaction",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::get_transaction");
             return (await coder.decodeArray(res, type.return));
         }
         view.getTransaction = getTransaction;
         async function lastResolvedSequenceNumber(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::last_resolved_sequence_number",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::last_resolved_sequence_number");
             return (await coder.decodeArray(res, type.return));
         }
         view.lastResolvedSequenceNumber = lastResolvedSequenceNumber;
         async function metadata(client, request, version) {
-            const data = { ...request, function: "0x1::multisig_account::metadata" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::multisig_account::metadata",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::multisig_account::metadata");
             return (await coder.decodeArray(res, type.return));
         }
         view.metadata = metadata;
         async function nextSequenceNumber(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::next_sequence_number",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::next_sequence_number");
             return (await coder.decodeArray(res, type.return));
         }
         view.nextSequenceNumber = nextSequenceNumber;
         async function numSignaturesRequired(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::multisig_account::num_signatures_required",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::multisig_account::num_signatures_required");
             return (await coder.decodeArray(res, type.return));
         }
         view.numSignaturesRequired = numSignaturesRequired;
         async function owners(client, request, version) {
-            const data = { ...request, function: "0x1::multisig_account::owners" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::multisig_account::owners",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::multisig_account::owners");
             return (await coder.decodeArray(res, type.return));
         }
         view.owners = owners;
         async function vote(client, request, version) {
-            const data = { ...request, function: "0x1::multisig_account::vote" };
-            const res = await client.view(data, version?.toString());
             const coder = defaultMoveCoder(client.nodeUrl);
+            const data = {
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
+                function: "0x1::multisig_account::vote",
+            };
+            const res = await client.view(data, version?.toString());
             const type = await coder.getMoveFunction("0x1::multisig_account::vote");
             return (await coder.decodeArray(res, type.return));
         }
@@ -4153,31 +4484,34 @@ export var resource_account;
     let entry;
     (function (entry) {
         async function createResourceAccount(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::resource_account::create_resource_account", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::resource_account::create_resource_account", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createResourceAccount = createResourceAccount;
         async function createResourceAccountAndFund(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::resource_account::create_resource_account_and_fund", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::resource_account::create_resource_account_and_fund", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createResourceAccountAndFund = createResourceAccountAndFund;
         async function createResourceAccountAndPublishPackage(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::resource_account::create_resource_account_and_publish_package", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::resource_account::create_resource_account_and_publish_package", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -4315,111 +4649,122 @@ export var staking_contract;
     let entry;
     (function (entry) {
         async function addStake(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::add_stake", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::add_stake", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.addStake = addStake;
         async function createStakingContract(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::create_staking_contract", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::create_staking_contract", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.createStakingContract = createStakingContract;
         async function distribute(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::distribute", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::distribute", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.distribute = distribute;
         async function requestCommission(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::request_commission", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::request_commission", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.requestCommission = requestCommission;
         async function resetLockup(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::reset_lockup", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::reset_lockup", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.resetLockup = resetLockup;
         async function switchOperator(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::switch_operator", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::switch_operator", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.switchOperator = switchOperator;
         async function switchOperatorWithSameCommission(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::switch_operator_with_same_commission", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::switch_operator_with_same_commission", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.switchOperatorWithSameCommission = switchOperatorWithSameCommission;
         async function unlockRewards(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::unlock_rewards", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::unlock_rewards", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.unlockRewards = unlockRewards;
         async function unlockStake(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::unlock_stake", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::unlock_stake", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.unlockStake = unlockStake;
         async function updateCommision(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::update_commision", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::update_commision", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
         entry.updateCommision = updateCommision;
         async function updateVoter(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::staking_contract::update_voter", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::staking_contract::update_voter", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -4428,67 +4773,73 @@ export var staking_contract;
     let view;
     (function (view) {
         async function commissionPercentage(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::staking_contract::commission_percentage",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::staking_contract::commission_percentage");
             return (await coder.decodeArray(res, type.return));
         }
         view.commissionPercentage = commissionPercentage;
         async function lastRecordedPrincipal(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::staking_contract::last_recorded_principal",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::staking_contract::last_recorded_principal");
             return (await coder.decodeArray(res, type.return));
         }
         view.lastRecordedPrincipal = lastRecordedPrincipal;
         async function pendingDistributionCounts(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::staking_contract::pending_distribution_counts",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::staking_contract::pending_distribution_counts");
             return (await coder.decodeArray(res, type.return));
         }
         view.pendingDistributionCounts = pendingDistributionCounts;
         async function stakePoolAddress(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::staking_contract::stake_pool_address",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::staking_contract::stake_pool_address");
             return (await coder.decodeArray(res, type.return));
         }
         view.stakePoolAddress = stakePoolAddress;
         async function stakingContractAmounts(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::staking_contract::staking_contract_amounts",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::staking_contract::staking_contract_amounts");
             return (await coder.decodeArray(res, type.return));
         }
         view.stakingContractAmounts = stakingContractAmounts;
         async function stakingContractExists(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::staking_contract::staking_contract_exists",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::staking_contract::staking_contract_exists");
             return (await coder.decodeArray(res, type.return));
         }
@@ -4566,11 +4917,12 @@ export var primary_fungible_store;
     let entry;
     (function (entry) {
         async function transfer(client, account, request, extraArgs) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const builder = new TransactionBuilderRemoteABI(client, {
                 sender: account.address(),
                 ...extraArgs,
             });
-            const txn = await builder.build("0x1::primary_fungible_store::transfer", request.type_arguments, request.arguments);
+            const txn = await builder.build("0x1::primary_fungible_store::transfer", request.type_arguments, coder.encodeArray(request.arguments));
             const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
             return await client.submitSignedBCSTransaction(bcsTxn);
         }
@@ -4579,56 +4931,61 @@ export var primary_fungible_store;
     let view;
     (function (view) {
         async function balance(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::primary_fungible_store::balance",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::primary_fungible_store::balance");
             return (await coder.decodeArray(res, type.return));
         }
         view.balance = balance;
         async function isFrozen(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::primary_fungible_store::is_frozen",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::primary_fungible_store::is_frozen");
             return (await coder.decodeArray(res, type.return));
         }
         view.isFrozen = isFrozen;
         async function primaryStore(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::primary_fungible_store::primary_store",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::primary_fungible_store::primary_store");
             return (await coder.decodeArray(res, type.return));
         }
         view.primaryStore = primaryStore;
         async function primaryStoreAddress(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::primary_fungible_store::primary_store_address",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::primary_fungible_store::primary_store_address");
             return (await coder.decodeArray(res, type.return));
         }
         view.primaryStoreAddress = primaryStoreAddress;
         async function primaryStoreExists(client, request, version) {
+            const coder = defaultMoveCoder(client.nodeUrl);
             const data = {
-                ...request,
+                type_arguments: request.type_arguments,
+                arguments: coder.encodeArray(request.arguments),
                 function: "0x1::primary_fungible_store::primary_store_exists",
             };
             const res = await client.view(data, version?.toString());
-            const coder = defaultMoveCoder(client.nodeUrl);
             const type = await coder.getMoveFunction("0x1::primary_fungible_store::primary_store_exists");
             return (await coder.decodeArray(res, type.return));
         }