@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/dist/esm/chunk-PKUXOBIV.mjs

@@ -1,138 +0,0 @@
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/authenticationKey.ts
-import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
-var _AuthenticationKey = class _AuthenticationKey extends Serializable {
-  /**
-   * Creates an instance of the AuthenticationKey using the provided hex input.
-   * This ensures that the hex input is valid and conforms to the required length for an Authentication Key.
-   *
-   * @param args - The arguments for constructing the AuthenticationKey.
-   * @param args.data - The hex input data to be used for the Authentication Key.
-   * @throws {Error} Throws an error if the length of the provided hex input is not equal to the required Authentication Key
-   * length.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(args) {
-    super();
-    const { data } = args;
-    const hex = Hex.fromHexInput(data);
-    if (hex.toUint8Array().length !== _AuthenticationKey.LENGTH) {
-      throw new Error(`Authentication Key length should be ${_AuthenticationKey.LENGTH}`);
-    }
-    this.data = hex;
-  }
-  /**
-   * Serializes the fixed bytes data into a format suitable for transmission or storage.
-   *
-   * @param serializer - The serializer instance used to perform the serialization.
-   * @group Implementation
-   * @category Serialization
-   */
-  serialize(serializer) {
-    serializer.serializeFixedBytes(this.data.toUint8Array());
-  }
-  /**
-   * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.
-   * @param deserializer - The deserializer to deserialize the AuthenticationKey from.
-   * @returns An instance of AuthenticationKey.
-   * @group Implementation
-   * @category Serialization
-   */
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeFixedBytes(_AuthenticationKey.LENGTH);
-    return new _AuthenticationKey({ data: bytes });
-  }
-  /**
-   * Convert the internal data representation to a Uint8Array.
-   *
-   * This function is useful for obtaining a byte representation of the data, which can be utilized for serialization or transmission.
-   *
-   * @returns Uint8Array representation of the internal data.
-   * @group Implementation
-   * @category Serialization
-   */
-  toUint8Array() {
-    return this.data.toUint8Array();
-  }
-  /**
-   * Generates an AuthenticationKey from the specified scheme and input bytes.
-   * This function is essential for creating a valid authentication key based on a given scheme.
-   *
-   * @param args - The arguments for generating the AuthenticationKey.
-   * @param args.scheme - The authentication key scheme to use.
-   * @param args.input - The input data in hexadecimal format to derive the key.
-   * @returns An instance of AuthenticationKey containing the generated key data.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromSchemeAndBytes(args) {
-    const { scheme, input } = args;
-    const inputBytes = Hex.fromHexInput(input).toUint8Array();
-    const hashInput = new Uint8Array([...inputBytes, scheme]);
-    const hash = sha3Hash.create();
-    hash.update(hashInput);
-    const hashDigest = hash.digest();
-    return new _AuthenticationKey({ data: hashDigest });
-  }
-  /**
-   * Derives an AuthenticationKey from the provided public key using a specified derivation scheme.
-   *
-   * @deprecated Use `fromPublicKey` instead.
-   * @param args - The arguments for deriving the authentication key.
-   * @param args.publicKey - The public key used for the derivation.
-   * @param args.scheme - The scheme to use for deriving the authentication key.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromPublicKeyAndScheme(args) {
-    const { publicKey } = args;
-    return publicKey.authKey();
-  }
-  /**
-   * Converts a PublicKey to an AuthenticationKey using the derivation scheme inferred from the provided PublicKey instance.
-   *
-   * @param args - The arguments for the function.
-   * @param args.publicKey - The PublicKey to be converted.
-   * @returns AuthenticationKey - The derived AuthenticationKey.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromPublicKey(args) {
-    const { publicKey } = args;
-    return publicKey.authKey();
-  }
-  /**
-   * Derives an account address from an AuthenticationKey by translating the AuthenticationKey bytes directly to an AccountAddress.
-   *
-   * @returns AccountAddress - The derived account address.
-   * @group Implementation
-   * @category Serialization
-   */
-  derivedAddress() {
-    return new AccountAddress(this.data.toUint8Array());
-  }
-};
-/**
- * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.
- *
- * The data to hash depends on the underlying public key type and the derivation scheme.
- * @group Implementation
- * @category Serialization
- */
-_AuthenticationKey.LENGTH = 32;
-var AuthenticationKey = _AuthenticationKey;
-
-export {
-  AuthenticationKey
-};
-//# sourceMappingURL=chunk-PKUXOBIV.mjs.map

package/dist/esm/chunk-PT2QHUB6.mjs

@@ -1,96 +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;
-  }
-  /**
-   * Adds an item to the queue. If there are pending dequeued promises, it resolves the oldest promise with the enqueued item
-   * immediately; otherwise, it adds the item to the queue.
-   *
-   * @param item - The item to be added to the queue.
-   * @group Implementation
-   * @category Transactions
-   */
-  enqueue(item) {
-    this.cancelled = false;
-    if (this.pendingDequeue.length > 0) {
-      const promise = this.pendingDequeue.shift();
-      promise?.resolve(item);
-      return;
-    }
-    this.queue.push(item);
-  }
-  /**
-   * Dequeues the next item from the queue and returns a promise that resolves to it.
-   * If the queue is empty, it creates a new promise that will be resolved when an item is enqueued.
-   *
-   * @returns Promise<T>
-   * @group Implementation
-   * @category Transactions
-   */
-  async dequeue() {
-    if (this.queue.length > 0) {
-      return Promise.resolve(this.queue.shift());
-    }
-    return new Promise((resolve, reject) => {
-      this.pendingDequeue.push({ resolve, reject });
-    });
-  }
-  /**
-   * Determine whether the queue is empty.
-   *
-   * @returns boolean - Returns true if the queue has no elements, otherwise false.
-   * @group Implementation
-   * @category Transactions
-   */
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-  /**
-   * Cancels all pending promises in the queue and rejects them with an AsyncQueueCancelledError.
-   * This ensures that any awaiting code can handle the cancellation appropriately.
-   *
-   * @returns {void}
-   * @group Implementation
-   * @category Transactions
-   */
-  cancel() {
-    this.cancelled = true;
-    this.pendingDequeue.forEach(async ({ reject }) => {
-      reject(new AsyncQueueCancelledError("Task cancelled"));
-    });
-    this.pendingDequeue = [];
-    this.queue.length = 0;
-  }
-  /**
-   * Determine whether the queue has been cancelled.
-   *
-   * @returns boolean - Returns true if the queue is cancelled, otherwise false.
-   * @group Implementation
-   * @category Transactions
-   */
-  isCancelled() {
-    return this.cancelled;
-  }
-  /**
-   * Retrieve the length of the pending dequeue.
-   *
-   * @returns number - The number of items currently in the pending dequeue.
-   * @group Implementation
-   * @category Transactions
-   */
-  pendingDequeueLength() {
-    return this.pendingDequeue.length;
-  }
-};
-var AsyncQueueCancelledError = class extends Error {
-};
-
-export {
-  AsyncQueue,
-  AsyncQueueCancelledError
-};
-//# sourceMappingURL=chunk-PT2QHUB6.mjs.map

package/dist/esm/chunk-QJ6CGH7N.mjs

@@ -1,71 +0,0 @@
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  MoveString,
-  MoveVector
-} from "./chunk-KSK3XIGF.mjs";
-import {
-  U64
-} from "./chunk-QSYWLSSN.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-
-// src/transactions/instances/rotationProofChallenge.ts
-var RotationProofChallenge = class extends Serializable {
-  /**
-   * Initializes a new instance of the class with the specified parameters.
-   * This constructor sets up the necessary attributes for managing account keys.
-   *
-   * @param args - The parameters required to create the instance.
-   * @param args.sequenceNumber - The sequence number associated with the transaction.
-   * @param args.originator - The account address of the originator.
-   * @param args.currentAuthKey - The current authentication key of the account.
-   * @param args.newPublicKey - The new public key to be set for the account.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(args) {
-    super();
-    // Resource account address
-    this.accountAddress = AccountAddress.ONE;
-    // Module name, i.e: 0x1::account
-    this.moduleName = new MoveString("account");
-    // The rotation proof challenge struct name that live under the module
-    this.structName = new MoveString("RotationProofChallenge");
-    this.sequenceNumber = new U64(args.sequenceNumber);
-    this.originator = args.originator;
-    this.currentAuthKey = args.currentAuthKey;
-    this.newPublicKey = MoveVector.U8(args.newPublicKey.toUint8Array());
-  }
-  /**
-   * Serializes the properties of the current instance for transmission or storage.
-   * This function helps in converting the instance data into a format suitable for serialization.
-   *
-   * @param serializer - The serializer used to serialize the instance properties.
-   * @param serializer.accountAddress - The account address to serialize.
-   * @param serializer.moduleName - The module name to serialize.
-   * @param serializer.structName - The struct name to serialize.
-   * @param serializer.sequenceNumber - The sequence number to serialize.
-   * @param serializer.originator - The originator to serialize.
-   * @param serializer.currentAuthKey - The current authentication key to serialize.
-   * @param serializer.newPublicKey - The new public key to serialize.
-   * @group Implementation
-   * @category Transactions
-   */
-  serialize(serializer) {
-    serializer.serialize(this.accountAddress);
-    serializer.serialize(this.moduleName);
-    serializer.serialize(this.structName);
-    serializer.serialize(this.sequenceNumber);
-    serializer.serialize(this.originator);
-    serializer.serialize(this.currentAuthKey);
-    serializer.serialize(this.newPublicKey);
-  }
-};
-
-export {
-  RotationProofChallenge
-};
-//# sourceMappingURL=chunk-QJ6CGH7N.mjs.map

package/dist/esm/chunk-QPT4BSAB.mjs

@@ -1,20 +0,0 @@
-// src/core/common.ts
-var ParsingError = class extends Error {
-  /**
-   * Creates an instance of the error with a specified message and invalid reason.
-   *
-   * @param message The error message that describes the issue.
-   * @param invalidReason The reason why the input is considered invalid.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(message, invalidReason) {
-    super(message);
-    this.invalidReason = invalidReason;
-  }
-};
-
-export {
-  ParsingError
-};
-//# sourceMappingURL=chunk-QPT4BSAB.mjs.map

package/dist/esm/chunk-QSYWLSSN.mjs

@@ -1,216 +0,0 @@
-import {
-  Serializable,
-  ensureBoolean,
-  validateNumberInRange
-} from "./chunk-C7T6GW5P.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";
-
-// src/bcs/serializable/movePrimitives.ts
-var Bool = class _Bool extends Serializable {
-  /**
-   * Constructs a new instance with a specified value.
-   * This ensures that the value is validated to be within the acceptable range.
-   *
-   * @param value - The number to be validated and assigned, which must be between 0 and MAX_U256_BIG_INT.
-   * @group Implementation
-   * @category BCS
-   */
-  constructor(value) {
-    super();
-    ensureBoolean(value);
-    this.value = value;
-  }
-  /**
-   * Serializes the value using the provided serializer.
-   * This function is essential for converting the value into a format suitable for transmission or storage.
-   *
-   * @param serializer - The serializer instance used to perform the serialization.
-   * @group Implementation
-   * @category BCS
-   */
-  serialize(serializer) {
-    serializer.serializeBool(this.value);
-  }
-  /**
-   * Serializes the current instance for use in an entry function by converting it to a byte sequence.
-   * This allows the instance to be properly formatted for serialization in transactions.
-   *
-   * @param serializer - The serializer instance used to serialize the byte sequence.
-   * @group Implementation
-   * @category BCS
-   */
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  /**
-   * Serializes the current instance for use in a script function.
-   * This allows for the conversion of the instance into a format suitable for transmission or storage.
-   *
-   * @param serializer - The serializer used to perform the serialization.
-   * @group Implementation
-   * @category BCS
-   */
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(5 /* Bool */);
-    serializer.serialize(this);
-  }
-  /**
-   * Deserializes a U256 value from the provided deserializer.
-   *
-   * @param deserializer - The deserializer instance used to read the U256 data.
-   * @group Implementation
-   * @category BCS
-   */
-  // eslint-disable-next-line class-methods-use-this
-  deserialize(deserializer) {
-    return new U256(deserializer.deserializeU256());
-  }
-  static deserialize(deserializer) {
-    return new _Bool(deserializer.deserializeBool());
-  }
-};
-var U8 = class _U8 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, 0, MAX_U8_NUMBER);
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeU8(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(0 /* U8 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U8(deserializer.deserializeU8());
-  }
-};
-var U16 = class _U16 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, 0, MAX_U16_NUMBER);
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeU16(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(6 /* U16 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U16(deserializer.deserializeU16());
-  }
-};
-var U32 = class _U32 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, 0, MAX_U32_NUMBER);
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeU32(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(7 /* U32 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U32(deserializer.deserializeU32());
-  }
-};
-var U64 = class _U64 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, BigInt(0), MAX_U64_BIG_INT);
-    this.value = BigInt(value);
-  }
-  serialize(serializer) {
-    serializer.serializeU64(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(1 /* U64 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U64(deserializer.deserializeU64());
-  }
-};
-var U128 = class _U128 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, BigInt(0), MAX_U128_BIG_INT);
-    this.value = BigInt(value);
-  }
-  serialize(serializer) {
-    serializer.serializeU128(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(2 /* U128 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U128(deserializer.deserializeU128());
-  }
-};
-var U256 = class _U256 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, BigInt(0), MAX_U256_BIG_INT);
-    this.value = BigInt(value);
-  }
-  serialize(serializer) {
-    serializer.serializeU256(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(8 /* U256 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U256(deserializer.deserializeU256());
-  }
-};
-
-export {
-  Bool,
-  U8,
-  U16,
-  U32,
-  U64,
-  U128,
-  U256
-};
-//# sourceMappingURL=chunk-QSYWLSSN.mjs.map