@aptos-labs/ts-sdk 1.13.3 → 1.14.0-zeta.1

package/dist/esm/chunk-FF4JPDKD.mjs

@@ -0,0 +1,315 @@
+import {
+  Simulate
+} from "./chunk-W76MGKZB.mjs";
+import {
+  Submit
+} from "./chunk-7IDBB4J4.mjs";
+import {
+  Build
+} from "./chunk-7FUHWL6A.mjs";
+import {
+  TransactionManagement
+} from "./chunk-WDRH2URB.mjs";
+import {
+  getSigningMessage,
+  publicPackageTransaction,
+  rotateAuthKey,
+  signAndSubmitTransaction,
+  signTransaction
+} from "./chunk-IHNPN5CQ.mjs";
+import {
+  getGasPriceEstimation,
+  getTransactionByHash,
+  getTransactionByVersion,
+  getTransactions,
+  isTransactionPending,
+  waitForTransaction
+} from "./chunk-TBHU6ZW6.mjs";
+
+// src/api/transaction.ts
+var Transaction = class {
+  constructor(config) {
+    this.config = config;
+    this.build = new Build(this.config);
+    this.simulate = new Simulate(this.config);
+    this.submit = new Submit(this.config);
+    this.batch = new TransactionManagement(this.config);
+  }
+  /**
+   * Queries on-chain transactions. This function will not return pending
+   * transactions. For that, use `getTransactionsByHash`.
+   *
+   * @example
+   * const transactions = await aptos.getTransactions()
+   *
+   * @param args.options.offset The number transaction to start with
+   * @param args.options.limit Number of results to return
+   *
+   * @returns Array of on-chain transactions
+   */
+  async getTransactions(args) {
+    return getTransactions({
+      aptosConfig: this.config,
+      ...args
+    });
+  }
+  /**
+   * Queries on-chain transaction by version. This function will not return pending transactions.
+   *
+   * @example
+   * const transaction = await aptos.getTransactions({ledgerVersion:1})
+   *
+   * @param args.ledgerVersion - Transaction version is an unsigned 64-bit number.
+   * @returns On-chain transaction. Only on-chain transactions have versions, so this
+   * function cannot be used to query pending transactions.
+   */
+  async getTransactionByVersion(args) {
+    return getTransactionByVersion({
+      aptosConfig: this.config,
+      ...args
+    });
+  }
+  /**
+   * Queries on-chain transaction by transaction hash. This function will return pending transactions.
+   *
+   * @example
+   * const transaction = await aptos.getTransactionByHash({transactionHash:"0x123"})
+   *
+   * @param args.transactionHash - Transaction hash should be hex-encoded bytes string with 0x prefix.
+   * @returns Transaction from mempool (pending) or on-chain (committed) transaction
+   */
+  async getTransactionByHash(args) {
+    return getTransactionByHash({
+      aptosConfig: this.config,
+      ...args
+    });
+  }
+  /**
+   * Defines if specified transaction is currently in pending state
+   *
+   * To create a transaction hash:
+   *
+   * 1. Create a hash message from the bytes: "Aptos::Transaction" bytes + the BCS-serialized Transaction bytes.
+   * 2. Apply hash algorithm SHA3-256 to the hash message bytes.
+   * 3. Hex-encode the hash bytes with 0x prefix.
+   *
+   * @example
+   * const isPendingTransaction = await aptos.isPendingTransaction({transactionHash:"0x123"})
+   *
+   * @param args.transactionHash A hash of transaction
+   * @returns `true` if transaction is in pending state and `false` otherwise
+   */
+  async isPendingTransaction(args) {
+    return isTransactionPending({
+      aptosConfig: this.config,
+      ...args
+    });
+  }
+  /**
+   * Waits for a transaction to move past the pending state.
+   *
+   * There are 4 cases.
+   * 1. Transaction is successfully processed and committed to the chain.
+   *    - The function will resolve with the transaction response from the API.
+   * 2. Transaction is rejected for some reason, and is therefore not committed to the blockchain.
+   *    - The function will throw an AptosApiError with an HTTP status code indicating some problem with the request.
+   * 3. Transaction is committed but execution failed, meaning no changes were
+   *    written to the blockchain state.
+   *    - If `checkSuccess` is true, the function will throw a FailedTransactionError
+   *      If `checkSuccess` is false, the function will resolve with the transaction response where the `success` field is false.
+   * 4. Transaction does not move past the pending state within `args.options.timeoutSecs` seconds.
+   *    - The function will throw a WaitForTransactionError
+   *
+   * @example
+   * const transaction = await aptos.waitForTransaction({transactionHash:"0x123"})
+   *
+   * @param args.transactionHash The hash of a transaction previously submitted to the blockchain.
+   * @param args.options.timeoutSecs Timeout in seconds. Defaults to 20 seconds.
+   * @param args.options.checkSuccess A boolean which controls whether the function will error if the transaction failed.
+   *   Defaults to true.  See case 3 above.
+   * @returns The transaction on-chain.  See above for more details.
+   */
+  async waitForTransaction(args) {
+    return waitForTransaction({
+      aptosConfig: this.config,
+      ...args
+    });
+  }
+  /**
+   * Gives an estimate of the gas unit price required to get a
+   * transaction on chain in a reasonable amount of time.
+   * For more information {@link https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price}
+   *
+   * @returns Object holding the outputs of the estimate gas API
+   *
+   * @example
+   * const gasPrice = await aptos.waitForTransaction()
+   */
+  async getGasPriceEstimation() {
+    return getGasPriceEstimation({
+      aptosConfig: this.config
+    });
+  }
+  /**
+   * Returns a signing message for a transaction.
+   *
+   * This allows a user to sign a transaction using their own preferred signing method, and
+   * then submit it to the network.
+   *
+   * @example
+   * const transaction = await aptos.transaction.build.simple({...})
+   * const message = await aptos.getSigningMessage({transaction})
+   *
+   * @param args.transaction A raw transaction for signing elsewhere
+   */
+  // eslint-disable-next-line class-methods-use-this
+  getSigningMessage(args) {
+    return getSigningMessage(args);
+  }
+  /**
+   * Generates a transaction to publish a move package to chain.
+   *
+   * To get the `metadataBytes` and `byteCode`, can compile using Aptos CLI with command
+   * `aptos move compile --save-metadata ...`,
+   * For more info {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}
+   *
+   * @example
+   * const transaction = await aptos.publishPackageTransaction({
+   *  account: alice,
+   *  metadataBytes,
+   *  moduleBytecode: [byteCode],
+   * })
+   *
+   * @param args.account The publisher account
+   * @param args.metadataBytes The package metadata bytes
+   * @param args.moduleBytecode An array of the bytecode of each module in the package in compiler output order
+   *
+   * @returns A SimpleTransaction that can be simulated or submitted to chain
+   */
+  async publishPackageTransaction(args) {
+    return publicPackageTransaction({ aptosConfig: this.config, ...args });
+  }
+  /**
+   * Rotate an account's auth key. After rotation, only the new private key can be used to sign txns for
+   * the account.
+   * Note: Only legacy Ed25519 scheme is supported for now.
+   * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}
+   *
+   * @example
+   * const response = await aptos.rotateAuthKey({
+   *  fromAccount: alice,
+   *  toNewPrivateKey: new ED25519PublicKey("0x123"),
+   * })
+   *
+   * @param args.fromAccount The account to rotate the auth key for
+   * @param args.toNewPrivateKey The new private key to rotate to
+   *
+   * @returns PendingTransactionResponse
+   */
+  async rotateAuthKey(args) {
+    return rotateAuthKey({ aptosConfig: this.config, ...args });
+  }
+  /**
+   * Sign a transaction that can later be submitted to chain
+   *
+   * @example
+   * const transaction = await aptos.transaction.build.simple({...})
+   * const transaction = await aptos.transaction.sign({
+   *  signer: alice,
+   *  transaction
+   * })
+   *
+   * @param args.signer The signer account
+   * @param args.transaction A raw transaction to sign on
+   *
+   * @returns AccountAuthenticator
+   */
+  // eslint-disable-next-line class-methods-use-this
+  sign(args) {
+    return signTransaction({
+      ...args
+    });
+  }
+  /**
+   * Sign a transaction as a fee payer that can later be submitted to chain
+   *
+   * @example
+   * const transaction = await aptos.transaction.build.simple({...})
+   * const transaction = await aptos.transaction.signAsFeePayer({
+   *  signer: alice,
+   *  transaction
+   * })
+   *
+   * @param args.signer The fee payer signer account
+   * @param args.transaction A raw transaction to sign on
+   *
+   * @returns AccountAuthenticator
+   */
+  // eslint-disable-next-line class-methods-use-this
+  signAsFeePayer(args) {
+    const { signer, transaction } = args;
+    if (!transaction.feePayerAddress) {
+      throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);
+    }
+    transaction.feePayerAddress = signer.accountAddress;
+    return signTransaction({
+      signer,
+      transaction
+    });
+  }
+  // TRANSACTION SUBMISSION //
+  /**
+   * @deprecated Prefer to use `aptos.transaction.batch.forSingleAccount()`
+   *
+   * Batch transactions for a single account.
+   *
+   * This function uses a transaction worker that receives payloads to be processed
+   * and submitted to chain.
+   * Note that this process is best for submitting multiple transactions that
+   * dont rely on each other, i.e batch funds, batch token mints, etc.
+   *
+   * If any worker failure, the functions throws an error.
+   *
+   * @param args.sender The sender account to sign and submit the transaction
+   * @param args.data An array of transaction payloads
+   * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)
+   *
+   * @return void. Throws if any error
+   */
+  async batchTransactionsForSingleAccount(args) {
+    try {
+      const { sender, data, options } = args;
+      this.batch.forSingleAccount({ sender, data, options });
+    } catch (error) {
+      throw new Error(`failed to submit transactions with error: ${error}`);
+    }
+  }
+  /**
+   * Sign and submit a single signer transaction to chain
+   *
+   * @param args.signer The signer account to sign the transaction
+   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
+   *
+   * @example
+   * const transaction = await aptos.transaction.build.simple({...})
+   * const transaction = await aptos.signAndSubmitTransaction({
+   *  signer: alice,
+   *  transaction
+   * })
+   *
+   * @return PendingTransactionResponse
+   */
+  async signAndSubmitTransaction(args) {
+    const { signer, transaction } = args;
+    return signAndSubmitTransaction({
+      aptosConfig: this.config,
+      signer,
+      transaction
+    });
+  }
+};
+
+export {
+  Transaction
+};
+//# sourceMappingURL=chunk-FF4JPDKD.mjs.map

package/dist/esm/chunk-FF4JPDKD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/transaction.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosConfig } from \"./aptosConfig\";\nimport {\n  getGasPriceEstimation,\n  getTransactionByHash,\n  getTransactionByVersion,\n  getTransactions,\n  isTransactionPending,\n  waitForTransaction,\n} from \"../internal/transaction\";\nimport {\n  AnyNumber,\n  CommittedTransactionResponse,\n  GasEstimation,\n  HexInput,\n  PaginationArgs,\n  PendingTransactionResponse,\n  TransactionResponse,\n  WaitForTransactionOptions,\n} from \"../types\";\nimport {\n  getSigningMessage,\n  publicPackageTransaction,\n  rotateAuthKey,\n  signAndSubmitTransaction,\n  signTransaction,\n} from \"../internal/transactionSubmission\";\nimport {\n  AccountAuthenticator,\n  AnyRawTransaction,\n  InputGenerateTransactionOptions,\n  InputGenerateTransactionPayloadData,\n} from \"../transactions\";\nimport { AccountAddressInput, PrivateKey } from \"../core\";\nimport { Account } from \"../account\";\nimport { Build } from \"./transactionSubmission/build\";\nimport { Simulate } from \"./transactionSubmission/simulate\";\nimport { Submit } from \"./transactionSubmission/submit\";\nimport { TransactionManagement } from \"./transactionSubmission/management\";\nimport { SimpleTransaction } from \"../transactions/instances/simpleTransaction\";\n\nexport class Transaction {\n  readonly config: AptosConfig;\n\n  readonly build: Build;\n\n  readonly simulate: Simulate;\n\n  readonly submit: Submit;\n\n  readonly batch: TransactionManagement;\n\n  constructor(config: AptosConfig) {\n    this.config = config;\n    this.build = new Build(this.config);\n    this.simulate = new Simulate(this.config);\n    this.submit = new Submit(this.config);\n    this.batch = new TransactionManagement(this.config);\n  }\n\n  /**\n   * Queries on-chain transactions. This function will not return pending\n   * transactions. For that, use `getTransactionsByHash`.\n   *\n   * @example\n   * const transactions = await aptos.getTransactions()\n   *\n   * @param args.options.offset The number transaction to start with\n   * @param args.options.limit Number of results to return\n   *\n   * @returns Array of on-chain transactions\n   */\n  async getTransactions(args?: { options?: PaginationArgs }): Promise<TransactionResponse[]> {\n    return getTransactions({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries on-chain transaction by version. This function will not return pending transactions.\n   *\n   * @example\n   * const transaction = await aptos.getTransactions({ledgerVersion:1})\n   *\n   * @param args.ledgerVersion - Transaction version is an unsigned 64-bit number.\n   * @returns On-chain transaction. Only on-chain transactions have versions, so this\n   * function cannot be used to query pending transactions.\n   */\n  async getTransactionByVersion(args: { ledgerVersion: AnyNumber }): Promise<TransactionResponse> {\n    return getTransactionByVersion({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries on-chain transaction by transaction hash. This function will return pending transactions.\n   *\n   * @example\n   * const transaction = await aptos.getTransactionByHash({transactionHash:\"0x123\"})\n   *\n   * @param args.transactionHash - Transaction hash should be hex-encoded bytes string with 0x prefix.\n   * @returns Transaction from mempool (pending) or on-chain (committed) transaction\n   */\n  async getTransactionByHash(args: { transactionHash: HexInput }): Promise<TransactionResponse> {\n    return getTransactionByHash({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Defines if specified transaction is currently in pending state\n   *\n   * To create a transaction hash:\n   *\n   * 1. Create a hash message from the bytes: \"Aptos::Transaction\" bytes + the BCS-serialized Transaction bytes.\n   * 2. Apply hash algorithm SHA3-256 to the hash message bytes.\n   * 3. Hex-encode the hash bytes with 0x prefix.\n   *\n   * @example\n   * const isPendingTransaction = await aptos.isPendingTransaction({transactionHash:\"0x123\"})\n   *\n   * @param args.transactionHash A hash of transaction\n   * @returns `true` if transaction is in pending state and `false` otherwise\n   */\n  async isPendingTransaction(args: { transactionHash: HexInput }): Promise<boolean> {\n    return isTransactionPending({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Waits for a transaction to move past the pending state.\n   *\n   * There are 4 cases.\n   * 1. Transaction is successfully processed and committed to the chain.\n   *    - The function will resolve with the transaction response from the API.\n   * 2. Transaction is rejected for some reason, and is therefore not committed to the blockchain.\n   *    - The function will throw an AptosApiError with an HTTP status code indicating some problem with the request.\n   * 3. Transaction is committed but execution failed, meaning no changes were\n   *    written to the blockchain state.\n   *    - If `checkSuccess` is true, the function will throw a FailedTransactionError\n   *      If `checkSuccess` is false, the function will resolve with the transaction response where the `success` field is false.\n   * 4. Transaction does not move past the pending state within `args.options.timeoutSecs` seconds.\n   *    - The function will throw a WaitForTransactionError\n   *\n   * @example\n   * const transaction = await aptos.waitForTransaction({transactionHash:\"0x123\"})\n   *\n   * @param args.transactionHash The hash of a transaction previously submitted to the blockchain.\n   * @param args.options.timeoutSecs Timeout in seconds. Defaults to 20 seconds.\n   * @param args.options.checkSuccess A boolean which controls whether the function will error if the transaction failed.\n   *   Defaults to true.  See case 3 above.\n   * @returns The transaction on-chain.  See above for more details.\n   */\n  async waitForTransaction(args: {\n    transactionHash: HexInput;\n    options?: WaitForTransactionOptions;\n  }): Promise<CommittedTransactionResponse> {\n    return waitForTransaction({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Gives an estimate of the gas unit price required to get a\n   * transaction on chain in a reasonable amount of time.\n   * For more information {@link https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price}\n   *\n   * @returns Object holding the outputs of the estimate gas API\n   *\n   * @example\n   * const gasPrice = await aptos.waitForTransaction()\n   */\n  async getGasPriceEstimation(): Promise<GasEstimation> {\n    return getGasPriceEstimation({\n      aptosConfig: this.config,\n    });\n  }\n\n  /**\n   * Returns a signing message for a transaction.\n   *\n   * This allows a user to sign a transaction using their own preferred signing method, and\n   * then submit it to the network.\n   *\n   * @example\n   * const transaction = await aptos.transaction.build.simple({...})\n   * const message = await aptos.getSigningMessage({transaction})\n   *\n   * @param args.transaction A raw transaction for signing elsewhere\n   */\n  // eslint-disable-next-line class-methods-use-this\n  getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {\n    return getSigningMessage(args);\n  }\n\n  /**\n   * Generates a transaction to publish a move package to chain.\n   *\n   * To get the `metadataBytes` and `byteCode`, can compile using Aptos CLI with command\n   * `aptos move compile --save-metadata ...`,\n   * For more info {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}\n   *\n   * @example\n   * const transaction = await aptos.publishPackageTransaction({\n   *  account: alice,\n   *  metadataBytes,\n   *  moduleBytecode: [byteCode],\n   * })\n   *\n   * @param args.account The publisher account\n   * @param args.metadataBytes The package metadata bytes\n   * @param args.moduleBytecode An array of the bytecode of each module in the package in compiler output order\n   *\n   * @returns A SimpleTransaction that can be simulated or submitted to chain\n   */\n  async publishPackageTransaction(args: {\n    account: AccountAddressInput;\n    metadataBytes: HexInput;\n    moduleBytecode: Array<HexInput>;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SimpleTransaction> {\n    return publicPackageTransaction({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Rotate an account's auth key. After rotation, only the new private key can be used to sign txns for\n   * the account.\n   * Note: Only legacy Ed25519 scheme is supported for now.\n   * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}\n   *\n   * @example\n   * const response = await aptos.rotateAuthKey({\n   *  fromAccount: alice,\n   *  toNewPrivateKey: new ED25519PublicKey(\"0x123\"),\n   * })\n   *\n   * @param args.fromAccount The account to rotate the auth key for\n   * @param args.toNewPrivateKey The new private key to rotate to\n   *\n   * @returns PendingTransactionResponse\n   */\n  async rotateAuthKey(args: { fromAccount: Account; toNewPrivateKey: PrivateKey }): Promise<TransactionResponse> {\n    return rotateAuthKey({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Sign a transaction that can later be submitted to chain\n   *\n   * @example\n   * const transaction = await aptos.transaction.build.simple({...})\n   * const transaction = await aptos.transaction.sign({\n   *  signer: alice,\n   *  transaction\n   * })\n   *\n   * @param args.signer The signer account\n   * @param args.transaction A raw transaction to sign on\n   *\n   * @returns AccountAuthenticator\n   */\n  // eslint-disable-next-line class-methods-use-this\n  sign(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n    return signTransaction({\n      ...args,\n    });\n  }\n\n  /**\n   * Sign a transaction as a fee payer that can later be submitted to chain\n   *\n   * @example\n   * const transaction = await aptos.transaction.build.simple({...})\n   * const transaction = await aptos.transaction.signAsFeePayer({\n   *  signer: alice,\n   *  transaction\n   * })\n   *\n   * @param args.signer The fee payer signer account\n   * @param args.transaction A raw transaction to sign on\n   *\n   * @returns AccountAuthenticator\n   */\n  // eslint-disable-next-line class-methods-use-this\n  signAsFeePayer(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n    const { signer, transaction } = args;\n\n    // if transaction doesnt hold a \"feePayerAddress\" prop it means\n    // this is not a fee payer transaction\n    if (!transaction.feePayerAddress) {\n      throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);\n    }\n\n    // Set the feePayerAddress to the signer account address\n    transaction.feePayerAddress = signer.accountAddress;\n\n    return signTransaction({\n      signer,\n      transaction,\n    });\n  }\n\n  // TRANSACTION SUBMISSION //\n\n  /**\n   * @deprecated Prefer to use `aptos.transaction.batch.forSingleAccount()`\n   *\n   * Batch transactions for a single account.\n   *\n   * This function uses a transaction worker that receives payloads to be processed\n   * and submitted to chain.\n   * Note that this process is best for submitting multiple transactions that\n   * dont rely on each other, i.e batch funds, batch token mints, etc.\n   *\n   * If any worker failure, the functions throws an error.\n   *\n   * @param args.sender The sender account to sign and submit the transaction\n   * @param args.data An array of transaction payloads\n   * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)\n   *\n   * @return void. Throws if any error\n   */\n  async batchTransactionsForSingleAccount(args: {\n    sender: Account;\n    data: InputGenerateTransactionPayloadData[];\n    options?: Omit<InputGenerateTransactionOptions, \"accountSequenceNumber\">;\n  }): Promise<void> {\n    try {\n      const { sender, data, options } = args;\n      this.batch.forSingleAccount({ sender, data, options });\n    } catch (error: any) {\n      throw new Error(`failed to submit transactions with error: ${error}`);\n    }\n  }\n\n  /**\n   * Sign and submit a single signer transaction to chain\n   *\n   * @param args.signer The signer account to sign the transaction\n   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses\n   *\n   * @example\n   * const transaction = await aptos.transaction.build.simple({...})\n   * const transaction = await aptos.signAndSubmitTransaction({\n   *  signer: alice,\n   *  transaction\n   * })\n   *\n   * @return PendingTransactionResponse\n   */\n  async signAndSubmitTransaction(args: {\n    signer: Account;\n    transaction: AnyRawTransaction;\n  }): Promise<PendingTransactionResponse> {\n    const { signer, transaction } = args;\n    return signAndSubmitTransaction({\n      aptosConfig: this.config,\n      signer,\n      transaction,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CO,IAAM,cAAN,MAAkB;AAAA,EAWvB,YAAY,QAAqB;AAC/B,SAAK,SAAS;AACd,SAAK,QAAQ,IAAI,MAAM,KAAK,MAAM;AAClC,SAAK,WAAW,IAAI,SAAS,KAAK,MAAM;AACxC,SAAK,SAAS,IAAI,OAAO,KAAK,MAAM;AACpC,SAAK,QAAQ,IAAI,sBAAsB,KAAK,MAAM;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,MAAM,gBAAgB,MAAqE;AACzF,WAAO,gBAAgB;AAAA,MACrB,aAAa,KAAK;AAAA,MAClB,GAAG;AAAA,IACL,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,wBAAwB,MAAkE;AAC9F,WAAO,wBAAwB;AAAA,MAC7B,aAAa,KAAK;AAAA,MAClB,GAAG;AAAA,IACL,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAM,qBAAqB,MAAmE;AAC5F,WAAO,qBAAqB;AAAA,MAC1B,aAAa,KAAK;AAAA,MAClB,GAAG;AAAA,IACL,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,MAAM,qBAAqB,MAAuD;AAChF,WAAO,qBAAqB;AAAA,MAC1B,aAAa,KAAK;AAAA,MAClB,GAAG;AAAA,IACL,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0BA,MAAM,mBAAmB,MAGiB;AACxC,WAAO,mBAAmB;AAAA,MACxB,aAAa,KAAK;AAAA,MAClB,GAAG;AAAA,IACL,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,wBAAgD;AACpD,WAAO,sBAAsB;AAAA,MAC3B,aAAa,KAAK;AAAA,IACpB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,kBAAkB,MAAsD;AACtE,WAAO,kBAAkB,IAAI;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBA,MAAM,0BAA0B,MAKD;AAC7B,WAAO,yBAAyB,EAAE,aAAa,KAAK,QAAQ,GAAG,KAAK,CAAC;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAAM,cAAc,MAA2F;AAC7G,WAAO,cAAc,EAAE,aAAa,KAAK,QAAQ,GAAG,KAAK,CAAC;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,KAAK,MAAiF;AACpF,WAAO,gBAAgB;AAAA,MACrB,GAAG;AAAA,IACL,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,eAAe,MAAiF;AAC9F,UAAM,EAAE,QAAQ,YAAY,IAAI;AAIhC,QAAI,CAAC,YAAY,iBAAiB;AAChC,YAAM,IAAI,MAAM,eAAe,WAAW,iCAAiC;AAAA,IAC7E;AAGA,gBAAY,kBAAkB,OAAO;AAErC,WAAO,gBAAgB;AAAA,MACrB;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBA,MAAM,kCAAkC,MAItB;AAChB,QAAI;AACF,YAAM,EAAE,QAAQ,MAAM,QAAQ,IAAI;AAClC,WAAK,MAAM,iBAAiB,EAAE,QAAQ,MAAM,QAAQ,CAAC;AAAA,IACvD,SAAS,OAAY;AACnB,YAAM,IAAI,MAAM,6CAA6C,KAAK,EAAE;AAAA,IACtE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,MAAM,yBAAyB,MAGS;AACtC,UAAM,EAAE,QAAQ,YAAY,IAAI;AAChC,WAAO,yBAAyB;AAAA,MAC9B,aAAa,KAAK;AAAA,MAClB;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/esm/chunk-FQQW55X7.mjs

@@ -0,0 +1,288 @@
+import {
+  Hex
+} from "./chunk-YV7M4CFP.mjs";
+import {
+  MAX_U128_BIG_INT,
+  MAX_U16_NUMBER,
+  MAX_U256_BIG_INT,
+  MAX_U32_NUMBER,
+  MAX_U64_BIG_INT,
+  MAX_U8_NUMBER
+} from "./chunk-SBB4YEPT.mjs";
+import {
+  __decorateClass
+} from "./chunk-OR7TEZ25.mjs";
+
+// src/bcs/serializer.ts
+var Serializable = class {
+  /**
+   * Serializes a `Serializable` value to its BCS representation.
+   * This function is the Typescript SDK equivalent of `bcs::to_bytes` in Move.
+   * @returns the BCS representation of the Serializable instance as a byte buffer
+   */
+  bcsToBytes() {
+    const serializer = new Serializer();
+    this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+  /**
+   * Helper function to get a value's BCS-serialized bytes as a Hex instance.
+   * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array
+   */
+  bcsToHex() {
+    const bcsBytes = this.bcsToBytes();
+    return Hex.fromHexInput(bcsBytes);
+  }
+};
+var Serializer = class {
+  // Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.
+  // `length` must be greater than 0.
+  constructor(length = 64) {
+    if (length <= 0) {
+      throw new Error("Length needs to be greater than 0");
+    }
+    this.buffer = new ArrayBuffer(length);
+    this.offset = 0;
+  }
+  ensureBufferWillHandleSize(bytes) {
+    while (this.buffer.byteLength < this.offset + bytes) {
+      const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);
+      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
+      this.buffer = newBuffer;
+    }
+  }
+  appendToBuffer(values) {
+    this.ensureBufferWillHandleSize(values.length);
+    new Uint8Array(this.buffer, this.offset).set(values);
+    this.offset += values.length;
+  }
+  serializeWithFunction(fn, bytesLength, value) {
+    this.ensureBufferWillHandleSize(bytesLength);
+    const dv = new DataView(this.buffer, this.offset);
+    fn.apply(dv, [0, value, true]);
+    this.offset += bytesLength;
+  }
+  /**
+   * Serializes a string. UTF8 string is supported.
+   *
+   * The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer.
+   * Then the string content is serialized as UTF8 encoded bytes.
+   *
+   * BCS layout for "string": string_length | string_content
+   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
+   *
+   * @example
+   * ```ts
+   * const serializer = new Serializer();
+   * serializer.serializeStr("1234abcd");
+   * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
+   * ```
+   */
+  serializeStr(value) {
+    const textEncoder = new TextEncoder();
+    this.serializeBytes(textEncoder.encode(value));
+  }
+  /**
+   * Serializes an array of bytes.
+   *
+   * BCS layout for "bytes": bytes_length | bytes
+   * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
+   */
+  serializeBytes(value) {
+    this.serializeU32AsUleb128(value.length);
+    this.appendToBuffer(value);
+  }
+  /**
+   * Serializes an array of bytes with known length. Therefore, length doesn't need to be
+   * serialized to help deserialization.
+   *
+   * When deserializing, the number of bytes to deserialize needs to be passed in.
+   */
+  serializeFixedBytes(value) {
+    this.appendToBuffer(value);
+  }
+  /**
+   * Serializes a boolean value.
+   *
+   * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
+   */
+  serializeBool(value) {
+    ensureBoolean(value);
+    const byteValue = value ? 1 : 0;
+    this.appendToBuffer(new Uint8Array([byteValue]));
+  }
+  serializeU8(value) {
+    this.appendToBuffer(new Uint8Array([value]));
+  }
+  serializeU16(value) {
+    this.serializeWithFunction(DataView.prototype.setUint16, 2, value);
+  }
+  serializeU32(value) {
+    this.serializeWithFunction(DataView.prototype.setUint32, 4, value);
+  }
+  serializeU64(value) {
+    const low = BigInt(value) & BigInt(MAX_U32_NUMBER);
+    const high = BigInt(value) >> BigInt(32);
+    this.serializeU32(Number(low));
+    this.serializeU32(Number(high));
+  }
+  serializeU128(value) {
+    const low = BigInt(value) & MAX_U64_BIG_INT;
+    const high = BigInt(value) >> BigInt(64);
+    this.serializeU64(low);
+    this.serializeU64(high);
+  }
+  serializeU256(value) {
+    const low = BigInt(value) & MAX_U128_BIG_INT;
+    const high = BigInt(value) >> BigInt(128);
+    this.serializeU128(low);
+    this.serializeU128(high);
+  }
+  serializeU32AsUleb128(val) {
+    let value = val;
+    const valueArray = [];
+    while (value >>> 7 !== 0) {
+      valueArray.push(value & 127 | 128);
+      value >>>= 7;
+    }
+    valueArray.push(value);
+    this.appendToBuffer(new Uint8Array(valueArray));
+  }
+  /**
+   * Returns the buffered bytes
+   */
+  toUint8Array() {
+    return new Uint8Array(this.buffer).slice(0, this.offset);
+  }
+  /**
+   * Serializes a `Serializable` value, facilitating composable serialization.
+   *
+   * @param value The Serializable value to serialize
+   *
+   * @example
+   * // Define the MoveStruct class that implements the Serializable interface
+   * class MoveStruct extends Serializable {
+   *     constructor(
+   *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable
+   *         public collectionName: string,
+   *         public tokenName: string
+   *     ) {}
+   *
+   *     serialize(serializer: Serializer): void {
+   *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object
+   *         serializer.serializeStr(this.collectionName);
+   *         serializer.serializeStr(this.tokenName);
+   *     }
+   * }
+   *
+   * // Construct a MoveStruct
+   * const moveStruct = new MoveStruct(new AccountAddress(...), "MyCollection", "TokenA");
+   *
+   * // Serialize a string, a u64 number, and a MoveStruct instance.
+   * const serializer = new Serializer();
+   * serializer.serializeStr("ExampleString");
+   * serializer.serializeU64(12345678);
+   * serializer.serialize(moveStruct);
+   *
+   * // Get the bytes from the Serializer instance
+   * const serializedBytes = serializer.toUint8Array();
+   *
+   * @returns the serializer instance
+   */
+  serialize(value) {
+    value.serialize(this);
+  }
+  /**
+   * Serializes an array of BCS Serializable values to a serializer instance.
+   * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
+   *
+   * @param values The array of BCS Serializable values
+   * @example
+   * const addresses = new Array<AccountAddress>(
+   *   AccountAddress.from("0x1"),
+   *   AccountAddress.from("0x2"),
+   *   AccountAddress.from("0xa"),
+   *   AccountAddress.from("0xb"),
+   * );
+   * const serializer = new Serializer();
+   * serializer.serializeVector(addresses);
+   * const serializedBytes = serializer.toUint8Array();
+   * // serializedBytes is now the BCS-serialized bytes
+   * // The equivalent value in Move would be:
+   * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
+   */
+  serializeVector(values) {
+    this.serializeU32AsUleb128(values.length);
+    values.forEach((item) => {
+      item.serialize(this);
+    });
+  }
+  serializeOption(value) {
+    if (value === void 0) {
+      this.serializeU32AsUleb128(0);
+    } else {
+      this.serializeU32AsUleb128(1);
+      value.serialize(this);
+    }
+  }
+  serializeOptionStr(value) {
+    if (value === void 0) {
+      this.serializeU32AsUleb128(0);
+    } else {
+      this.serializeU32AsUleb128(1);
+      this.serializeStr(value);
+    }
+  }
+};
+__decorateClass([
+  checkNumberRange(0, MAX_U8_NUMBER)
+], Serializer.prototype, "serializeU8", 1);
+__decorateClass([
+  checkNumberRange(0, MAX_U16_NUMBER)
+], Serializer.prototype, "serializeU16", 1);
+__decorateClass([
+  checkNumberRange(0, MAX_U32_NUMBER)
+], Serializer.prototype, "serializeU32", 1);
+__decorateClass([
+  checkNumberRange(BigInt(0), MAX_U64_BIG_INT)
+], Serializer.prototype, "serializeU64", 1);
+__decorateClass([
+  checkNumberRange(BigInt(0), MAX_U128_BIG_INT)
+], Serializer.prototype, "serializeU128", 1);
+__decorateClass([
+  checkNumberRange(BigInt(0), MAX_U256_BIG_INT)
+], Serializer.prototype, "serializeU256", 1);
+__decorateClass([
+  checkNumberRange(0, MAX_U32_NUMBER)
+], Serializer.prototype, "serializeU32AsUleb128", 1);
+function ensureBoolean(value) {
+  if (typeof value !== "boolean") {
+    throw new Error(`${value} is not a boolean value`);
+  }
+}
+var outOfRangeErrorMessage = (value, min, max) => `${value} is out of range: [${min}, ${max}]`;
+function validateNumberInRange(value, minValue, maxValue) {
+  const valueBigInt = BigInt(value);
+  if (valueBigInt > BigInt(maxValue) || valueBigInt < BigInt(minValue)) {
+    throw new Error(outOfRangeErrorMessage(value, minValue, maxValue));
+  }
+}
+function checkNumberRange(minValue, maxValue) {
+  return (target, propertyKey, descriptor) => {
+    const childFunction = descriptor.value;
+    descriptor.value = function deco(value) {
+      validateNumberInRange(value, minValue, maxValue);
+      return childFunction.apply(this, [value]);
+    };
+    return descriptor;
+  };
+}
+
+export {
+  Serializable,
+  Serializer,
+  ensureBoolean,
+  outOfRangeErrorMessage,
+  validateNumberInRange
+};
+//# sourceMappingURL=chunk-FQQW55X7.mjs.map