@typemove/aptos 1.2.9-rc.1 → 1.3.0-rc.1

package/src/builtin/0x3.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 * as _0x1 from "./0x1.js";
 
@@ -106,7 +105,7 @@ export namespace token {
   }
 
   export interface CreateCollectionEvent {
-    creator: Address;
+    creator: MoveAddressType;
     collection_name: string;
     uri: string;
     description: string;
@@ -136,7 +135,7 @@ export namespace token {
     description: string;
     maximum: bigint;
     uri: string;
-    royalty_payee_address: Address;
+    royalty_payee_address: MoveAddressType;
     royalty_points_denominator: bigint;
     royalty_points_numerator: bigint;
     name: string;
@@ -235,7 +234,7 @@ export namespace token {
   export interface Royalty {
     royalty_points_numerator: bigint;
     royalty_points_denominator: bigint;
-    payee_address: Address;
+    payee_address: MoveAddressType;
   }
 
   export namespace Royalty {
@@ -292,7 +291,7 @@ export namespace token {
   }
 
   export interface TokenDataId {
-    creator: Address;
+    creator: MoveAddressType;
     collection: string;
     name: string;
   }
@@ -378,7 +377,7 @@ export namespace token {
   }
 
   export interface WithdrawCapability {
-    token_owner: Address;
+    token_owner: MoveAddressType;
     token_id: token.TokenId;
     amount: bigint;
     expiration_sec: bigint;
@@ -425,86 +424,92 @@ export namespace token {
 
   export namespace entry {
     export async function burn(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, string, string, bigint, bigint];
+        typeArguments: [];
+        functionArguments: [MoveAddressType, string, string, bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::burn",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::burn",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
     export async function burnByCreator(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, string, string, bigint, bigint];
+        typeArguments: [];
+        functionArguments: [MoveAddressType, string, string, bigint, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::burn_by_creator",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::burn_by_creator",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function createCollectionScript(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [string, string, string, bigint, Boolean[]];
+        typeArguments: [];
+        functionArguments: [string, string, string, bigint, Boolean[]];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::create_collection_script",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::create_collection_script",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function createTokenScript(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [
+        typeArguments: [];
+        functionArguments: [
           string,
           string,
           string,
           bigint,
           bigint,
           string,
-          Address,
+          MoveAddressType,
           bigint,
           bigint,
           Boolean[],
@@ -513,99 +518,114 @@ export namespace token {
           string[],
         ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::create_token_script",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::create_token_script",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function directTransferScript(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, Address, string, string, bigint, bigint];
+        typeArguments: [];
+        functionArguments: [
+          MoveAddressType,
+          MoveAddressType,
+          string,
+          string,
+          bigint,
+          bigint,
+        ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::direct_transfer_script",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::direct_transfer_script",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function initializeTokenScript(
-      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,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::initialize_token_script",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::initialize_token_script",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function mintScript(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, string, string, bigint];
+        typeArguments: [];
+        functionArguments: [MoveAddressType, string, string, bigint];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::mint_script",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::mint_script",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function mutateTokenProperties(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [
-          Address,
-          Address,
+        typeArguments: [];
+        functionArguments: [
+          MoveAddressType,
+          MoveAddressType,
           string,
           string,
           bigint,
@@ -615,83 +635,99 @@ export namespace token {
           string[],
         ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::mutate_token_properties",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::mutate_token_properties",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function optInDirectTransfer(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Boolean];
+        typeArguments: [];
+        functionArguments: [Boolean];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::opt_in_direct_transfer",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::opt_in_direct_transfer",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function transferWithOptIn(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, string, string, bigint, Address, bigint];
+        typeArguments: [];
+        functionArguments: [
+          MoveAddressType,
+          string,
+          string,
+          bigint,
+          MoveAddressType,
+          bigint,
+        ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token::transfer_with_opt_in",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token::transfer_with_opt_in",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
   }
   export namespace view {
     export async function getCollectionMutabilityConfig(
-      client: AptosClient,
+      client: Aptos,
       request: {
-        arguments: [Address, string];
+        functionArguments: [MoveAddressType, string];
       },
       version?: bigint,
     ): Promise<[token.CollectionMutabilityConfig]> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const data = {
-        type_arguments: [],
-        arguments: coder.encodeArray(request.arguments),
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const data: InputViewRequestData = {
         function: "0x3::token::get_collection_mutability_config",
+        functionArguments: coder.encodeArray(request.functionArguments),
+        typeArguments: [],
       };
-      const res = await client.view(data, version?.toString());
+      const res = await client.view({
+        payload: data,
+        options: { ledgerVersion: version },
+      });
       const type = await coder.getMoveFunction(
         "0x3::token::get_collection_mutability_config",
       );
@@ -853,7 +889,7 @@ export namespace token_coin_swap {
 
   export interface TokenSwapEvent {
     token_id: token.TokenId;
-    token_buyer: Address;
+    token_buyer: MoveAddressType;
     token_amount: bigint;
     coin_amount: bigint;
     coin_type_info: _0x1.type_info.TypeInfo;
@@ -877,26 +913,36 @@ export namespace token_coin_swap {
 
   export namespace entry {
     export async function listTokenForSwap<T0 = any>(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [string];
-        arguments: [Address, string, string, bigint, bigint, bigint, bigint];
+        typeArguments: [MoveStructId];
+        functionArguments: [
+          MoveAddressType,
+          string,
+          string,
+          bigint,
+          bigint,
+          bigint,
+          bigint,
+        ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token_coin_swap::list_token_for_swap",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: request.typeArguments,
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token_coin_swap::list_token_for_swap",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
   }
   export namespace view {}
@@ -921,7 +967,7 @@ export namespace token_transfers {
   }
 
   export interface TokenCancelOfferEvent {
-    to_address: Address;
+    to_address: MoveAddressType;
     token_id: token.TokenId;
     amount: bigint;
   }
@@ -945,7 +991,7 @@ export namespace token_transfers {
   }
 
   export interface TokenClaimEvent {
-    to_address: Address;
+    to_address: MoveAddressType;
     token_id: token.TokenId;
     amount: bigint;
   }
@@ -969,7 +1015,7 @@ export namespace token_transfers {
   }
 
   export interface TokenOfferEvent {
-    to_address: Address;
+    to_address: MoveAddressType;
     token_id: token.TokenId;
     amount: bigint;
   }
@@ -993,7 +1039,7 @@ export namespace token_transfers {
   }
 
   export interface TokenOfferId {
-    to_addr: Address;
+    to_addr: MoveAddressType;
     token_id: token.TokenId;
   }
 
@@ -1015,72 +1061,100 @@ export namespace token_transfers {
 
   export namespace entry {
     export async function cancelOfferScript(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, Address, Address, string, string, bigint];
+        typeArguments: [];
+        functionArguments: [
+          MoveAddressType,
+          MoveAddressType,
+          MoveAddressType,
+          string,
+          string,
+          bigint,
+        ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token_transfers::cancel_offer_script",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token_transfers::cancel_offer_script",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function claimScript(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, Address, Address, string, string, bigint];
+        typeArguments: [];
+        functionArguments: [
+          MoveAddressType,
+          MoveAddressType,
+          MoveAddressType,
+          string,
+          string,
+          bigint,
+        ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token_transfers::claim_script",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token_transfers::claim_script",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
 
     export async function offerScript(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [];
-        arguments: [Address, Address, Address, string, string, bigint, bigint];
+        typeArguments: [];
+        functionArguments: [
+          MoveAddressType,
+          MoveAddressType,
+          MoveAddressType,
+          string,
+          string,
+          bigint,
+          bigint,
+        ];
       },
-      extraArgs?: OptionalTransactionArgs,
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl);
-      const builder = new TransactionBuilderRemoteABI(client, {
-        sender: account.address(),
-        ...extraArgs,
+      options?: InputGenerateTransactionOptions,
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode);
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "0x3::token_transfers::offer_script",
+          functionArguments: coder.encodeArray(request.functionArguments),
+          typeArguments: [],
+        },
+        options,
+      });
+      return await client.signAndSubmitTransaction({
+        signer: account,
+        transaction,
       });
-      const txn = await builder.build(
-        "0x3::token_transfers::offer_script",
-        request.type_arguments,
-        coder.encodeArray(request.arguments),
-      );
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn);
-      return await client.submitSignedBCSTransaction(bcsTxn);
     }
   }
   export namespace view {}
@@ -1088,7 +1162,7 @@ export namespace token_transfers {
 
 export namespace token_event_store {
   export interface CollectionDescriptionMutateEvent {
-    creator_addr: Address;
+    creator_addr: MoveAddressType;
     collection_name: string;
     old_description: string;
     new_description: string;
@@ -1114,7 +1188,7 @@ export namespace token_event_store {
   }
 
   export interface CollectionMaxiumMutateEvent {
-    creator_addr: Address;
+    creator_addr: MoveAddressType;
     collection_name: string;
     old_maximum: bigint;
     new_maximum: bigint;
@@ -1140,7 +1214,7 @@ export namespace token_event_store {
   }
 
   export interface CollectionUriMutateEvent {
-    creator_addr: Address;
+    creator_addr: MoveAddressType;
     collection_name: string;
     old_uri: string;
     new_uri: string;
@@ -1166,7 +1240,7 @@ export namespace token_event_store {
   }
 
   export interface DefaultPropertyMutateEvent {
-    creator: Address;
+    creator: MoveAddressType;
     collection: string;
     token: string;
     keys: string[];
@@ -1194,7 +1268,7 @@ export namespace token_event_store {
   }
 
   export interface DescriptionMutateEvent {
-    creator: Address;
+    creator: MoveAddressType;
     collection: string;
     token: string;
     old_description: string;
@@ -1220,7 +1294,7 @@ export namespace token_event_store {
   }
 
   export interface MaxiumMutateEvent {
-    creator: Address;
+    creator: MoveAddressType;
     collection: string;
     token: string;
     old_maximum: bigint;
@@ -1268,15 +1342,15 @@ export namespace token_event_store {
   }
 
   export interface RoyaltyMutateEvent {
-    creator: Address;
+    creator: MoveAddressType;
     collection: string;
     token: string;
     old_royalty_numerator: bigint;
     old_royalty_denominator: bigint;
-    old_royalty_payee_addr: Address;
+    old_royalty_payee_addr: MoveAddressType;
     new_royalty_numerator: bigint;
     new_royalty_denominator: bigint;
-    new_royalty_payee_addr: Address;
+    new_royalty_payee_addr: MoveAddressType;
   }
 
   export namespace RoyaltyMutateEvent {
@@ -1323,7 +1397,7 @@ export namespace token_event_store {
   }
 
   export interface UriMutationEvent {
-    creator: Address;
+    creator: MoveAddressType;
     collection: string;
     token: string;
     old_uri: string;