@aptos-labs/ts-sdk 1.27.1-zeta.0 → 1.28.0-zeta.0

package/dist/esm/chunk-MY6PZIXF.mjs

@@ -1,254 +0,0 @@
-import {
-  AsyncQueue,
-  AsyncQueueCancelledError
-} from "./chunk-AC3OGAL6.mjs";
-import {
-  AccountSequenceNumber
-} from "./chunk-YSSWVBLZ.mjs";
-import {
-  generateTransaction,
-  signAndSubmitTransaction
-} from "./chunk-FBF77YDQ.mjs";
-import {
-  waitForTransaction
-} from "./chunk-UZLU45X7.mjs";
-
-// src/transactions/management/transactionWorker.ts
-import EventEmitter from "eventemitter3";
-var promiseFulfilledStatus = "fulfilled";
-var TransactionWorkerEventsEnum = /* @__PURE__ */ ((TransactionWorkerEventsEnum2) => {
-  TransactionWorkerEventsEnum2["TransactionSent"] = "transactionSent";
-  TransactionWorkerEventsEnum2["TransactionSendFailed"] = "transactionSendFailed";
-  TransactionWorkerEventsEnum2["TransactionExecuted"] = "transactionExecuted";
-  TransactionWorkerEventsEnum2["TransactionExecutionFailed"] = "transactionExecutionFailed";
-  TransactionWorkerEventsEnum2["ExecutionFinish"] = "executionFinish";
-  return TransactionWorkerEventsEnum2;
-})(TransactionWorkerEventsEnum || {});
-var TransactionWorker = class extends EventEmitter {
-  /**
-   * Provides a simple framework for receiving payloads to be processed.
-   *
-   * @param aptosConfig - a config object
-   * @param sender - a sender as Account
-   * @param maxWaitTime - the max wait time to wait before resyncing the sequence number
-   * to the current on-chain state, default to 30
-   * @param maximumInFlight - submit up to `maximumInFlight` transactions per account.
-   * Mempool limits the number of transactions per account to 100, hence why we default to 100.
-   * @param sleepTime - If `maximumInFlight` are in flight, wait `sleepTime` seconds before re-evaluating, default to 10
-   */
-  constructor(aptosConfig, account, maxWaitTime = 30, maximumInFlight = 100, sleepTime = 10) {
-    super();
-    this.taskQueue = new AsyncQueue();
-    /**
-     * transactions payloads waiting to be generated and signed
-     *
-     * TODO support entry function payload from ABI builder
-     */
-    this.transactionsQueue = new AsyncQueue();
-    /**
-     * signed transactions waiting to be submitted
-     */
-    this.outstandingTransactions = new AsyncQueue();
-    /**
-     * transactions that have been submitted to chain
-     */
-    this.sentTransactions = [];
-    /**
-     * transactions that have been committed to chain
-     */
-    this.executedTransactions = [];
-    this.aptosConfig = aptosConfig;
-    this.account = account;
-    this.started = false;
-    this.accountSequnceNumber = new AccountSequenceNumber(
-      aptosConfig,
-      account,
-      maxWaitTime,
-      maximumInFlight,
-      sleepTime
-    );
-  }
-  /**
-   * Gets the current account sequence number,
-   * generates the transaction with the account sequence number,
-   * adds the transaction to the outstanding transaction queue
-   * to be processed later.
-   */
-  async submitNextTransaction() {
-    try {
-      while (true) {
-        const sequenceNumber = await this.accountSequnceNumber.nextSequenceNumber();
-        if (sequenceNumber === null)
-          return;
-        const transaction = await this.generateNextTransaction(this.account, sequenceNumber);
-        if (!transaction)
-          return;
-        const pendingTransaction = signAndSubmitTransaction({
-          aptosConfig: this.aptosConfig,
-          transaction,
-          signer: this.account
-        });
-        await this.outstandingTransactions.enqueue([pendingTransaction, sequenceNumber]);
-      }
-    } catch (error) {
-      if (error instanceof AsyncQueueCancelledError) {
-        return;
-      }
-      throw new Error(`Submit transaction failed for ${this.account.accountAddress.toString()} with error ${error}`);
-    }
-  }
-  /**
-   * Reads the outstanding transaction queue and submits the transaction to chain.
-   *
-   * If the transaction has fulfilled, it pushes the transaction to the processed
-   * transactions queue and fires a transactionsFulfilled event.
-   *
-   * If the transaction has failed, it pushes the transaction to the processed
-   * transactions queue with the failure reason and fires a transactionsFailed event.
-   */
-  async processTransactions() {
-    try {
-      while (true) {
-        const awaitingTransactions = [];
-        const sequenceNumbers = [];
-        let [pendingTransaction, sequenceNumber] = await this.outstandingTransactions.dequeue();
-        awaitingTransactions.push(pendingTransaction);
-        sequenceNumbers.push(sequenceNumber);
-        while (!this.outstandingTransactions.isEmpty()) {
-          [pendingTransaction, sequenceNumber] = await this.outstandingTransactions.dequeue();
-          awaitingTransactions.push(pendingTransaction);
-          sequenceNumbers.push(sequenceNumber);
-        }
-        const sentTransactions = await Promise.allSettled(awaitingTransactions);
-        for (let i = 0; i < sentTransactions.length && i < sequenceNumbers.length; i += 1) {
-          const sentTransaction = sentTransactions[i];
-          sequenceNumber = sequenceNumbers[i];
-          if (sentTransaction.status === promiseFulfilledStatus) {
-            this.sentTransactions.push([sentTransaction.value.hash, sequenceNumber, null]);
-            this.emit("transactionSent" /* TransactionSent */, {
-              message: `transaction hash ${sentTransaction.value.hash} has been committed to chain`,
-              transactionHash: sentTransaction.value.hash
-            });
-            await this.checkTransaction(sentTransaction, sequenceNumber);
-          } else {
-            this.sentTransactions.push([sentTransaction.status, sequenceNumber, sentTransaction.reason]);
-            this.emit("transactionSendFailed" /* TransactionSendFailed */, {
-              message: `failed to commit transaction ${this.sentTransactions.length} with error ${sentTransaction.reason}`,
-              error: sentTransaction.reason
-            });
-          }
-        }
-        this.emit("executionFinish" /* ExecutionFinish */, {
-          message: `execute ${sentTransactions.length} transactions finished`
-        });
-      }
-    } catch (error) {
-      if (error instanceof AsyncQueueCancelledError) {
-        return;
-      }
-      throw new Error(`Process execution failed for ${this.account.accountAddress.toString()} with error ${error}`);
-    }
-  }
-  /**
-   * Once transaction has been sent to chain, we check for its execution status.
-   * @param sentTransaction transactions that were sent to chain and are now waiting to be executed
-   * @param sequenceNumber the account's sequence number that was sent with the transaction
-   */
-  async checkTransaction(sentTransaction, sequenceNumber) {
-    try {
-      const waitFor = [];
-      waitFor.push(waitForTransaction({ aptosConfig: this.aptosConfig, transactionHash: sentTransaction.value.hash }));
-      const sentTransactions = await Promise.allSettled(waitFor);
-      for (let i = 0; i < sentTransactions.length; i += 1) {
-        const executedTransaction = sentTransactions[i];
-        if (executedTransaction.status === promiseFulfilledStatus) {
-          this.executedTransactions.push([executedTransaction.value.hash, sequenceNumber, null]);
-          this.emit("transactionExecuted" /* TransactionExecuted */, {
-            message: `transaction hash ${executedTransaction.value.hash} has been executed on chain`,
-            transactionHash: sentTransaction.value.hash
-          });
-        } else {
-          this.executedTransactions.push([executedTransaction.status, sequenceNumber, executedTransaction.reason]);
-          this.emit("transactionExecutionFailed" /* TransactionExecutionFailed */, {
-            message: `failed to execute transaction ${this.executedTransactions.length} with error ${executedTransaction.reason}`,
-            error: executedTransaction.reason
-          });
-        }
-      }
-    } catch (error) {
-      throw new Error(`Check transaction failed for ${this.account.accountAddress.toString()} with error ${error}`);
-    }
-  }
-  /**
-   * Push transaction to the transactions queue
-   *
-   * @param transactionData Transaction payload
-   * @param transactionData.abi For all entry function payloads, the ABI to skip remote ABI lookups
-   * @param options.maxGasAmount Maximum gas amount for the transaction
-   * @param options.gasUnitPrice Gas unit price for the transaction
-   * @param options.expireTimestamp expiration timestamp on the transaction
-   * @param options.accountSequenceNumber the sequence number for the transaction
-   */
-  async push(transactionData, options) {
-    this.transactionsQueue.enqueue([transactionData, options]);
-  }
-  /**
-   * Generates a signed transaction that can be submitted to chain
-   * @param account an Aptos account
-   * @param sequenceNumber a sequence number the transaction will be generated with
-   * @returns
-   */
-  async generateNextTransaction(account, sequenceNumber) {
-    if (this.transactionsQueue.isEmpty())
-      return void 0;
-    const [transactionData, options] = await this.transactionsQueue.dequeue();
-    return generateTransaction({
-      aptosConfig: this.aptosConfig,
-      sender: account.accountAddress,
-      data: transactionData,
-      options: { ...options, accountSequenceNumber: sequenceNumber }
-    });
-  }
-  /**
-   * Starts transaction submission and transaction processing.
-   */
-  async run() {
-    try {
-      while (!this.taskQueue.isCancelled()) {
-        const task = await this.taskQueue.dequeue();
-        await task();
-      }
-    } catch (error) {
-      throw new Error(`Unable to start transaction batching: ${error}`);
-    }
-  }
-  /**
-   * Starts the transaction management process.
-   */
-  start() {
-    if (this.started) {
-      throw new Error("worker has already started");
-    }
-    this.started = true;
-    this.taskQueue.enqueue(() => this.submitNextTransaction());
-    this.taskQueue.enqueue(() => this.processTransactions());
-    this.run();
-  }
-  /**
-   * Stops the the transaction management process.
-   */
-  stop() {
-    if (this.taskQueue.isCancelled()) {
-      throw new Error("worker has already stopped");
-    }
-    this.started = false;
-    this.taskQueue.cancel();
-  }
-};
-
-export {
-  promiseFulfilledStatus,
-  TransactionWorkerEventsEnum,
-  TransactionWorker
-};
-//# sourceMappingURL=chunk-MY6PZIXF.mjs.map

package/dist/esm/chunk-N6K44CGJ.mjs

@@ -1,7 +0,0 @@
-// src/version.ts
-var VERSION = "1.27.1";
-
-export {
-  VERSION
-};
-//# sourceMappingURL=chunk-N6K44CGJ.mjs.map

package/dist/esm/chunk-NGUFBDTH.mjs

@@ -1,129 +0,0 @@
-import {
-  TransactionPayload
-} from "./chunk-XUNU6GVQ.mjs";
-import {
-  ChainId
-} from "./chunk-26HCJOBL.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.mjs";
-
-// src/transactions/instances/rawTransaction.ts
-var RawTransaction = class _RawTransaction extends Serializable {
-  /**
-   * RawTransactions contain the metadata and payloads that can be submitted to Aptos chain for execution.
-   * RawTransactions must be signed before Aptos chain can execute them.
-   *
-   * @param sender The sender Account Address
-   * @param sequence_number Sequence number of this transaction. This must match the sequence number stored in
-   *   the sender's account at the time the transaction executes.
-   * @param payload Instructions for the Aptos Blockchain, including publishing a module,
-   *   execute an entry function or execute a script payload.
-   * @param max_gas_amount Maximum total gas to spend for this transaction. The account must have more
-   *   than this gas or the transaction will be discarded during validation.
-   * @param gas_unit_price Price to be paid per gas unit.
-   * @param expiration_timestamp_secs The blockchain timestamp at which the blockchain would discard this transaction.
-   * @param chain_id The chain ID of the blockchain that this transaction is intended to be run on.
-   */
-  constructor(sender, sequence_number, payload, max_gas_amount, gas_unit_price, expiration_timestamp_secs, chain_id) {
-    super();
-    this.sender = sender;
-    this.sequence_number = sequence_number;
-    this.payload = payload;
-    this.max_gas_amount = max_gas_amount;
-    this.gas_unit_price = gas_unit_price;
-    this.expiration_timestamp_secs = expiration_timestamp_secs;
-    this.chain_id = chain_id;
-  }
-  serialize(serializer) {
-    this.sender.serialize(serializer);
-    serializer.serializeU64(this.sequence_number);
-    this.payload.serialize(serializer);
-    serializer.serializeU64(this.max_gas_amount);
-    serializer.serializeU64(this.gas_unit_price);
-    serializer.serializeU64(this.expiration_timestamp_secs);
-    this.chain_id.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const sender = AccountAddress.deserialize(deserializer);
-    const sequence_number = deserializer.deserializeU64();
-    const payload = TransactionPayload.deserialize(deserializer);
-    const max_gas_amount = deserializer.deserializeU64();
-    const gas_unit_price = deserializer.deserializeU64();
-    const expiration_timestamp_secs = deserializer.deserializeU64();
-    const chain_id = ChainId.deserialize(deserializer);
-    return new _RawTransaction(
-      sender,
-      sequence_number,
-      payload,
-      max_gas_amount,
-      gas_unit_price,
-      expiration_timestamp_secs,
-      chain_id
-    );
-  }
-};
-var RawTransactionWithData = class extends Serializable {
-  /**
-   * Deserialize a Raw Transaction With Data
-   */
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* MultiAgentTransaction */:
-        return MultiAgentRawTransaction.load(deserializer);
-      case 1 /* FeePayerTransaction */:
-        return FeePayerRawTransaction.load(deserializer);
-      default:
-        throw new Error(`Unknown variant index for RawTransactionWithData: ${index}`);
-    }
-  }
-};
-var MultiAgentRawTransaction = class _MultiAgentRawTransaction extends RawTransactionWithData {
-  constructor(raw_txn, secondary_signer_addresses) {
-    super();
-    this.raw_txn = raw_txn;
-    this.secondary_signer_addresses = secondary_signer_addresses;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* MultiAgentTransaction */);
-    this.raw_txn.serialize(serializer);
-    serializer.serializeVector(this.secondary_signer_addresses);
-  }
-  static load(deserializer) {
-    const rawTxn = RawTransaction.deserialize(deserializer);
-    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
-    return new _MultiAgentRawTransaction(rawTxn, secondarySignerAddresses);
-  }
-};
-var FeePayerRawTransaction = class _FeePayerRawTransaction extends RawTransactionWithData {
-  constructor(raw_txn, secondary_signer_addresses, fee_payer_address) {
-    super();
-    this.raw_txn = raw_txn;
-    this.secondary_signer_addresses = secondary_signer_addresses;
-    this.fee_payer_address = fee_payer_address;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(1 /* FeePayerTransaction */);
-    this.raw_txn.serialize(serializer);
-    serializer.serializeVector(this.secondary_signer_addresses);
-    this.fee_payer_address.serialize(serializer);
-  }
-  static load(deserializer) {
-    const rawTxn = RawTransaction.deserialize(deserializer);
-    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
-    const feePayerAddress = AccountAddress.deserialize(deserializer);
-    return new _FeePayerRawTransaction(rawTxn, secondarySignerAddresses, feePayerAddress);
-  }
-};
-
-export {
-  RawTransaction,
-  RawTransactionWithData,
-  MultiAgentRawTransaction,
-  FeePayerRawTransaction
-};
-//# sourceMappingURL=chunk-NGUFBDTH.mjs.map

package/dist/esm/chunk-NMKCJNQM.mjs

@@ -1,20 +0,0 @@
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/crypto/utils.ts
-var convertSigningMessage = (message) => {
-  if (typeof message === "string") {
-    const isValid = Hex.isValid(message);
-    if (!isValid.valid) {
-      return Buffer.from(message, "utf8");
-    }
-    return message;
-  }
-  return message;
-};
-
-export {
-  convertSigningMessage
-};
-//# sourceMappingURL=chunk-NMKCJNQM.mjs.map

package/dist/esm/chunk-NUA7L6XF.mjs

@@ -1,120 +0,0 @@
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-B673XLJY.mjs";
-import {
-  PublicKey
-} from "./chunk-L3E7YJBM.mjs";
-import {
-  Signature
-} from "./chunk-6BI4XTJN.mjs";
-import {
-  Deserializer
-} from "./chunk-6J7C4S3H.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/crypto/ephemeral.ts
-var EphemeralPublicKey = class _EphemeralPublicKey extends PublicKey {
-  constructor(publicKey) {
-    super();
-    const publicKeyType = publicKey.constructor.name;
-    switch (publicKeyType) {
-      case Ed25519PublicKey.name:
-        this.publicKey = publicKey;
-        this.variant = 0 /* Ed25519 */;
-        break;
-      default:
-        throw new Error(`Unsupported key for EphemeralPublicKey - ${publicKeyType}`);
-    }
-  }
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  /**
-   * Verifies a signed data with a the ephemeral public key
-   *
-   * @param args.message message
-   * @param args.signature The signature that was signed by the private key of the ephemeral public key
-   * @returns true if the signature is valid
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    return this.publicKey.verifySignature({ message, signature: signature.signature });
-  }
-  serialize(serializer) {
-    if (this.publicKey instanceof Ed25519PublicKey) {
-      serializer.serializeU32AsUleb128(0 /* Ed25519 */);
-      this.publicKey.serialize(serializer);
-    } else {
-      throw new Error("Unknown public key type");
-    }
-  }
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Ed25519 */:
-        return new _EphemeralPublicKey(Ed25519PublicKey.deserialize(deserializer));
-      default:
-        throw new Error(`Unknown variant index for EphemeralPublicKey: ${index}`);
-    }
-  }
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _EphemeralPublicKey;
-  }
-};
-var EphemeralSignature = class _EphemeralSignature extends Signature {
-  constructor(signature) {
-    super();
-    const signatureType = signature.constructor.name;
-    switch (signatureType) {
-      case Ed25519Signature.name:
-        this.signature = signature;
-        break;
-      default:
-        throw new Error(`Unsupported signature for EphemeralSignature - ${signatureType}`);
-    }
-  }
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  static fromHex(hexInput) {
-    const data = Hex.fromHexInput(hexInput);
-    const deserializer = new Deserializer(data.toUint8Array());
-    return _EphemeralSignature.deserialize(deserializer);
-  }
-  serialize(serializer) {
-    if (this.signature instanceof Ed25519Signature) {
-      serializer.serializeU32AsUleb128(0 /* Ed25519 */);
-      this.signature.serialize(serializer);
-    } else {
-      throw new Error("Unknown signature type");
-    }
-  }
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Ed25519 */:
-        return new _EphemeralSignature(Ed25519Signature.deserialize(deserializer));
-      default:
-        throw new Error(`Unknown variant index for EphemeralSignature: ${index}`);
-    }
-  }
-};
-
-export {
-  EphemeralPublicKey,
-  EphemeralSignature
-};
-//# sourceMappingURL=chunk-NUA7L6XF.mjs.map

package/dist/esm/chunk-NYELBSVO.mjs

@@ -1,172 +0,0 @@
-import {
-  Secp256k1PublicKey,
-  Secp256k1Signature
-} from "./chunk-SRKSXJ5U.mjs";
-import {
-  FederatedKeylessPublicKey
-} from "./chunk-BBCNBKEC.mjs";
-import {
-  KeylessPublicKey,
-  KeylessSignature
-} from "./chunk-BMXV6WQK.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-B673XLJY.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-L3E7YJBM.mjs";
-import {
-  Signature
-} from "./chunk-6BI4XTJN.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-ANOJYMO2.mjs";
-
-// src/core/crypto/singleKey.ts
-var AnyPublicKey = class _AnyPublicKey extends AccountPublicKey {
-  // region Constructors
-  constructor(publicKey) {
-    super();
-    this.publicKey = publicKey;
-    if (publicKey instanceof Ed25519PublicKey) {
-      this.variant = 0 /* Ed25519 */;
-    } else if (publicKey instanceof Secp256k1PublicKey) {
-      this.variant = 1 /* Secp256k1 */;
-    } else if (publicKey instanceof KeylessPublicKey) {
-      this.variant = 3 /* Keyless */;
-    } else if (publicKey instanceof FederatedKeylessPublicKey) {
-      this.variant = 4 /* FederatedKeyless */;
-    } else {
-      throw new Error("Unsupported public key type");
-    }
-  }
-  // endregion
-  // region AccountPublicKey
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (!AnySignature.isInstance(signature)) {
-      return false;
-    }
-    return this.publicKey.verifySignature({
-      message,
-      signature: signature.signature
-    });
-  }
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 2 /* SingleKey */,
-      input: this.toUint8Array()
-    });
-  }
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.publicKey.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let publicKey;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        publicKey = Ed25519PublicKey.deserialize(deserializer);
-        break;
-      case 1 /* Secp256k1 */:
-        publicKey = Secp256k1PublicKey.deserialize(deserializer);
-        break;
-      case 3 /* Keyless */:
-        publicKey = KeylessPublicKey.deserialize(deserializer);
-        break;
-      case 4 /* FederatedKeyless */:
-        publicKey = FederatedKeylessPublicKey.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
-    }
-    return new _AnyPublicKey(publicKey);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof AnyPublicKey` instead.
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _AnyPublicKey;
-  }
-  /**
-   * @deprecated use `publicKey instanceof Ed25519PublicKey` instead.
-   */
-  isEd25519() {
-    return this.publicKey instanceof Ed25519PublicKey;
-  }
-  /**
-   * @deprecated use `publicKey instanceof Secp256k1PublicKey` instead.
-   */
-  isSecp256k1PublicKey() {
-    return this.publicKey instanceof Secp256k1PublicKey;
-  }
-  static isInstance(publicKey) {
-    return "publicKey" in publicKey && "variant" in publicKey;
-  }
-};
-var AnySignature = class _AnySignature extends Signature {
-  // region Constructors
-  constructor(signature) {
-    super();
-    this.signature = signature;
-    if (signature instanceof Ed25519Signature) {
-      this.variant = 0 /* Ed25519 */;
-    } else if (signature instanceof Secp256k1Signature) {
-      this.variant = 1 /* Secp256k1 */;
-    } else if (signature instanceof KeylessSignature) {
-      this.variant = 3 /* Keyless */;
-    } else {
-      throw new Error("Unsupported signature type");
-    }
-  }
-  // endregion
-  // region AccountSignature
-  toUint8Array() {
-    console.warn(
-      "[Aptos SDK] Calls to AnySignature.toUint8Array() will soon return the underlying signature bytes. Use AnySignature.bcsToBytes() instead."
-    );
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.signature.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let signature;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        signature = Ed25519Signature.deserialize(deserializer);
-        break;
-      case 1 /* Secp256k1 */:
-        signature = Secp256k1Signature.deserialize(deserializer);
-        break;
-      case 3 /* Keyless */:
-        signature = KeylessSignature.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
-    }
-    return new _AnySignature(signature);
-  }
-  // endregion
-  static isInstance(signature) {
-    return "signature" in signature && typeof signature.signature === "object" && signature.signature !== null && "toUint8Array" in signature.signature;
-  }
-};
-
-export {
-  AnyPublicKey,
-  AnySignature
-};
-//# sourceMappingURL=chunk-NYELBSVO.mjs.map