@typemove/aptos 1.2.9 → 1.3.0-rc.1

package/src/tests/types/0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541.ts

@@ -9,16 +9,15 @@ import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
 
 import { defaultMoveCoder } from "@typemove/aptos";
 
-import { Address } from "@typemove/aptos";
-
 import {
-  AptosClient,
-  AptosAccount,
-  TransactionBuilderRemoteABI,
-  Types,
-  TxnBuilderTypes,
-  OptionalTransactionArgs,
-} from "aptos";
+  Aptos,
+  Account as AptosAccount,
+  MoveAddressType,
+  PendingTransactionResponse,
+  InputGenerateTransactionOptions,
+  MoveStructId,
+  InputViewRequestData,
+} from "@aptos-labs/ts-sdk";
 
 import { _0x1 } from "@typemove/aptos/builtin";
 
@@ -149,7 +148,7 @@ export namespace amm {
   }
 
   export interface SwapEvent {
-    sender_addr: Address;
+    sender_addr: MoveAddressType;
     timestamp: bigint;
     in_coin_type: string;
     out_coin_type: string;
@@ -178,297 +177,336 @@ export namespace amm {
 
   export namespace entry {
     export async function addApproximateLiquidity<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint, bigint, bigint, bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint, bigint, bigint, bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::add_approximate_liquidity",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::add_approximate_liquidity",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function addExactLiquidity<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::add_exact_liquidity",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::add_exact_liquidity",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function addLiquidity<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::add_liquidity",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::add_liquidity",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function addLiquidityWithAuxAccount<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::add_liquidity_with_aux_account",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::add_liquidity_with_aux_account",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function createPool<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::create_pool",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::create_pool",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function removeLiquidity<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::remove_liquidity",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::remove_liquidity",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function removeLiquidityWithAuxAccount<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::remove_liquidity_with_aux_account",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::remove_liquidity_with_aux_account",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function resetPool<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::reset_pool",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::reset_pool",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function swapCoinForExactCoinLimit<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint, bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint, bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::swap_coin_for_exact_coin_limit",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::swap_coin_for_exact_coin_limit",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function swapCoinForExactCoinWithSigner<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::swap_coin_for_exact_coin_with_signer",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::swap_coin_for_exact_coin_with_signer",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function swapExactCoinForCoinLimit<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::swap_exact_coin_for_coin_limit",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::swap_exact_coin_for_coin_limit",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function swapExactCoinForCoinWithSigner<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::swap_exact_coin_for_coin_with_signer",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::swap_exact_coin_for_coin_with_signer",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function updateFee<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::update_fee",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::amm::update_fee",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
   }
   export namespace view {}
@@ -522,7 +560,7 @@ export namespace util {
 
 export namespace vault {
   export interface AuxUserAccount {
-    authorized_traders: _0x1.table.Table<Address, vault.Nothing>;
+    authorized_traders: _0x1.table.Table<MoveAddressType, vault.Nothing>;
   }
 
   export namespace AuxUserAccount {
@@ -573,8 +611,8 @@ export namespace vault {
 
   export interface DepositEvent {
     coinType: string;
-    depositor: Address;
-    to: Address;
+    depositor: MoveAddressType;
+    to: MoveAddressType;
     amount_au: bigint;
   }
 
@@ -617,8 +655,8 @@ export namespace vault {
 
   export interface TransferEvent {
     coinType: string;
-    from: Address;
-    to: Address;
+    from: MoveAddressType;
+    to: MoveAddressType;
     amount_au: bigint;
   }
 
@@ -658,7 +696,7 @@ export namespace vault {
 
   export interface WithdrawEvent {
     coinType: string;
-    owner: Address;
+    owner: MoveAddressType;
     amount_au: bigint;
   }
 
@@ -681,161 +719,182 @@ export namespace vault {
 
   export namespace entry {
     export async function addAuthorizedTrader(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address];
+        typeArguments: [];
+        functionArguments: [MoveAddressType];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::add_authorized_trader",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::add_authorized_trader",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function createAuxAccount(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [];
+        typeArguments: [];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::create_aux_account",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::create_aux_account",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function createVault(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [];
+        typeArguments: [];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::create_vault",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::create_vault",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function deposit<T0 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string];
-        arguments: [Address, bigint];
+        typeArguments: [MoveStructId];
+        functionArguments: [MoveAddressType, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::deposit",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::deposit",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function removeAuthorizedTrader(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address];
+        typeArguments: [];
+        functionArguments: [MoveAddressType];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::remove_authorized_trader",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::remove_authorized_trader",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function transfer<T0 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string];
-        arguments: [Address, bigint];
+        typeArguments: [MoveStructId];
+        functionArguments: [MoveAddressType, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::transfer",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::transfer",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function withdraw<T0 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string];
-        arguments: [bigint];
+        typeArguments: [MoveStructId];
+        functionArguments: [bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::withdraw",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::vault::withdraw",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
   }
   export namespace view {}
@@ -844,49 +903,55 @@ export namespace vault {
 export namespace router {
   export namespace entry {
     export async function swapCoinForExactCoinWithSigner<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::router::swap_coin_for_exact_coin_with_signer",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::router::swap_coin_for_exact_coin_with_signer",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function swapExactCoinForCoinWithSigner<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::router::swap_exact_coin_for_coin_with_signer",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::router::swap_exact_coin_for_coin_with_signer",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
   }
   export namespace view {}
@@ -1012,70 +1077,79 @@ export namespace aux_coin {
 
   export namespace entry {
     export async function initializeAuxCoin(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [];
+        typeArguments: [];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::aux_coin::initialize_aux_coin",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::aux_coin::initialize_aux_coin",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function mint(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, bigint];
+        typeArguments: [];
+        functionArguments: [MoveAddressType, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::aux_coin::mint",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::aux_coin::mint",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function registerAccount(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [];
+        typeArguments: [];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::aux_coin::register_account",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::aux_coin::register_account",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
   }
   export namespace view {}
@@ -1084,7 +1158,7 @@ export namespace aux_coin {
 export namespace authority {
   export interface Authority {
     signer_capability: _0x1.account.SignerCapability;
-    owner_address: Address;
+    owner_address: MoveAddressType;
   }
 
   export namespace Authority {
@@ -1291,92 +1365,104 @@ export namespace fake_coin {
 
   export namespace entry {
     export async function burn<T0 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string];
-        arguments: [bigint];
+        typeArguments: [MoveStructId];
+        functionArguments: [bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::fake_coin::burn",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::fake_coin::burn",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function mint<T0 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string];
-        arguments: [bigint];
+        typeArguments: [MoveStructId];
+        functionArguments: [bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::fake_coin::mint",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::fake_coin::mint",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function register<T0 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string];
-        arguments: [];
+        typeArguments: [MoveStructId];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::fake_coin::register",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::fake_coin::register",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function registerAndMint<T0 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string];
-        arguments: [bigint];
+        typeArguments: [MoveStructId];
+        functionArguments: [bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::fake_coin::register_and_mint",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::fake_coin::register_and_mint",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
   }
   export namespace view {}
@@ -1559,7 +1645,7 @@ export namespace clob_market {
     quantity: bigint;
     aux_au_to_burn_per_lot: bigint;
     is_bid: Boolean;
-    owner_id: Address;
+    owner_id: MoveAddressType;
     timeout_timestamp: bigint;
     order_type: bigint;
     timestamp: bigint;
@@ -1636,7 +1722,7 @@ export namespace clob_market {
     quantity: bigint;
     aux_au_to_burn_per_lot: bigint;
     is_bid: Boolean;
-    owner_id: Address;
+    owner_id: MoveAddressType;
     timeout_timestamp: bigint;
     order_type: bigint;
     timestamp: bigint;
@@ -1656,7 +1742,7 @@ export namespace clob_market {
   export interface OrderCancelEvent {
     order_id: bigint;
     client_order_id: bigint;
-    owner: Address;
+    owner: MoveAddressType;
     cancel_qty: bigint;
     timestamp: bigint;
     order_type: bigint;
@@ -1685,7 +1771,7 @@ export namespace clob_market {
     order_id: bigint;
     client_order_id: bigint;
     is_bid: Boolean;
-    owner: Address;
+    owner: MoveAddressType;
     base_qty: bigint;
     price: bigint;
     fee: bigint;
@@ -1714,7 +1800,7 @@ export namespace clob_market {
   export interface OrderPlacedEvent {
     order_id: bigint;
     client_order_id: bigint;
-    owner: Address;
+    owner: MoveAddressType;
     is_bid: Boolean;
     qty: bigint;
     price: bigint;
@@ -1742,189 +1828,213 @@ export namespace clob_market {
 
   export namespace entry {
     export async function cancelAll<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [Address];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [MoveAddressType];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::cancel_all",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::cancel_all",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function cancelOrder<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [Address, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [MoveAddressType, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::cancel_order",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::cancel_order",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function createMarket<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::create_market",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::create_market",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function fastCancelOrder<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [Address, bigint, bigint, Boolean];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [MoveAddressType, bigint, bigint, Boolean];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::fast_cancel_order",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::fast_cancel_order",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function loadAllOrdersIntoEvent<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::load_all_orders_into_event",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::load_all_orders_into_event",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function loadMarketIntoEvent<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::load_market_into_event",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::load_market_into_event",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function loadOpenOrdersIntoEvent<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::load_open_orders_into_event",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::load_open_orders_into_event",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
     export async function loadOpenOrdersIntoEventForAddress<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [Address];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [MoveAddressType];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::load_open_orders_into_event_for_address",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::load_open_orders_into_event_for_address",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function placeOrder<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [
-          Address,
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [
+          MoveAddressType,
           Boolean,
           bigint,
           bigint,
@@ -1937,43 +2047,49 @@ export namespace clob_market {
           bigint,
         ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::place_order",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::place_order",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
 
     export async function updateMarketParameter<T0 = any, T1 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string, string];
-        arguments: [bigint, bigint];
+        typeArguments: [MoveStructId, MoveStructId];
+        functionArguments: [bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
-      });
-      const txn = await builder.build(
-        "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::update_market_parameter",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function:
+            "0xbd35135844473187163ca197ca93b2ab014370587bb0ed3befff9e902d6bb541::clob_market::update_market_parameter",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
+      });
     }
   }
   export namespace view {}
@@ -2002,7 +2118,7 @@ export namespace fake_markets {
 export namespace onchain_signer {
   export interface OnchainSigner {
     signer_capability: _0x1.account.SignerCapability;
-    account_address: Address;
+    account_address: MoveAddressType;
   }
 
   export namespace OnchainSigner {