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

package/dist/esm/chunk-AC3OGAL6.mjs

@@ -1,87 +0,0 @@
-// src/transactions/management/asyncQueue.ts
-var AsyncQueue = class {
-  constructor() {
-    this.queue = [];
-    // The pendingDequeue is used to handle the resolution of promises when items are enqueued and dequeued.
-    this.pendingDequeue = [];
-    this.cancelled = false;
-  }
-  /**
-   * The enqueue method adds an item to the queue. If there are pending dequeued promises,
-   * in the pendingDequeue, it resolves the oldest promise with the enqueued item immediately.
-   * Otherwise, it adds the item to the queue.
-   *
-   * @param item T
-   */
-  enqueue(item) {
-    this.cancelled = false;
-    if (this.pendingDequeue.length > 0) {
-      const promise = this.pendingDequeue.shift();
-      promise?.resolve(item);
-      return;
-    }
-    this.queue.push(item);
-  }
-  /**
-   * The dequeue method returns a promise that resolves to the next item in the queue.
-   * If the queue is not empty, it resolves the promise immediately with the next item.
-   * Otherwise, it creates a new promise. The promise's resolve function is stored
-   * in the pendingDequeue with a unique counter value as the key.
-   * The newly created promise is then returned, and it will be resolved later when an item is enqueued.
-   *
-   * @returns Promise<T>
-   */
-  async dequeue() {
-    if (this.queue.length > 0) {
-      return Promise.resolve(this.queue.shift());
-    }
-    return new Promise((resolve, reject) => {
-      this.pendingDequeue.push({ resolve, reject });
-    });
-  }
-  /**
-   * The isEmpty method returns whether the queue is empty or not.
-   *
-   * @returns boolean
-   */
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-  /**
-   * The cancel method cancels all pending promises in the queue.
-   * It rejects the promises with a AsyncQueueCancelledError error,
-   * ensuring that any awaiting code can handle the cancellation appropriately.
-   */
-  cancel() {
-    this.cancelled = true;
-    this.pendingDequeue.forEach(async ({ reject }) => {
-      reject(new AsyncQueueCancelledError("Task cancelled"));
-    });
-    this.pendingDequeue = [];
-    this.queue.length = 0;
-  }
-  /**
-   * The isCancelled method returns whether the queue is cancelled or not.
-   *
-   * @returns boolean
-   */
-  isCancelled() {
-    return this.cancelled;
-  }
-  /**
-   * The pendingDequeueLength method returns the length of the pendingDequeue.
-   *
-   * @returns number
-   */
-  pendingDequeueLength() {
-    return this.pendingDequeue.length;
-  }
-};
-var AsyncQueueCancelledError = class extends Error {
-};
-
-export {
-  AsyncQueue,
-  AsyncQueueCancelledError
-};
-//# sourceMappingURL=chunk-AC3OGAL6.mjs.map

package/dist/esm/chunk-AR7X6GWQ.mjs

@@ -1,356 +0,0 @@
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-WK5ZSNE2.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/bcs/serializable/moveStructs.ts
-var MoveVector = class _MoveVector extends Serializable {
-  constructor(values) {
-    super();
-    this.values = values;
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  /**
-   * NOTE: This function will only work when the inner values in the `MoveVector` are `U8`s.
-   * @param serializer
-   */
-  serializeForScriptFunction(serializer) {
-    const isU8 = this.values[0] instanceof U8;
-    if (!isU8 && this.values[0] !== void 0) {
-      throw new Error("Script function arguments only accept u8 vectors");
-    }
-    serializer.serializeU32AsUleb128(4 /* U8Vector */);
-    serializer.serialize(this);
-  }
-  /**
-   * Factory method to generate a MoveVector of U8s from an array of numbers.
-   *
-   * @example
-   * const v = MoveVector.U8([1, 2, 3, 4]);
-   * @params values: an array of `numbers` to convert to U8s
-   * @returns a `MoveVector<U8>`
-   */
-  static U8(values) {
-    let numbers;
-    if (Array.isArray(values) && typeof values[0] === "number") {
-      numbers = values;
-    } else if (typeof values === "string") {
-      const hex = Hex.fromHexInput(values);
-      numbers = Array.from(hex.toUint8Array());
-    } else if (values instanceof Uint8Array) {
-      numbers = Array.from(values);
-    } else {
-      throw new Error("Invalid input type");
-    }
-    return new _MoveVector(numbers.map((v) => new U8(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U16s from an array of numbers.
-   *
-   * @example
-   * const v = MoveVector.U16([1, 2, 3, 4]);
-   * @params values: an array of `numbers` to convert to U16s
-   * @returns a `MoveVector<U16>`
-   */
-  static U16(values) {
-    return new _MoveVector(values.map((v) => new U16(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U32s from an array of numbers.
-   *
-   * @example
-   * const v = MoveVector.U32([1, 2, 3, 4]);
-   * @params values: an array of `numbers` to convert to U32s
-   * @returns a `MoveVector<U32>`
-   */
-  static U32(values) {
-    return new _MoveVector(values.map((v) => new U32(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U64s from an array of numbers or bigints.
-   *
-   * @example
-   * const v = MoveVector.U64([1, 2, 3, 4]);
-   * @params values: an array of numbers of type `number | bigint` to convert to U64s
-   * @returns a `MoveVector<U64>`
-   */
-  static U64(values) {
-    return new _MoveVector(values.map((v) => new U64(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U128s from an array of numbers or bigints.
-   *
-   * @example
-   * const v = MoveVector.U128([1, 2, 3, 4]);
-   * @params values: an array of numbers of type `number | bigint` to convert to U128s
-   * @returns a `MoveVector<U128>`
-   */
-  static U128(values) {
-    return new _MoveVector(values.map((v) => new U128(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U256s from an array of numbers or bigints.
-   *
-   * @example
-   * const v = MoveVector.U256([1, 2, 3, 4]);
-   * @params values: an array of numbers of type `number | bigint` to convert to U256s
-   * @returns a `MoveVector<U256>`
-   */
-  static U256(values) {
-    return new _MoveVector(values.map((v) => new U256(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of Bools from an array of booleans.
-   *
-   * @example
-   * const v = MoveVector.Bool([true, false, true, false]);
-   * @params values: an array of `bools` to convert to Bools
-   * @returns a `MoveVector<Bool>`
-   */
-  static Bool(values) {
-    return new _MoveVector(values.map((v) => new Bool(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of MoveStrings from an array of strings.
-   *
-   * @example
-   * const v = MoveVector.MoveString(["hello", "world"]);
-   * @params values: an array of `strings` to convert to MoveStrings
-   * @returns a `MoveVector<MoveString>`
-   */
-  static MoveString(values) {
-    return new _MoveVector(values.map((v) => new MoveString(v)));
-  }
-  serialize(serializer) {
-    serializer.serializeVector(this.values);
-  }
-  /**
-   * Deserialize a MoveVector of type T, specifically where T is a Serializable and Deserializable type.
-   *
-   * NOTE: This only works with a depth of one. Generics will not work.
-   *
-   * NOTE: This will not work with types that aren't of the Serializable class.
-   *
-   * If you're looking for a more flexible deserialization function, you can use the deserializeVector function
-   * in the Deserializer class.
-   *
-   * @example
-   * const vec = MoveVector.deserialize(deserializer, U64);
-   * @params deserializer: the Deserializer instance to use, with bytes loaded into it already.
-   * cls: the class to typecast the input values to, must be a Serializable and Deserializable type.
-   * @returns a MoveVector of the corresponding class T
-   * *
-   */
-  static deserialize(deserializer, cls) {
-    const length = deserializer.deserializeUleb128AsU32();
-    const values = new Array();
-    for (let i = 0; i < length; i += 1) {
-      values.push(cls.deserialize(deserializer));
-    }
-    return new _MoveVector(values);
-  }
-};
-var MoveString = class _MoveString extends Serializable {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeStr(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    const fixedStringBytes = this.bcsToBytes().slice(1);
-    const vectorU8 = MoveVector.U8(fixedStringBytes);
-    vectorU8.serializeForScriptFunction(serializer);
-  }
-  static deserialize(deserializer) {
-    return new _MoveString(deserializer.deserializeStr());
-  }
-};
-var MoveOption = class _MoveOption extends Serializable {
-  constructor(value) {
-    super();
-    if (typeof value !== "undefined" && value !== null) {
-      this.vec = new MoveVector([value]);
-    } else {
-      this.vec = new MoveVector([]);
-    }
-    [this.value] = this.vec.values;
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  /**
-   * Retrieves the inner value of the MoveOption.
-   *
-   * This method is inspired by Rust's `Option<T>.unwrap()`.
-   * In Rust, attempting to unwrap a `None` value results in a panic.
-   *
-   * Similarly, this method will throw an error if the value is not present.
-   *
-   * @example
-   * const option = new MoveOption<Bool>(new Bool(true));
-   * const value = option.unwrap();  // Returns the Bool instance
-   *
-   * @throws {Error} Throws an error if the MoveOption does not contain a value.
-   *
-   * @returns {T} The contained value if present.
-   */
-  unwrap() {
-    if (!this.isSome()) {
-      throw new Error("Called unwrap on a MoveOption with no value");
-    } else {
-      return this.vec.values[0];
-    }
-  }
-  // Check if the MoveOption has a value.
-  isSome() {
-    return this.vec.values.length === 1;
-  }
-  serialize(serializer) {
-    this.vec.serialize(serializer);
-  }
-  /**
-   * Factory method to generate a MoveOption<U8> from a `number` or `undefined`.
-   *
-   * @example
-   * MoveOption.U8(1).isSome() === true;
-   * MoveOption.U8().isSome() === false;
-   * MoveOption.U8(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U8> with an inner value `value`
-   */
-  static U8(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U8(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U16> from a `number` or `undefined`.
-   *
-   * @example
-   * MoveOption.U16(1).isSome() === true;
-   * MoveOption.U16().isSome() === false;
-   * MoveOption.U16(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U16> with an inner value `value`
-   */
-  static U16(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U16(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U32> from a `number` or `undefined`.
-   *
-   * @example
-   * MoveOption.U32(1).isSome() === true;
-   * MoveOption.U32().isSome() === false;
-   * MoveOption.U32(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U32> with an inner value `value`
-   */
-  static U32(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U32(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U64> from a `number` or a `bigint` or `undefined`.
-   *
-   * @example
-   * MoveOption.U64(1).isSome() === true;
-   * MoveOption.U64().isSome() === false;
-   * MoveOption.U64(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U64> with an inner value `value`
-   */
-  static U64(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U64(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U128> from a `number` or a `bigint` or `undefined`.
-   *
-   * @example
-   * MoveOption.U128(1).isSome() === true;
-   * MoveOption.U128().isSome() === false;
-   * MoveOption.U128(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U128> with an inner value `value`
-   */
-  static U128(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U128(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U256> from a `number` or a `bigint` or `undefined`.
-   *
-   * @example
-   * MoveOption.U256(1).isSome() === true;
-   * MoveOption.U256().isSome() === false;
-   * MoveOption.U256(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U256> with an inner value `value`
-   */
-  static U256(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U256(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<Bool> from a `boolean` or `undefined`.
-   *
-   * @example
-   * MoveOption.Bool(true).isSome() === true;
-   * MoveOption.Bool().isSome() === false;
-   * MoveOption.Bool(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<Bool> with an inner value `value`
-   */
-  static Bool(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new Bool(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<MoveString> from a `string` or `undefined`.
-   *
-   * @example
-   * MoveOption.MoveString("hello").isSome() === true;
-   * MoveOption.MoveString("").isSome() === true;
-   * MoveOption.MoveString().isSome() === false;
-   * MoveOption.MoveString(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<MoveString> with an inner value `value`
-   */
-  static MoveString(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new MoveString(value) : void 0);
-  }
-  static deserialize(deserializer, cls) {
-    const vector = MoveVector.deserialize(deserializer, cls);
-    return new _MoveOption(vector.values[0]);
-  }
-};
-
-export {
-  MoveVector,
-  MoveString,
-  MoveOption
-};
-//# sourceMappingURL=chunk-AR7X6GWQ.mjs.map

package/dist/esm/chunk-ASF2VWOX.mjs

@@ -1,142 +0,0 @@
-import {
-  AccountAuthenticator
-} from "./chunk-IC56GQFJ.mjs";
-import {
-  MultiEd25519PublicKey,
-  MultiEd25519Signature
-} from "./chunk-UKU6A2W2.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-
-// src/transactions/authenticator/transaction.ts
-var TransactionAuthenticator = class extends Serializable {
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Ed25519 */:
-        return TransactionAuthenticatorEd25519.load(deserializer);
-      case 1 /* MultiEd25519 */:
-        return TransactionAuthenticatorMultiEd25519.load(deserializer);
-      case 2 /* MultiAgent */:
-        return TransactionAuthenticatorMultiAgent.load(deserializer);
-      case 3 /* FeePayer */:
-        return TransactionAuthenticatorFeePayer.load(deserializer);
-      case 4 /* SingleSender */:
-        return TransactionAuthenticatorSingleSender.load(deserializer);
-      default:
-        throw new Error(`Unknown variant index for TransactionAuthenticator: ${index}`);
-    }
-  }
-};
-var TransactionAuthenticatorEd25519 = class _TransactionAuthenticatorEd25519 extends TransactionAuthenticator {
-  constructor(public_key, signature) {
-    super();
-    this.public_key = public_key;
-    this.signature = signature;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* Ed25519 */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_key = Ed25519PublicKey.deserialize(deserializer);
-    const signature = Ed25519Signature.deserialize(deserializer);
-    return new _TransactionAuthenticatorEd25519(public_key, signature);
-  }
-};
-var TransactionAuthenticatorMultiEd25519 = class _TransactionAuthenticatorMultiEd25519 extends TransactionAuthenticator {
-  constructor(public_key, signature) {
-    super();
-    this.public_key = public_key;
-    this.signature = signature;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(1 /* MultiEd25519 */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_key = MultiEd25519PublicKey.deserialize(deserializer);
-    const signature = MultiEd25519Signature.deserialize(deserializer);
-    return new _TransactionAuthenticatorMultiEd25519(public_key, signature);
-  }
-};
-var TransactionAuthenticatorMultiAgent = class _TransactionAuthenticatorMultiAgent extends TransactionAuthenticator {
-  constructor(sender, secondary_signer_addresses, secondary_signers) {
-    super();
-    this.sender = sender;
-    this.secondary_signer_addresses = secondary_signer_addresses;
-    this.secondary_signers = secondary_signers;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(2 /* MultiAgent */);
-    this.sender.serialize(serializer);
-    serializer.serializeVector(this.secondary_signer_addresses);
-    serializer.serializeVector(this.secondary_signers);
-  }
-  static load(deserializer) {
-    const sender = AccountAuthenticator.deserialize(deserializer);
-    const secondary_signer_addresses = deserializer.deserializeVector(AccountAddress);
-    const secondary_signers = deserializer.deserializeVector(AccountAuthenticator);
-    return new _TransactionAuthenticatorMultiAgent(sender, secondary_signer_addresses, secondary_signers);
-  }
-};
-var TransactionAuthenticatorFeePayer = class _TransactionAuthenticatorFeePayer extends TransactionAuthenticator {
-  constructor(sender, secondary_signer_addresses, secondary_signers, fee_payer) {
-    super();
-    this.sender = sender;
-    this.secondary_signer_addresses = secondary_signer_addresses;
-    this.secondary_signers = secondary_signers;
-    this.fee_payer = fee_payer;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(3 /* FeePayer */);
-    this.sender.serialize(serializer);
-    serializer.serializeVector(this.secondary_signer_addresses);
-    serializer.serializeVector(this.secondary_signers);
-    this.fee_payer.address.serialize(serializer);
-    this.fee_payer.authenticator.serialize(serializer);
-  }
-  static load(deserializer) {
-    const sender = AccountAuthenticator.deserialize(deserializer);
-    const secondary_signer_addresses = deserializer.deserializeVector(AccountAddress);
-    const secondary_signers = deserializer.deserializeVector(AccountAuthenticator);
-    const address = AccountAddress.deserialize(deserializer);
-    const authenticator = AccountAuthenticator.deserialize(deserializer);
-    const fee_payer = { address, authenticator };
-    return new _TransactionAuthenticatorFeePayer(sender, secondary_signer_addresses, secondary_signers, fee_payer);
-  }
-};
-var TransactionAuthenticatorSingleSender = class _TransactionAuthenticatorSingleSender extends TransactionAuthenticator {
-  constructor(sender) {
-    super();
-    this.sender = sender;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(4 /* SingleSender */);
-    this.sender.serialize(serializer);
-  }
-  static load(deserializer) {
-    const sender = AccountAuthenticator.deserialize(deserializer);
-    return new _TransactionAuthenticatorSingleSender(sender);
-  }
-};
-
-export {
-  TransactionAuthenticator,
-  TransactionAuthenticatorEd25519,
-  TransactionAuthenticatorMultiEd25519,
-  TransactionAuthenticatorMultiAgent,
-  TransactionAuthenticatorFeePayer,
-  TransactionAuthenticatorSingleSender
-};
-//# sourceMappingURL=chunk-ASF2VWOX.mjs.map

package/dist/esm/chunk-ATVFVXR6.mjs

@@ -1,43 +0,0 @@
-import {
-  RawTransaction
-} from "./chunk-2OQW7BMN.mjs";
-import {
-  TransactionAuthenticator
-} from "./chunk-ASF2VWOX.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-
-// src/transactions/instances/signedTransaction.ts
-var SignedTransaction = class _SignedTransaction extends Serializable {
-  /**
-   * A SignedTransaction consists of a raw transaction and an authenticator. The authenticator
-   * contains a client's public key and the signature of the raw transaction.
-   *
-   * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
-   *
-   * @param raw_txn
-   * @param authenticator Contains a client's public key and the signature of the raw transaction.
-   * Authenticator has 3 flavors: single signature, multi-signature and multi-agent.
-   * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
-   */
-  constructor(raw_txn, authenticator) {
-    super();
-    this.raw_txn = raw_txn;
-    this.authenticator = authenticator;
-  }
-  serialize(serializer) {
-    this.raw_txn.serialize(serializer);
-    this.authenticator.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const raw_txn = RawTransaction.deserialize(deserializer);
-    const authenticator = TransactionAuthenticator.deserialize(deserializer);
-    return new _SignedTransaction(raw_txn, authenticator);
-  }
-};
-
-export {
-  SignedTransaction
-};
-//# sourceMappingURL=chunk-ATVFVXR6.mjs.map