@aptos-labs/ts-sdk 1.14.0-zeta.2 → 1.14.0-zeta.3

package/dist/esm/chunk-FF4JPDKD.mjs

@@ -1,315 +0,0 @@
-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-FQQW55X7.mjs

@@ -1,288 +0,0 @@
-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

package/dist/esm/chunk-FXKSE3ZP.mjs

@@ -1,25 +0,0 @@
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/crypto/publicKey.ts
-var PublicKey = class extends Serializable {
-  /**
-   * Get the public key as a hex string with a 0x prefix e.g. 0x123456...
-   */
-  toString() {
-    const bytes = this.toUint8Array();
-    return Hex.fromHexInput(bytes).toString();
-  }
-};
-var AccountPublicKey = class extends PublicKey {
-};
-
-export {
-  PublicKey,
-  AccountPublicKey
-};
-//# sourceMappingURL=chunk-FXKSE3ZP.mjs.map