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

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/singleKey.ts"],"sourcesContent":["import { Deserializer, Serializer } from \"../../bcs\";\nimport { AnyPublicKeyVariant, AnySignatureVariant, SigningScheme as AuthenticationKeyScheme } from \"../../types\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"./ed25519\";\nimport { AccountPublicKey, PublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Secp256k1PublicKey, Secp256k1Signature } from \"./secp256k1\";\nimport { KeylessPublicKey, KeylessSignature } from \"./keyless\";\nimport { Signature } from \"./signature\";\nimport { FederatedKeylessPublicKey } from \"./federatedKeyless\";\n\n/**\n * Represents any public key supported by Aptos.\n *\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentication keys.\n *\n * Any unified authentication key is represented in the SDK as `AnyPublicKey`.\n */\nexport class AnyPublicKey extends AccountPublicKey {\n  /**\n   * Reference to the inner public key\n   */\n  public readonly publicKey: PublicKey;\n\n  /**\n   * Index of the underlying enum variant\n   */\n  public readonly variant: AnyPublicKeyVariant;\n\n  // region Constructors\n\n  constructor(publicKey: PublicKey) {\n    super();\n    this.publicKey = publicKey;\n    if (publicKey instanceof Ed25519PublicKey) {\n      this.variant = AnyPublicKeyVariant.Ed25519;\n    } else if (publicKey instanceof Secp256k1PublicKey) {\n      this.variant = AnyPublicKeyVariant.Secp256k1;\n    } else if (publicKey instanceof KeylessPublicKey) {\n      this.variant = AnyPublicKeyVariant.Keyless;\n    } else if (publicKey instanceof FederatedKeylessPublicKey) {\n      this.variant = AnyPublicKeyVariant.FederatedKeyless;\n    } else {\n      throw new Error(\"Unsupported public key type\");\n    }\n  }\n\n  // endregion\n\n  // region AccountPublicKey\n\n  verifySignature(args: VerifySignatureArgs): boolean {\n    const { message, signature } = args;\n    if (!AnySignature.isInstance(signature)) {\n      return false;\n    }\n\n    return this.publicKey.verifySignature({\n      message,\n      signature: signature.signature,\n    });\n  }\n\n  authKey(): AuthenticationKey {\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: AuthenticationKeyScheme.SingleKey,\n      input: this.toUint8Array(),\n    });\n  }\n\n  toUint8Array() {\n    return this.bcsToBytes();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(this.variant);\n    this.publicKey.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): AnyPublicKey {\n    const variantIndex = deserializer.deserializeUleb128AsU32();\n    let publicKey: PublicKey;\n    switch (variantIndex) {\n      case AnyPublicKeyVariant.Ed25519:\n        publicKey = Ed25519PublicKey.deserialize(deserializer);\n        break;\n      case AnyPublicKeyVariant.Secp256k1:\n        publicKey = Secp256k1PublicKey.deserialize(deserializer);\n        break;\n      case AnyPublicKeyVariant.Keyless:\n        publicKey = KeylessPublicKey.deserialize(deserializer);\n        break;\n      case AnyPublicKeyVariant.FederatedKeyless:\n        publicKey = FederatedKeylessPublicKey.deserialize(deserializer);\n        break;\n      default:\n        throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);\n    }\n    return new AnyPublicKey(publicKey);\n  }\n\n  // endregion\n\n  /**\n   * @deprecated use `instanceof AnyPublicKey` instead.\n   */\n  static isPublicKey(publicKey: AccountPublicKey): publicKey is AnyPublicKey {\n    return publicKey instanceof AnyPublicKey;\n  }\n\n  /**\n   * @deprecated use `publicKey instanceof Ed25519PublicKey` instead.\n   */\n  isEd25519(): boolean {\n    return this.publicKey instanceof Ed25519PublicKey;\n  }\n\n  /**\n   * @deprecated use `publicKey instanceof Secp256k1PublicKey` instead.\n   */\n  isSecp256k1PublicKey(): boolean {\n    return this.publicKey instanceof Secp256k1PublicKey;\n  }\n\n  static isInstance(publicKey: PublicKey): publicKey is AnyPublicKey {\n    return \"publicKey\" in publicKey && \"variant\" in publicKey;\n  }\n}\n\n/**\n * Instance of signature that uses the SingleKey authentication scheme.\n * This signature can only be generated by a `SingleKeySigner`, since it uses the\n * same authentication scheme.\n */\nexport class AnySignature extends Signature {\n  public readonly signature: Signature;\n\n  /**\n   * Index of the underlying enum variant\n   */\n  private readonly variant: AnySignatureVariant;\n\n  // region Constructors\n\n  constructor(signature: Signature) {\n    super();\n    this.signature = signature;\n\n    if (signature instanceof Ed25519Signature) {\n      this.variant = AnySignatureVariant.Ed25519;\n    } else if (signature instanceof Secp256k1Signature) {\n      this.variant = AnySignatureVariant.Secp256k1;\n    } else if (signature instanceof KeylessSignature) {\n      this.variant = AnySignatureVariant.Keyless;\n    } else {\n      throw new Error(\"Unsupported signature type\");\n    }\n  }\n\n  // endregion\n\n  // region AccountSignature\n\n  toUint8Array() {\n    // TODO: keep this warning around for a bit, and eventually change this to return `this.signature.toUint8Array()`.\n    // eslint-disable-next-line no-console\n    console.warn(\n      \"[Aptos SDK] Calls to AnySignature.toUint8Array() will soon return the underlying signature bytes. \" +\n        \"Use AnySignature.bcsToBytes() instead.\",\n    );\n    return this.bcsToBytes();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(this.variant);\n    this.signature.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): AnySignature {\n    const variantIndex = deserializer.deserializeUleb128AsU32();\n    let signature: Signature;\n    switch (variantIndex) {\n      case AnySignatureVariant.Ed25519:\n        signature = Ed25519Signature.deserialize(deserializer);\n        break;\n      case AnySignatureVariant.Secp256k1:\n        signature = Secp256k1Signature.deserialize(deserializer);\n        break;\n      case AnySignatureVariant.Keyless:\n        signature = KeylessSignature.deserialize(deserializer);\n        break;\n      default:\n        throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);\n    }\n    return new AnySignature(signature);\n  }\n\n  // endregion\n\n  static isInstance(signature: Signature): signature is AnySignature {\n    return (\n      \"signature\" in signature &&\n      typeof signature.signature === \"object\" &&\n      signature.signature !== null &&\n      \"toUint8Array\" in signature.signature\n    );\n  }\n}\n"],"mappings":"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","names":[]}