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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/keyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n// eslint-disable-next-line max-classes-per-file\nimport { JwtPayload, jwtDecode } from \"jwt-decode\";\nimport { sha3_256 } from \"@noble/hashes/sha3\";\nimport { AccountPublicKey, PublicKey } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { Deserializer, Serializable, Serializer } from \"../../bcs\";\nimport { Hex, hexToAsciiString } from \"../hex\";\nimport {\n  HexInput,\n  EphemeralCertificateVariant,\n  AnyPublicKeyVariant,\n  SigningScheme,\n  ZkpVariant,\n  LedgerVersionArg,\n  MoveResource,\n} from \"../../types\";\nimport { EphemeralPublicKey, EphemeralSignature } from \"./ephemeral\";\nimport { bigIntToBytesLE, bytesToBigIntLE, hashStrToField, poseidonHash } from \"./poseidon\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Proof } from \"./proof\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"./ed25519\";\nimport {\n  Groth16VerificationKeyResponse,\n  KeylessConfigurationResponse,\n  MoveAnyStruct,\n  PatchedJWKsResponse,\n} from \"../../types/keyless\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport { getAptosFullNode } from \"../../client\";\nimport { memoizeAsync } from \"../../utils/memoize\";\nimport { AccountAddress, AccountAddressInput } from \"../accountAddress\";\nimport { getErrorMessage } from \"../../utils\";\nimport { KeylessError, KeylessErrorType } from \"../../errors\";\n\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const EPK_HORIZON_SECS = 10000000;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_AUD_VAL_BYTES = 120;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_UID_KEY_BYTES = 30;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_UID_VAL_BYTES = 330;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_ISS_VAL_BYTES = 120;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_EXTRA_FIELD_BYTES = 350;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_JWT_HEADER_B64_BYTES = 300;\n/**\n * @group Implementation\n * @category Serialization\n */\nexport const MAX_COMMITED_EPK_BYTES = 93;\n\n/**\n * Represents a Keyless Public Key used for authentication.\n *\n * This class encapsulates the public key functionality for keyless authentication,\n * including methods for generating and verifying signatures, as well as serialization\n * and deserialization of the key. The KeylessPublicKey is represented in the SDK\n * as `AnyPublicKey`.\n * @group Implementation\n * @category Serialization\n */\nexport class KeylessPublicKey extends AccountPublicKey {\n  /**\n   * The number of bytes that `idCommitment` should be\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly ID_COMMITMENT_LENGTH: number = 32;\n\n  /**\n   * The value of the 'iss' claim on the JWT which identifies the OIDC provider.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly iss: string;\n\n  /**\n   * A value representing a cryptographic commitment to a user identity.\n   *\n   * It is calculated from the aud, uidKey, uidVal, pepper.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly idCommitment: Uint8Array;\n\n  /**\n   * Constructs an instance with the specified parameters for cryptographic operations.\n   *\n   * @param args - The parameters required to initialize the instance.\n   * @param args.alphaG1 - The hex representation of the alpha G1 value.\n   * @param args.betaG2 - The hex representation of the beta G2 value.\n   * @param args.deltaG2 - The hex representation of the delta G2 value.\n   * @param args.gammaAbcG1 - An array containing two hex representations for gamma ABC G1 values.\n   * @param args.gammaG2 - The hex representation of the gamma G2 value.\n   * @group Implementation\n   * @category Serialization\n   */\n  // TODO: Fix the JSDoc for the below values\n  constructor(iss: string, idCommitment: HexInput) {\n    super();\n    const idcBytes = Hex.fromHexInput(idCommitment).toUint8Array();\n    if (idcBytes.length !== KeylessPublicKey.ID_COMMITMENT_LENGTH) {\n      throw new Error(`Id Commitment length in bytes should be ${KeylessPublicKey.ID_COMMITMENT_LENGTH}`);\n    }\n    this.iss = iss;\n    this.idCommitment = idcBytes;\n  }\n\n  /**\n   * Get the authentication key for the keyless public key.\n   *\n   * @returns AuthenticationKey - The authentication key derived from the keyless public key.\n   * @group Implementation\n   * @category Serialization\n   */\n  authKey(): AuthenticationKey {\n    const serializer = new Serializer();\n    serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Keyless);\n    serializer.serializeFixedBytes(this.bcsToBytes());\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: SigningScheme.SingleKey,\n      input: serializer.toUint8Array(),\n    });\n  }\n\n  /**\n   * Verifies the validity of a signature for a given message.\n   *\n   * @param args - The arguments for signature verification.\n   * @param args.message - The message that was signed.\n   * @param args.signature - The signature to verify against the message.\n   * @returns true if the signature is valid; otherwise, false.\n   * @group Implementation\n   * @category Serialization\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this\n  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {\n    throw new Error(\"Not yet implemented\");\n  }\n\n  /**\n   * Serializes the current instance into a format suitable for transmission or storage.\n   * This function ensures that all relevant fields are properly serialized, including the proof and optional fields.\n   *\n   * @param serializer - The serializer instance used to perform the serialization.\n   * @param serializer.proof - The proof to be serialized.\n   * @param serializer.expHorizonSecs - The expiration horizon in seconds.\n   * @param serializer.extraField - An optional additional field for serialization.\n   * @param serializer.overrideAudVal - An optional override value for auditing.\n   * @param serializer.trainingWheelsSignature - An optional signature for training wheels.\n   * @group Implementation\n   * @category Serialization\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.iss);\n    serializer.serializeBytes(this.idCommitment);\n  }\n\n  /**\n   * Deserializes a ZeroKnowledgeSig object from the provided deserializer.\n   * This function allows you to reconstruct a ZeroKnowledgeSig instance from its serialized form.\n   *\n   * @param deserializer - The deserializer instance used to read the serialized data.\n   * @returns A new instance of ZeroKnowledgeSig.\n   * @group Implementation\n   * @category Serialization\n   */\n  static deserialize(deserializer: Deserializer): KeylessPublicKey {\n    const iss = deserializer.deserializeStr();\n    const addressSeed = deserializer.deserializeBytes();\n    return new KeylessPublicKey(iss, addressSeed);\n  }\n\n  /**\n   * Loads a KeylessPublicKey instance from the provided deserializer.\n   * This function is used to deserialize the necessary components to create a KeylessPublicKey.\n   *\n   * @param deserializer - The deserializer used to extract the string and byte data.\n   * @param deserializer.deserializeStr - A method to deserialize a string value.\n   * @param deserializer.deserializeBytes - A method to deserialize byte data.\n   * @returns A new instance of KeylessPublicKey.\n   * @group Implementation\n   * @category Serialization\n   */\n  static load(deserializer: Deserializer): KeylessPublicKey {\n    const iss = deserializer.deserializeStr();\n    const addressSeed = deserializer.deserializeBytes();\n    return new KeylessPublicKey(iss, addressSeed);\n  }\n\n  /**\n   * Determines if the provided public key is an instance of KeylessPublicKey.\n   *\n   * @param publicKey - The public key to check.\n   * @returns A boolean indicating whether the public key is a KeylessPublicKey instance.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isPublicKey(publicKey: PublicKey): publicKey is KeylessPublicKey {\n    return publicKey instanceof KeylessPublicKey;\n  }\n\n  /**\n   * Creates a KeylessPublicKey from the JWT components plus pepper\n   *\n   * @param args.iss the iss of the identity\n   * @param args.uidKey the key to use to get the uidVal in the JWT token\n   * @param args.uidVal the value of the uidKey in the JWT token\n   * @param args.aud the client ID of the application\n   * @param args.pepper The pepper used to maintain privacy of the account\n   * @returns KeylessPublicKey\n   * @group Implementation\n   * @category Serialization\n   */\n  static create(args: {\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n  }): KeylessPublicKey {\n    computeIdCommitment(args);\n    return new KeylessPublicKey(args.iss, computeIdCommitment(args));\n  }\n\n  /**\n   * Creates a KeylessPublicKey instance from a JWT and a pepper value.\n   * This function is useful for generating a public key that can be used for authentication based on the provided JWT claims and pepper.\n   *\n   * @param args - The arguments for creating the KeylessPublicKey.\n   * @param args.jwt - The JSON Web Token to decode.\n   * @param args.pepper - The pepper value used in the key creation process.\n   * @param args.uidKey - An optional key to retrieve the unique identifier from the JWT payload, defaults to \"sub\".\n   * @returns A KeylessPublicKey instance created from the provided JWT and pepper.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromJwtAndPepper(args: { jwt: string; pepper: HexInput; uidKey?: string }): KeylessPublicKey {\n    const { jwt, pepper, uidKey = \"sub\" } = args;\n    const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);\n    if (typeof jwtPayload.iss !== \"string\") {\n      throw new Error(\"iss was not found\");\n    }\n    if (typeof jwtPayload.aud !== \"string\") {\n      throw new Error(\"aud was not found or an array of values\");\n    }\n    const uidVal = jwtPayload[uidKey];\n    return KeylessPublicKey.create({ iss: jwtPayload.iss, uidKey, uidVal, aud: jwtPayload.aud, pepper });\n  }\n\n  /**\n   * Checks if the provided public key is a valid instance by verifying its structure and types.\n   *\n   * @param publicKey - The public key to validate.\n   * @returns A boolean indicating whether the public key is a valid instance.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isInstance(publicKey: PublicKey) {\n    return (\n      \"iss\" in publicKey &&\n      typeof publicKey.iss === \"string\" &&\n      \"idCommitment\" in publicKey &&\n      publicKey.idCommitment instanceof Uint8Array\n    );\n  }\n}\n\nfunction computeIdCommitment(args: { uidKey: string; uidVal: string; aud: string; pepper: HexInput }): Uint8Array {\n  const { uidKey, uidVal, aud, pepper } = args;\n\n  const fields = [\n    bytesToBigIntLE(Hex.fromHexInput(pepper).toUint8Array()),\n    hashStrToField(aud, MAX_AUD_VAL_BYTES),\n    hashStrToField(uidVal, MAX_UID_VAL_BYTES),\n    hashStrToField(uidKey, MAX_UID_KEY_BYTES),\n  ];\n\n  return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ID_COMMITMENT_LENGTH);\n}\n\n/**\n * Represents a signature of a message signed via a Keyless Account, utilizing proofs or a JWT token for authentication.\n * @group Implementation\n * @category Serialization\n */\nexport class KeylessSignature extends Signature {\n  /**\n   * The inner signature ZeroKnowledgeSignature or OpenIdSignature\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly ephemeralCertificate: EphemeralCertificate;\n\n  /**\n   * The jwt header in the token used to create the proof/signature.  In json string representation.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly jwtHeader: string;\n\n  /**\n   * The expiry timestamp in seconds of the EphemeralKeyPair used to sign\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly expiryDateSecs: number;\n\n  /**\n   * The ephemeral public key used to verify the signature\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly ephemeralPublicKey: EphemeralPublicKey;\n\n  /**\n   * The signature resulting from signing with the private key of the EphemeralKeyPair\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly ephemeralSignature: EphemeralSignature;\n\n  constructor(args: {\n    jwtHeader: string;\n    ephemeralCertificate: EphemeralCertificate;\n    expiryDateSecs: number;\n    ephemeralPublicKey: EphemeralPublicKey;\n    ephemeralSignature: EphemeralSignature;\n  }) {\n    super();\n    const { jwtHeader, ephemeralCertificate, expiryDateSecs, ephemeralPublicKey, ephemeralSignature } = args;\n    this.jwtHeader = jwtHeader;\n    this.ephemeralCertificate = ephemeralCertificate;\n    this.expiryDateSecs = expiryDateSecs;\n    this.ephemeralPublicKey = ephemeralPublicKey;\n    this.ephemeralSignature = ephemeralSignature;\n  }\n\n  /**\n   * Get the kid of the JWT used to derive the Keyless Account used to sign.\n   *\n   * @returns the kid as a string\n   */\n  getJwkKid(): string {\n    return parseJwtHeader(this.jwtHeader).kid;\n  }\n\n  serialize(serializer: Serializer): void {\n    this.ephemeralCertificate.serialize(serializer);\n    serializer.serializeStr(this.jwtHeader);\n    serializer.serializeU64(this.expiryDateSecs);\n    this.ephemeralPublicKey.serialize(serializer);\n    this.ephemeralSignature.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): KeylessSignature {\n    const ephemeralCertificate = EphemeralCertificate.deserialize(deserializer);\n    const jwtHeader = deserializer.deserializeStr();\n    const expiryDateSecs = deserializer.deserializeU64();\n    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);\n    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);\n    return new KeylessSignature({\n      jwtHeader,\n      expiryDateSecs: Number(expiryDateSecs),\n      ephemeralCertificate,\n      ephemeralPublicKey,\n      ephemeralSignature,\n    });\n  }\n\n  static getSimulationSignature(): KeylessSignature {\n    return new KeylessSignature({\n      jwtHeader: \"{}\",\n      ephemeralCertificate: new EphemeralCertificate(\n        new ZeroKnowledgeSig({\n          proof: new ZkProof(\n            new Groth16Zkp({ a: new Uint8Array(32), b: new Uint8Array(64), c: new Uint8Array(32) }),\n            ZkpVariant.Groth16,\n          ),\n          expHorizonSecs: 0,\n        }),\n        EphemeralCertificateVariant.ZkProof,\n      ),\n      expiryDateSecs: 0,\n      ephemeralPublicKey: new EphemeralPublicKey(new Ed25519PublicKey(new Uint8Array(32))),\n      ephemeralSignature: new EphemeralSignature(new Ed25519Signature(new Uint8Array(64))),\n    });\n  }\n\n  static isSignature(signature: Signature): signature is KeylessSignature {\n    return signature instanceof KeylessSignature;\n  }\n}\n\n/**\n * Represents an ephemeral certificate containing a signature, specifically a ZeroKnowledgeSig.\n * This class can be extended to support additional signature types, such as OpenIdSignature.\n *\n * @extends Signature\n * @group Implementation\n * @category Serialization\n */\nexport class EphemeralCertificate extends Signature {\n  public readonly signature: Signature;\n\n  /**\n   * Index of the underlying enum variant\n   * @group Implementation\n   * @category Serialization\n   */\n  private readonly variant: EphemeralCertificateVariant;\n\n  constructor(signature: Signature, variant: EphemeralCertificateVariant) {\n    super();\n    this.signature = signature;\n    this.variant = variant;\n  }\n\n  /**\n   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    return this.signature.toUint8Array();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(this.variant);\n    this.signature.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): EphemeralCertificate {\n    const variant = deserializer.deserializeUleb128AsU32();\n    switch (variant) {\n      case EphemeralCertificateVariant.ZkProof:\n        return new EphemeralCertificate(ZeroKnowledgeSig.deserialize(deserializer), variant);\n      default:\n        throw new Error(`Unknown variant index for EphemeralCertificate: ${variant}`);\n    }\n  }\n}\n\n/**\n * Represents a fixed-size byte array of 32 bytes, extending the Serializable class.\n * This class is used for handling and serializing G1 bytes in cryptographic operations.\n *\n * @extends Serializable\n * @group Implementation\n * @category Serialization\n */\nclass G1Bytes extends Serializable {\n  data: Uint8Array;\n\n  constructor(data: HexInput) {\n    super();\n    this.data = Hex.fromHexInput(data).toUint8Array();\n    if (this.data.length !== 32) {\n      throw new Error(\"Input needs to be 32 bytes\");\n    }\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.data);\n  }\n\n  static deserialize(deserializer: Deserializer): G1Bytes {\n    const bytes = deserializer.deserializeFixedBytes(32);\n    return new G1Bytes(bytes);\n  }\n}\n\n/**\n * Represents a 64-byte G2 element in a cryptographic context.\n * This class provides methods for serialization and deserialization of G2 bytes.\n *\n * @extends Serializable\n * @group Implementation\n * @category Serialization\n */\nclass G2Bytes extends Serializable {\n  data: Uint8Array;\n\n  constructor(data: HexInput) {\n    super();\n    this.data = Hex.fromHexInput(data).toUint8Array();\n    if (this.data.length !== 64) {\n      throw new Error(\"Input needs to be 64 bytes\");\n    }\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.data);\n  }\n\n  static deserialize(deserializer: Deserializer): G2Bytes {\n    const bytes = deserializer.deserializeFixedBytes(64);\n    return new G2Bytes(bytes);\n  }\n}\n\n/**\n * Represents a Groth16 zero-knowledge proof, consisting of three proof points in compressed serialization format.\n * The points are the compressed serialization of affine representation of the proof.\n *\n * @extends Proof\n * @group Implementation\n * @category Serialization\n */\nexport class Groth16Zkp extends Proof {\n  /**\n   * The bytes of G1 proof point a\n   * @group Implementation\n   * @category Serialization\n   */\n  a: G1Bytes;\n\n  /**\n   * The bytes of G2 proof point b\n   * @group Implementation\n   * @category Serialization\n   */\n  b: G2Bytes;\n\n  /**\n   * The bytes of G1 proof point c\n   * @group Implementation\n   * @category Serialization\n   */\n  c: G1Bytes;\n\n  constructor(args: { a: HexInput; b: HexInput; c: HexInput }) {\n    super();\n    const { a, b, c } = args;\n    this.a = new G1Bytes(a);\n    this.b = new G2Bytes(b);\n    this.c = new G1Bytes(c);\n  }\n\n  serialize(serializer: Serializer): void {\n    this.a.serialize(serializer);\n    this.b.serialize(serializer);\n    this.c.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): Groth16Zkp {\n    const a = G1Bytes.deserialize(deserializer).bcsToBytes();\n    const b = G2Bytes.deserialize(deserializer).bcsToBytes();\n    const c = G1Bytes.deserialize(deserializer).bcsToBytes();\n    return new Groth16Zkp({ a, b, c });\n  }\n}\n\n/**\n * Represents a container for different types of zero-knowledge proofs.\n *\n * @extends Serializable\n * @group Implementation\n * @category Serialization\n */\nexport class ZkProof extends Serializable {\n  public readonly proof: Proof;\n\n  /**\n   * Index of the underlying enum variant\n   * @group Implementation\n   * @category Serialization\n   */\n  private readonly variant: ZkpVariant;\n\n  constructor(proof: Proof, variant: ZkpVariant) {\n    super();\n    this.proof = proof;\n    this.variant = variant;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(this.variant);\n    this.proof.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): ZkProof {\n    const variant = deserializer.deserializeUleb128AsU32();\n    switch (variant) {\n      case ZkpVariant.Groth16:\n        return new ZkProof(Groth16Zkp.deserialize(deserializer), variant);\n      default:\n        throw new Error(`Unknown variant index for ZkProof: ${variant}`);\n    }\n  }\n}\n\n/**\n * Represents a zero-knowledge signature, encapsulating the proof and its associated metadata.\n *\n * @extends Signature\n * @group Implementation\n * @category Serialization\n */\nexport class ZeroKnowledgeSig extends Signature {\n  /**\n   * The proof\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly proof: ZkProof;\n\n  /**\n   * The max lifespan of the proof\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly expHorizonSecs: number;\n\n  /**\n   * A key value pair on the JWT token that can be specified on the signature which would reveal the value on chain.\n   * Can be used to assert identity or other attributes.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly extraField?: string;\n\n  /**\n   * The 'aud' value of the recovery service which is set when recovering an account.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly overrideAudVal?: string;\n\n  /**\n   * The training wheels signature\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly trainingWheelsSignature?: EphemeralSignature;\n\n  constructor(args: {\n    proof: ZkProof;\n    expHorizonSecs: number;\n    extraField?: string;\n    overrideAudVal?: string;\n    trainingWheelsSignature?: EphemeralSignature;\n  }) {\n    super();\n    const { proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal } = args;\n    this.proof = proof;\n    this.expHorizonSecs = expHorizonSecs;\n    this.trainingWheelsSignature = trainingWheelsSignature;\n    this.extraField = extraField;\n    this.overrideAudVal = overrideAudVal;\n  }\n\n  /**\n   * Deserialize a ZeroKnowledgeSig object from its BCS serialization in bytes.\n   *\n   * @param bytes - The bytes representing the serialized ZeroKnowledgeSig.\n   * @returns ZeroKnowledgeSig - The deserialized ZeroKnowledgeSig object.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromBytes(bytes: Uint8Array): ZeroKnowledgeSig {\n    return ZeroKnowledgeSig.deserialize(new Deserializer(bytes));\n  }\n\n  serialize(serializer: Serializer): void {\n    this.proof.serialize(serializer);\n    serializer.serializeU64(this.expHorizonSecs);\n    serializer.serializeOption(this.extraField);\n    serializer.serializeOption(this.overrideAudVal);\n    serializer.serializeOption(this.trainingWheelsSignature);\n  }\n\n  static deserialize(deserializer: Deserializer): ZeroKnowledgeSig {\n    const proof = ZkProof.deserialize(deserializer);\n    const expHorizonSecs = Number(deserializer.deserializeU64());\n    const extraField = deserializer.deserializeOption(\"string\");\n    const overrideAudVal = deserializer.deserializeOption(\"string\");\n    const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);\n    return new ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });\n  }\n}\n\n/**\n * Represents the on-chain configuration for how Keyless accounts operate.\n *\n * @remarks\n * This class encapsulates the verification key and the maximum lifespan of ephemeral key pairs,\n * which are essential for the functionality of Keyless accounts.\n * @group Implementation\n * @category Serialization\n */\nexport class KeylessConfiguration {\n  /**\n   * The verification key used to verify Groth16 proofs on chain\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly verificationKey: Groth16VerificationKey;\n\n  /**\n   * The maximum lifespan of an ephemeral key pair.  This is configured on chain.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly maxExpHorizonSecs: number;\n\n  constructor(verificationKey: Groth16VerificationKey, maxExpHorizonSecs: number) {\n    this.verificationKey = verificationKey;\n    this.maxExpHorizonSecs = maxExpHorizonSecs;\n  }\n\n  static create(res: Groth16VerificationKeyResponse, maxExpHorizonSecs: number): KeylessConfiguration {\n    return new KeylessConfiguration(\n      new Groth16VerificationKey({\n        alphaG1: res.alpha_g1,\n        betaG2: res.beta_g2,\n        deltaG2: res.delta_g2,\n        gammaAbcG1: res.gamma_abc_g1,\n        gammaG2: res.gamma_g2,\n      }),\n      maxExpHorizonSecs,\n    );\n  }\n}\n\n/**\n * Represents the verification key stored on-chain used to verify Groth16 proofs.\n * @group Implementation\n * @category Serialization\n */\nexport class Groth16VerificationKey {\n  // The docstrings below are borrowed from ark-groth16\n\n  /**\n   * The `alpha * G`, where `G` is the generator of G1\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly alphaG1: G1Bytes;\n\n  /**\n   * The `alpha * H`, where `H` is the generator of G2\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly betaG2: G2Bytes;\n\n  /**\n   * The `delta * H`, where `H` is the generator of G2\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly deltaG2: G2Bytes;\n\n  /**\n   * The `gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H`, where H is the generator of G1\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly gammaAbcG1: [G1Bytes, G1Bytes];\n\n  /**\n   * The `gamma * H`, where `H` is the generator of G2\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly gammaG2: G2Bytes;\n\n  constructor(args: {\n    alphaG1: HexInput;\n    betaG2: HexInput;\n    deltaG2: HexInput;\n    gammaAbcG1: [HexInput, HexInput];\n    gammaG2: HexInput;\n  }) {\n    const { alphaG1, betaG2, deltaG2, gammaAbcG1, gammaG2 } = args;\n    this.alphaG1 = new G1Bytes(alphaG1);\n    this.betaG2 = new G2Bytes(betaG2);\n    this.deltaG2 = new G2Bytes(deltaG2);\n    this.gammaAbcG1 = [new G1Bytes(gammaAbcG1[0]), new G1Bytes(gammaAbcG1[1])];\n    this.gammaG2 = new G2Bytes(gammaG2);\n  }\n\n  /**\n   * Calculates the hash of the serialized form of the verification key.\n   * This is useful for comparing verification keys or using them as unique identifiers.\n   *\n   * @returns The SHA3-256 hash of the serialized verification key as a Uint8Array\n   */\n  public hash(): Uint8Array {\n    const serializer = new Serializer();\n    this.serialize(serializer);\n    return sha3_256.create().update(serializer.toUint8Array()).digest();\n  }\n\n  serialize(serializer: Serializer): void {\n    this.alphaG1.serialize(serializer);\n    this.betaG2.serialize(serializer);\n    this.deltaG2.serialize(serializer);\n    this.gammaAbcG1[0].serialize(serializer);\n    this.gammaAbcG1[1].serialize(serializer);\n    this.gammaG2.serialize(serializer);\n  }\n\n  /**\n   * Converts a Groth16VerificationKeyResponse object into a Groth16VerificationKey instance.\n   *\n   * @param res - The Groth16VerificationKeyResponse object containing the verification key data.\n   * @param res.alpha_g1 - The alpha G1 value from the response.\n   * @param res.beta_g2 - The beta G2 value from the response.\n   * @param res.delta_g2 - The delta G2 value from the response.\n   * @param res.gamma_abc_g1 - The gamma ABC G1 value from the response.\n   * @param res.gamma_g2 - The gamma G2 value from the response.\n   * @returns A Groth16VerificationKey instance constructed from the provided response data.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromGroth16VerificationKeyResponse(res: Groth16VerificationKeyResponse): Groth16VerificationKey {\n    return new Groth16VerificationKey({\n      alphaG1: res.alpha_g1,\n      betaG2: res.beta_g2,\n      deltaG2: res.delta_g2,\n      gammaAbcG1: res.gamma_abc_g1,\n      gammaG2: res.gamma_g2,\n    });\n  }\n}\n\n/**\n * Retrieves the configuration parameters for Keyless Accounts on the blockchain, including the verifying key and the maximum\n * expiry horizon.\n *\n * @param args - The arguments for retrieving the keyless configuration.\n * @param args.aptosConfig - The Aptos configuration object containing network details.\n * @param args.options - Optional parameters for the request.\n * @param args.options.ledgerVersion - The ledger version to query; if not provided, the latest version will be used.\n * @returns KeylessConfiguration - The configuration object containing the verifying key and maximum expiry horizon.\n * @group Implementation\n * @category Serialization\n */\nexport async function getKeylessConfig(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<KeylessConfiguration> {\n  const { aptosConfig } = args;\n  try {\n    return await memoizeAsync(\n      async () => {\n        const config = await getKeylessConfigurationResource(args);\n        const vk = await getGroth16VerificationKeyResource(args);\n        return KeylessConfiguration.create(vk, Number(config.max_exp_horizon_secs));\n      },\n      `keyless-configuration-${aptosConfig.network}`,\n      1000 * 60 * 5, // 5 minutes\n    )();\n  } catch (error) {\n    if (error instanceof KeylessError) {\n      throw error;\n    }\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.FULL_NODE_OTHER,\n      error,\n    });\n  }\n}\n\n/**\n * Parses a JWT and returns the 'iss', 'aud', and 'uid' values.\n *\n * @param args - The arguments for parsing the JWT.\n * @param args.jwt - The JWT to parse.\n * @param args.uidKey - The key to use for the 'uid' value; defaults to 'sub'.\n * @returns The 'iss', 'aud', and 'uid' values from the JWT.\n */\nexport function getIssAudAndUidVal(args: { jwt: string; uidKey?: string }): {\n  iss: string;\n  aud: string;\n  uidVal: string;\n} {\n  const { jwt, uidKey = \"sub\" } = args;\n  let jwtPayload: JwtPayload & { [key: string]: string };\n  try {\n    jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);\n  } catch (error) {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.JWT_PARSING_ERROR,\n      details: `Failed to parse JWT - ${getErrorMessage(error)}`,\n    });\n  }\n  if (typeof jwtPayload.iss !== \"string\") {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.JWT_PARSING_ERROR,\n      details: \"JWT is missing 'iss' in the payload. This should never happen.\",\n    });\n  }\n  if (typeof jwtPayload.aud !== \"string\") {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.JWT_PARSING_ERROR,\n      details: \"JWT is missing 'aud' in the payload or 'aud' is an array of values.\",\n    });\n  }\n  const uidVal = jwtPayload[uidKey];\n  return { iss: jwtPayload.iss, aud: jwtPayload.aud, uidVal };\n}\n\n/**\n * Retrieves the KeylessConfiguration set on chain.\n *\n * @param args - The arguments for retrieving the configuration.\n * @param args.aptosConfig - The configuration for connecting to the Aptos network.\n * @param args.options - Optional parameters for the request.\n * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.\n * @returns KeylessConfigurationResponse - The response containing the keyless configuration data.\n * @group Implementation\n * @category Serialization\n */\nasync function getKeylessConfigurationResource(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<KeylessConfigurationResponse> {\n  const { aptosConfig, options } = args;\n  const resourceType = \"0x1::keyless_account::Configuration\";\n  try {\n    const { data } = await getAptosFullNode<{}, MoveResource<KeylessConfigurationResponse>>({\n      aptosConfig,\n      originMethod: \"getKeylessConfigurationResource\",\n      path: `accounts/${AccountAddress.from(\"0x1\").toString()}/resource/${resourceType}`,\n      params: { ledger_version: options?.ledgerVersion },\n    });\n    return data.data;\n  } catch (error) {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.FULL_NODE_CONFIG_LOOKUP_ERROR,\n      error,\n    });\n  }\n}\n\n/**\n * Retrieves the Groth16VerificationKey set on the blockchain.\n *\n * @param args - The arguments for retrieving the verification key.\n * @param args.aptosConfig - The Aptos configuration object.\n * @param args.options - Optional parameters for the request.\n * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.\n * @returns Groth16VerificationKeyResponse - The response containing the Groth16 verification key data.\n * @group Implementation\n * @category Serialization\n */\nasync function getGroth16VerificationKeyResource(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<Groth16VerificationKeyResponse> {\n  const { aptosConfig, options } = args;\n  const resourceType = \"0x1::keyless_account::Groth16VerificationKey\";\n  try {\n    const { data } = await getAptosFullNode<{}, MoveResource<Groth16VerificationKeyResponse>>({\n      aptosConfig,\n      originMethod: \"getGroth16VerificationKeyResource\",\n      path: `accounts/${AccountAddress.from(\"0x1\").toString()}/resource/${resourceType}`,\n      params: { ledger_version: options?.ledgerVersion },\n    });\n    return data.data;\n  } catch (error) {\n    throw KeylessError.fromErrorType({\n      type: KeylessErrorType.FULL_NODE_VERIFICATION_KEY_LOOKUP_ERROR,\n      error,\n    });\n  }\n}\n\nexport async function getKeylessJWKs(args: {\n  aptosConfig: AptosConfig;\n  jwkAddr?: AccountAddressInput;\n  options?: LedgerVersionArg;\n}): Promise<Map<string, MoveJWK[]>> {\n  const { aptosConfig, jwkAddr, options } = args;\n  let resource: MoveResource<PatchedJWKsResponse>;\n  if (!jwkAddr) {\n    const resourceType = \"0x1::jwks::PatchedJWKs\";\n    const { data } = await getAptosFullNode<{}, MoveResource<PatchedJWKsResponse>>({\n      aptosConfig,\n      originMethod: \"getKeylessJWKs\",\n      path: `accounts/0x1/resource/${resourceType}`,\n      params: { ledger_version: options?.ledgerVersion },\n    });\n    resource = data;\n  } else {\n    const resourceType = \"0x1::jwks::FederatedJWKs\";\n    const { data } = await getAptosFullNode<{}, MoveResource<PatchedJWKsResponse>>({\n      aptosConfig,\n      originMethod: \"getKeylessJWKs\",\n      path: `accounts/${AccountAddress.from(jwkAddr).toString()}/resource/${resourceType}`,\n      params: { ledger_version: options?.ledgerVersion },\n    });\n    resource = data;\n  }\n\n  // Create a map of issuer to JWK arrays\n  const jwkMap = new Map<string, MoveJWK[]>();\n  for (const entry of resource.data.jwks.entries) {\n    const jwks: MoveJWK[] = [];\n    for (const jwkStruct of entry.jwks) {\n      const { data: jwkData } = jwkStruct.variant;\n      const deserializer = new Deserializer(Hex.fromHexInput(jwkData).toUint8Array());\n      const jwk = MoveJWK.deserialize(deserializer);\n      jwks.push(jwk);\n    }\n    jwkMap.set(hexToAsciiString(entry.issuer), jwks);\n  }\n\n  return jwkMap;\n}\n\nexport class MoveJWK extends Serializable {\n  public kid: string;\n\n  public kty: string;\n\n  public alg: string;\n\n  public e: string;\n\n  public n: string;\n\n  constructor(args: { kid: string; kty: string; alg: string; e: string; n: string }) {\n    super();\n    const { kid, kty, alg, e, n } = args;\n    this.kid = kid;\n    this.kty = kty;\n    this.alg = alg;\n    this.e = e;\n    this.n = n;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.kid);\n    serializer.serializeStr(this.kty);\n    serializer.serializeStr(this.alg);\n    serializer.serializeStr(this.e);\n    serializer.serializeStr(this.n);\n  }\n\n  static fromMoveStruct(struct: MoveAnyStruct): MoveJWK {\n    const { data } = struct.variant;\n    const deserializer = new Deserializer(Hex.fromHexInput(data).toUint8Array());\n    return MoveJWK.deserialize(deserializer);\n  }\n\n  static deserialize(deserializer: Deserializer): MoveJWK {\n    const kid = deserializer.deserializeStr();\n    const kty = deserializer.deserializeStr();\n    const alg = deserializer.deserializeStr();\n    const n = deserializer.deserializeStr();\n    const e = deserializer.deserializeStr();\n    return new MoveJWK({ kid, kty, alg, n, e });\n  }\n}\n\ninterface JwtHeader {\n  kid: string; // Key ID\n}\n/**\n * Safely parses the JWT header.\n * @param jwtHeader The JWT header string\n * @returns Parsed JWT header as an object.\n */\nexport function parseJwtHeader(jwtHeader: string): JwtHeader {\n  try {\n    const header = JSON.parse(jwtHeader);\n    if (header.kid === undefined) {\n      throw new Error(\"JWT header missing kid\");\n    }\n    return header;\n  } catch (error) {\n    throw new Error(\"Failed to parse JWT header.\");\n  }\n}\n"],"mappings":"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","names":["jwtDecode","sha3_256","EPK_HORIZON_SECS","MAX_AUD_VAL_BYTES","MAX_UID_KEY_BYTES","MAX_UID_VAL_BYTES","MAX_ISS_VAL_BYTES","MAX_EXTRA_FIELD_BYTES","MAX_JWT_HEADER_B64_BYTES","MAX_COMMITED_EPK_BYTES","_KeylessPublicKey","AccountPublicKey","iss","idCommitment","idcBytes","Hex","serializer","Serializer","AuthenticationKey","args","deserializer","addressSeed","publicKey","computeIdCommitment","jwt","pepper","uidKey","jwtPayload","jwtDecode","uidVal","KeylessPublicKey","aud","fields","bytesToBigIntLE","hashStrToField","bigIntToBytesLE","poseidonHash","KeylessSignature","_KeylessSignature","Signature","jwtHeader","ephemeralCertificate","expiryDateSecs","ephemeralPublicKey","ephemeralSignature","parseJwtHeader","EphemeralCertificate","EphemeralPublicKey","EphemeralSignature","ZeroKnowledgeSig","ZkProof","Groth16Zkp","Ed25519PublicKey","Ed25519Signature","signature","_EphemeralCertificate","variant","G1Bytes","_G1Bytes","Serializable","data","bytes","G2Bytes","_G2Bytes","_Groth16Zkp","Proof","a","b","c","_ZkProof","proof","_ZeroKnowledgeSig","expHorizonSecs","trainingWheelsSignature","extraField","overrideAudVal","Deserializer","KeylessConfiguration","_KeylessConfiguration","verificationKey","maxExpHorizonSecs","res","Groth16VerificationKey","_Groth16VerificationKey","alphaG1","betaG2","deltaG2","gammaAbcG1","gammaG2","sha3_256","getKeylessConfig","aptosConfig","memoizeAsync","config","getKeylessConfigurationResource","vk","getGroth16VerificationKeyResource","error","KeylessError","getIssAudAndUidVal","getErrorMessage","options","resourceType","getAptosFullNode","AccountAddress","getKeylessJWKs","jwkAddr","resource","jwkMap","entry","jwks","jwkStruct","jwkData","jwk","MoveJWK","hexToAsciiString","_MoveJWK","kid","kty","alg","e","struct","n","header"]}

package/dist/esm/chunk-HYJQHVDZ.mjs

@@ -1,2 +0,0 @@
-import{b as g}from"./chunk-CPAAEEF4.mjs";import{b as m}from"./chunk-WHVCUVZP.mjs";import{a as p}from"./chunk-MAWGZICD.mjs";import{e as a}from"./chunk-BPHCRTHD.mjs";import{b as d,c as u}from"./chunk-QUJM5W4L.mjs";import{b as y}from"./chunk-LQOSHBB7.mjs";var A=class l{constructor(e){this.signingScheme=3;let{multiKey:i,address:s}=e,n=e.signers.map(t=>t instanceof p?m.fromEd25519Account(t):t);if(i.signaturesRequired>n.length)throw new Error(`Not enough signers provided to satisfy the required signatures. Need ${i.signaturesRequired} signers, but only ${n.length} provided`);if(i.signaturesRequired<n.length)throw new Error(`More signers provided than required. Need ${i.signaturesRequired} signers, but ${n.length} provided`);this.publicKey=i,this.accountAddress=s?y.from(s):this.publicKey.authKey().derivedAddress();let r=[];for(let t of n)r.push(this.publicKey.getIndex(t.getAnyPublicKey()));let o=n.map((t,c)=>[t,r[c]]);o.sort((t,c)=>t[1]-c[1]),this.signers=o.map(t=>t[0]),this.signerIndicies=o.map(t=>t[1]),this.signaturesBitmap=this.publicKey.createBitmap({bits:r})}static fromPublicKeysAndSigners(e){let{publicKeys:i,signaturesRequired:s,signers:n}=e,r=new d({publicKeys:i,signaturesRequired:s});return new l({multiKey:r,signers:n})}static isMultiKeySigner(e){return e instanceof l}signWithAuthenticator(e){return new a(this.publicKey,this.sign(e))}signTransactionWithAuthenticator(e){return new a(this.publicKey,this.signTransaction(e))}async waitForProofFetch(){let i=this.signers.filter(s=>s instanceof g).map(async s=>s.waitForProofFetch());await Promise.all(i)}async checkKeylessAccountValidity(e){let s=this.signers.filter(n=>n instanceof g).map(n=>n.checkKeylessAccountValidity(e));await Promise.all(s)}sign(e){let i=[];for(let s of this.signers)i.push(s.sign(e));return new u({signatures:i,bitmap:this.signaturesBitmap})}signTransaction(e){let i=[];for(let s of this.signers)i.push(s.signTransaction(e));return new u({signatures:i,bitmap:this.signaturesBitmap})}verifySignature(e){let{message:i,signature:s}=e;if(!this.signerIndicies.every((r,o)=>o===0||r>=this.signerIndicies[o-1]))return!1;for(let r=0;r<s.signatures.length;r+=1){let o=s.signatures[r];if(!this.publicKey.publicKeys[this.signerIndicies[r]].verifySignature({message:i,signature:o}))return!1}return!0}};export{A as a};
-//# sourceMappingURL=chunk-HYJQHVDZ.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/MultiKeyAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Account } from \"./Account\";\nimport { MultiKey, MultiKeySignature, PublicKey } from \"../core/crypto\";\nimport { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { HexInput, SigningScheme } from \"../types\";\nimport { AccountAuthenticatorMultiKey } from \"../transactions/authenticator/account\";\nimport { AnyRawTransaction } from \"../transactions/types\";\nimport { AbstractKeylessAccount, KeylessSigner } from \"./AbstractKeylessAccount\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { SingleKeyAccount, SingleKeySigner, SingleKeySignerOrLegacyEd25519Account } from \"./SingleKeyAccount\";\nimport { Ed25519Account } from \"./Ed25519Account\";\n\n/**\n * Arguments required to verify a multi-key signature against a given message.\n *\n * @param message - The original message that was signed.\n * @param signature - The multi-key signature to be verified.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface VerifyMultiKeySignatureArgs {\n  message: HexInput;\n  signature: MultiKeySignature;\n}\n\n/**\n * Signer implementation for the MultiKey authentication scheme.\n *\n * This account utilizes an M of N signing scheme, where M and N are specified in the {@link MultiKey}.\n * It signs messages using an array of M accounts, each corresponding to a public key in the {@link MultiKey}.\n *\n * Note: Generating a signer instance does not create the account on-chain.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class MultiKeyAccount implements Account, KeylessSigner {\n  /**\n   * Public key associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly publicKey: MultiKey;\n\n  /**\n   * Account address associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly accountAddress: AccountAddress;\n\n  /**\n   * Signing scheme used to sign transactions\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly signingScheme: SigningScheme = SigningScheme.MultiKey;\n\n  /**\n   * The signers used to sign messages.  These signers should correspond to public keys in the\n   * MultiKeyAccount's public key.  The number of signers should be equal to this.publicKey.signaturesRequired.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly signers: Account[];\n\n  /**\n   * An array of indices where for signer[i], signerIndicies[i] is the index of the corresponding public key in\n   * publicKey.publicKeys.  Used to derive the right public key to use for verification.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  // TODO: Rename Indicies to Indices\n  readonly signerIndicies: number[];\n\n  readonly signaturesBitmap: Uint8Array;\n\n  /**\n   * Constructs a MultiKeyAccount instance, which requires multiple signatures for transactions.\n   *\n   * @param args - The arguments for creating a MultiKeyAccount.\n   * @param args.multiKey - The multikey of the account consisting of N public keys and a number M representing the required signatures.\n   * @param args.signers - An array of M signers that will be used to sign the transaction.\n   * @param args.address - An optional account address input. If not provided, the derived address from the public key will be used.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  constructor(args: {\n    multiKey: MultiKey;\n    signers: SingleKeySignerOrLegacyEd25519Account[];\n    address?: AccountAddressInput;\n  }) {\n    const { multiKey, address } = args;\n\n    const signers: SingleKeySigner[] = args.signers.map((signer) =>\n      signer instanceof Ed25519Account ? SingleKeyAccount.fromEd25519Account(signer) : signer,\n    );\n\n    if (multiKey.signaturesRequired > signers.length) {\n      throw new Error(\n        // eslint-disable-next-line max-len\n        `Not enough signers provided to satisfy the required signatures. Need ${multiKey.signaturesRequired} signers, but only ${signers.length} provided`,\n      );\n    } else if (multiKey.signaturesRequired < signers.length) {\n      throw new Error(\n        // eslint-disable-next-line max-len\n        `More signers provided than required. Need ${multiKey.signaturesRequired} signers, but ${signers.length} provided`,\n      );\n    }\n\n    this.publicKey = multiKey;\n\n    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();\n\n    // For each signer, find its corresponding position in the MultiKey's public keys array\n    const bitPositions: number[] = [];\n    for (const signer of signers) {\n      bitPositions.push(this.publicKey.getIndex(signer.getAnyPublicKey()));\n    }\n\n    // Create pairs of [signer, position] and sort them by position\n    // This sorting is critical because:\n    // 1. The on-chain verification expects signatures to be in ascending order by bit position\n    // 2. The bitmap must match the order of signatures when verifying\n    const signersAndBitPosition: [Account, number][] = signers.map((signer, index) => [signer, bitPositions[index]]);\n    signersAndBitPosition.sort((a, b) => a[1] - b[1]);\n\n    // Extract the sorted signers and their positions into separate arrays\n    this.signers = signersAndBitPosition.map((value) => value[0]);\n    this.signerIndicies = signersAndBitPosition.map((value) => value[1]);\n\n    // Create a bitmap representing which public keys from the MultiKey are being used\n    // This bitmap is used during signature verification to identify which public keys\n    // should be used to verify each signature\n    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });\n  }\n\n  /**\n   * Static constructor to create a MultiKeyAccount using the provided public keys and signers.\n   *\n   * @param args - The arguments for creating a MultiKeyAccount.\n   * @param args.publicKeys - The N public keys of the MultiKeyAccount.\n   * @param args.signaturesRequired - The number of signatures required to authorize a transaction.\n   * @param args.signers - An array of M signers that will be used to sign the transaction.\n   * @returns MultiKeyAccount - The newly created MultiKeyAccount.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static fromPublicKeysAndSigners(args: {\n    publicKeys: PublicKey[];\n    signaturesRequired: number;\n    signers: SingleKeySignerOrLegacyEd25519Account[];\n  }): MultiKeyAccount {\n    const { publicKeys, signaturesRequired, signers } = args;\n    const multiKey = new MultiKey({ publicKeys, signaturesRequired });\n    return new MultiKeyAccount({ multiKey, signers });\n  }\n\n  /**\n   * Determines if the provided account is a multi-key account.\n   *\n   * @param account - The account to check.\n   * @returns A boolean indicating whether the account is a multi-key account.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static isMultiKeySigner(account: Account): account is MultiKeyAccount {\n    return account instanceof MultiKeyAccount;\n  }\n\n  /**\n   * Sign a message using the account's signers and return an AccountAuthenticator containing the signature along with the\n   * account's public key.\n   * @param message - The signing message, represented as binary input in hexadecimal format.\n   * @returns An instance of AccountAuthenticatorMultiKey that includes the signature and the public key.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiKey {\n    return new AccountAuthenticatorMultiKey(this.publicKey, this.sign(message));\n  }\n\n  /**\n   * Sign a transaction using the account's signers, returning an AccountAuthenticator that contains the signature and the\n   * account's public key.\n   * @param transaction - The raw transaction to be signed.\n   * @returns An AccountAuthenticatorMultiKey containing the signature of the transaction along with the account's public key.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey {\n    return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));\n  }\n\n  /**\n   * Waits for any proofs on KeylessAccount signers to be fetched. This ensures that signing with the KeylessAccount does not\n   * fail due to missing proofs.\n   * @return {Promise<void>} A promise that resolves when all proofs have been fetched.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  async waitForProofFetch(): Promise<void> {\n    const keylessSigners = this.signers.filter(\n      (signer) => signer instanceof AbstractKeylessAccount,\n    ) as AbstractKeylessAccount[];\n    const promises = keylessSigners.map(async (signer) => signer.waitForProofFetch());\n    await Promise.all(promises);\n  }\n\n  /**\n   * Validates that the Keyless Account can be used to sign transactions.\n   * @return\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  async checkKeylessAccountValidity(aptosConfig: AptosConfig): Promise<void> {\n    const keylessSigners = this.signers.filter(\n      (signer) => signer instanceof AbstractKeylessAccount,\n    ) as AbstractKeylessAccount[];\n    const promises = keylessSigners.map((signer) => signer.checkKeylessAccountValidity(aptosConfig));\n    await Promise.all(promises);\n  }\n\n  /**\n   * Sign the given message using the MultiKeyAccount's signers\n   * @param data - The data to be signed in HexInput format.\n   * @returns MultiKeySignature\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  sign(data: HexInput): MultiKeySignature {\n    const signatures = [];\n    for (const signer of this.signers) {\n      signatures.push(signer.sign(data));\n    }\n    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });\n  }\n\n  /**\n   * Sign the given transaction using the MultiKeyAccount's signers.\n   * This function aggregates signatures from all signers associated with the MultiKeyAccount.\n   *\n   * @param transaction - The transaction to be signed.\n   * @returns MultiKeySignature - An object containing the aggregated signatures and a bitmap of the signatures.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signTransaction(transaction: AnyRawTransaction): MultiKeySignature {\n    const signatures = [];\n    for (const signer of this.signers) {\n      signatures.push(signer.signTransaction(transaction));\n    }\n    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });\n  }\n\n  /**\n   * Verify the given message and signature with the public keys.\n   *\n   * This function checks if the provided signatures are valid for the given message using the corresponding public keys.\n   *\n   * @param args - The arguments for verifying the signature.\n   * @param args.message - The raw message data in HexInput format.\n   * @param args.signature - The signed message MultiKeySignature containing multiple signatures.\n   * @returns A boolean indicating whether the signatures are valid for the message.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  verifySignature(args: VerifyMultiKeySignatureArgs): boolean {\n    const { message, signature } = args;\n    const isSignerIndicesSorted = this.signerIndicies.every(\n      (value, i) => i === 0 || value >= this.signerIndicies[i - 1],\n    );\n    if (!isSignerIndicesSorted) {\n      return false;\n    }\n    for (let i = 0; i < signature.signatures.length; i += 1) {\n      const singleSignature = signature.signatures[i];\n      const publicKey = this.publicKey.publicKeys[this.signerIndicies[i]];\n      if (!publicKey.verifySignature({ message, signature: singleSignature })) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n"],"mappings":"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","names":["MultiKeyAccount","_MultiKeyAccount","args","multiKey","address","signers","signer","Ed25519Account","SingleKeyAccount","AccountAddress","bitPositions","signersAndBitPosition","index","a","b","value","publicKeys","signaturesRequired","MultiKey","account","message","AccountAuthenticatorMultiKey","transaction","promises","AbstractKeylessAccount","aptosConfig","data","signatures","MultiKeySignature","signature","i","singleSignature"]}

package/dist/esm/chunk-IHYTP2EW.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-IHYTP2EW.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/chunk-ILUFGYLO.mjs

@@ -1,2 +0,0 @@
-import{b as s}from"./chunk-LQOSHBB7.mjs";import{E as r}from"./chunk-R6QCPXQG.mjs";function o(i){let e=i.deserializeUleb128AsU32();if(!Object.values(r).includes(e))throw new Error(`Deserialization of Account failed: SigningScheme variant ${e} is invalid`);return{address:s.deserialize(i),signingScheme:e}}export{o as a};
-//# sourceMappingURL=chunk-ILUFGYLO.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/utils.ts"],"sourcesContent":["import { SigningScheme } from \"../types\";\nimport { AccountAddress } from \"../core\";\nimport { Deserializer } from \"../bcs/deserializer\";\n\nexport function deserializeSchemeAndAddress(deserializer: Deserializer): {\n  address: AccountAddress;\n  signingScheme: SigningScheme;\n} {\n  const signingScheme = deserializer.deserializeUleb128AsU32();\n  // Validate that signingScheme is a valid SigningScheme value\n  if (!Object.values(SigningScheme).includes(signingScheme)) {\n    throw new Error(`Deserialization of Account failed: SigningScheme variant ${signingScheme} is invalid`);\n  }\n  const address = AccountAddress.deserialize(deserializer);\n  return { address, signingScheme };\n}\n"],"mappings":"kFAIO,SAASA,EAA4BC,EAG1C,CACA,IAAMC,EAAgBD,EAAa,wBAAwB,EAE3D,GAAI,CAAC,OAAO,OAAOE,CAAa,EAAE,SAASD,CAAa,EACtD,MAAM,IAAI,MAAM,4DAA4DA,CAAa,aAAa,EAGxG,MAAO,CAAE,QADOE,EAAe,YAAYH,CAAY,EACrC,cAAAC,CAAc,CAClC","names":["deserializeSchemeAndAddress","deserializer","signingScheme","SigningScheme","AccountAddress"]}

package/dist/esm/chunk-IMYNN4TW.mjs

@@ -1,2 +0,0 @@
-import{a as r}from"./chunk-RIINVEZA.mjs";import{a as m,c as a,d as f}from"./chunk-HHWJHOFZ.mjs";import{a as i,b as o,c as u,d as s,e as p,f as c,g as y}from"./chunk-TKXEVD7A.mjs";import{b as g}from"./chunk-LQOSHBB7.mjs";function D(n){return typeof n=="boolean"}function A(n){return typeof n=="string"}function F(n){return typeof n=="number"}function M(n){if(F(n))return n;if(A(n)&&n!=="")return Number.parseInt(n,10)}function N(n){return typeof n=="number"||typeof n=="bigint"||typeof n=="string"}function G(n){return n==null}function P(n){return T(n)||x(n)||S(n)||B(n)||U(n)||b(n)||I(n)||E(n)||l(n)||d(n)||n instanceof m||n instanceof f}function T(n){return n instanceof i}function E(n){return n instanceof g}function l(n){return n instanceof a}function d(n){return n instanceof r}function x(n){return n instanceof o}function S(n){return n instanceof u}function B(n){return n instanceof s}function U(n){return n instanceof p}function b(n){return n instanceof c}function I(n){return n instanceof y}function w(n){return"bytecode"in n}function O(n,t){throw new Error(`Type mismatch for argument ${t}, expected '${n}'`)}function R(n){let t=n.params.findIndex(e=>e!=="signer"&&e!=="&signer");return t<0?n.params.length:t}export{D as a,A as b,F as c,M as d,N as e,G as f,P as g,T as h,E as i,l as j,d as k,x as l,S as m,B as n,U as o,b as p,I as q,w as r,O as s,R as t};
-//# sourceMappingURL=chunk-IMYNN4TW.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/transactionBuilder/helpers.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  EntryFunctionArgumentTypes,\n  InputGenerateTransactionPayloadData,\n  InputGenerateTransactionPayloadDataWithRemoteABI,\n  InputScriptData,\n  SimpleEntryFunctionArgumentTypes,\n} from \"../types\";\nimport { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from \"../../bcs\";\nimport { AccountAddress } from \"../../core\";\nimport { MoveFunction } from \"../../types\";\n\n/**\n * Determines if the provided argument is of type boolean.\n * This can help in validating input types before processing them further.\n *\n * @param arg - The argument to check, which can be of various types.\n * @returns A boolean indicating whether the argument is a boolean.\n * @group Implementation\n * @category Transactions\n */\nexport function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean {\n  return typeof arg === \"boolean\";\n}\n\n/**\n * Checks if the provided argument is of type string.\n *\n * @param arg - The value to be checked for string type.\n * @returns A boolean indicating whether the argument is a string.\n * @group Implementation\n * @category Transactions\n */\nexport function isString(arg: any): arg is string {\n  return typeof arg === \"string\";\n}\n\n/**\n * Determines if the provided argument is of type number.\n *\n * @param arg - The argument to check, which can be of various types.\n * @returns A boolean indicating whether the argument is a number.\n * @group Implementation\n * @category Transactions\n */\nexport function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number {\n  return typeof arg === \"number\";\n}\n\n/**\n * Converts a number or a string representation of a number into a number type.\n * This function is useful for ensuring that the input is in a consistent numeric format,\n * which can help prevent type mismatches in further processing.\n *\n * @param arg - The input value to be converted. This can be a number, a string representing a number, or any other type.\n * @returns Returns the converted number if the input is valid; otherwise, it returns undefined.\n * @group Implementation\n * @category Transactions\n */\nexport function convertNumber(arg: SimpleEntryFunctionArgumentTypes): number | undefined {\n  if (isNumber(arg)) {\n    return arg;\n  }\n  if (isString(arg) && arg !== \"\") {\n    return Number.parseInt(arg, 10);\n  }\n\n  return undefined;\n}\n\n/**\n * Determines if the provided argument is a large number, which can be a number, bigint, or string representation of a number.\n *\n * @param arg - The argument to check, which can be of type number, bigint, or string.\n * @group Implementation\n * @category Transactions\n */\nexport function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string {\n  return typeof arg === \"number\" || typeof arg === \"bigint\" || typeof arg === \"string\";\n}\n\n/**\n * Checks if the provided argument is empty, meaning it is either null or undefined.\n *\n * @param arg - The argument to check for emptiness.\n * @returns A boolean indicating whether the argument is empty.\n * @group Implementation\n * @category Transactions\n */\nexport function isEmptyOption(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined {\n  return arg === null || arg === undefined;\n}\n\n/**\n * Determines if the provided argument is a valid encoded entry function argument type.\n * This function helps validate that the argument conforms to the expected types for entry function parameters.\n *\n * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n * @group Implementation\n * @category Transactions\n */\nexport function isEncodedEntryFunctionArgument(\n  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n): arg is EntryFunctionArgumentTypes {\n  return (\n    /**\n     * Determines if the provided argument is an instance of the Bool class.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsBool(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U8.\n     * This function helps validate the type of the argument passed to ensure it is a U8 type.\n     *\n     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU8(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U16.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU16(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U32.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @returns A boolean indicating whether the argument is a U32 instance.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU32(arg) ||\n    /**\n     * Determine if the provided argument is an instance of U64.\n     * This function helps validate that the argument conforms to the expected U64 type.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU64(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U128.\n     * This function helps validate the type of the argument passed to ensure it is a U128 type.\n     *\n     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU128(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U256.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @returns A boolean indicating whether the argument is a U256 instance.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU256(arg) ||\n    /**\n     * Determines if the provided argument is an instance of AccountAddress.\n     * This function helps validate whether a given input corresponds to a valid BCS address type.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsAddress(arg) ||\n    /**\n     * Determine if the provided argument is an instance of MoveString.\n     *\n     * @param arg - The argument to check, which can be of types EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsString(arg) ||\n    /**\n     * Determine if the provided argument is an instance of FixedBytes.\n     * This function helps to validate the type of the argument being passed.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsFixedBytes(arg) ||\n    arg instanceof MoveVector ||\n    arg instanceof MoveOption\n  );\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsBool(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is Bool {\n  return arg instanceof Bool;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsAddress(\n  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n): arg is AccountAddress {\n  return arg instanceof AccountAddress;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsString(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is MoveString {\n  return arg instanceof MoveString;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsFixedBytes(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is FixedBytes {\n  return arg instanceof FixedBytes;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U8 {\n  return arg instanceof U8;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U16 {\n  return arg instanceof U16;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U32 {\n  return arg instanceof U32;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U64 {\n  return arg instanceof U64;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U128 {\n  return arg instanceof U128;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256 {\n  return arg instanceof U256;\n}\n\n/**\n * Determines if the provided argument contains script data input by checking for the presence of bytecode.\n *\n * @param arg - The input data to be checked, which can either be a payload with remote ABI or a standard payload.\n * @param arg.bytecode - The bytecode of the script, present if the input is script data.\n * @param arg.function - The function associated with the transaction, which is relevant for standard payloads.\n * @param arg.args - The arguments for the function, applicable in the context of standard payloads.\n * @group Implementation\n * @category Transactions\n */\nexport function isScriptDataInput(\n  arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData,\n): arg is InputScriptData {\n  return \"bytecode\" in arg;\n}\n\n/**\n * Throws an error indicating a type mismatch for a specified argument position.\n * This function helps in debugging by providing clear feedback on expected types.\n *\n * @param expectedType - The type that was expected for the argument.\n * @param position - The position of the argument that caused the type mismatch.\n * @group Implementation\n * @category Transactions\n */\nexport function throwTypeMismatch(expectedType: string, position: number) {\n  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);\n}\n\n/**\n * Finds the index of the first non-signer argument in the function ABI parameters.\n *\n * A function is often defined with a `signer` or `&signer` arguments at the start, which are filled in\n * by signatures and not by the caller. This function helps identify the position of the first argument that\n * can be provided by the caller, allowing for easier handling of function parameters.\n *\n * @param functionAbi - The ABI of the function to analyze.\n * @returns The index of the first non-signer argument, or the length of the parameters array if none are found.\n * @group Implementation\n * @category Transactions\n */\nexport function findFirstNonSignerArg(functionAbi: MoveFunction): number {\n  const index = functionAbi.params.findIndex((param) => param !== \"signer\" && param !== \"&signer\");\n  if (index < 0) {\n    return functionAbi.params.length;\n  }\n  return index;\n}\n"],"mappings":"4NAuBO,SAASA,EAAOC,EAAuD,CAC5E,OAAO,OAAOA,GAAQ,SACxB,CAUO,SAASC,EAASD,EAAyB,CAChD,OAAO,OAAOA,GAAQ,QACxB,CAUO,SAASE,EAASF,EAAsD,CAC7E,OAAO,OAAOA,GAAQ,QACxB,CAYO,SAASG,EAAcH,EAA2D,CACvF,GAAIE,EAASF,CAAG,EACd,OAAOA,EAET,GAAIC,EAASD,CAAG,GAAKA,IAAQ,GAC3B,OAAO,OAAO,SAASA,EAAK,EAAE,CAIlC,CASO,SAASI,EAAcJ,EAAwE,CACpG,OAAO,OAAOA,GAAQ,UAAY,OAAOA,GAAQ,UAAY,OAAOA,GAAQ,QAC9E,CAUO,SAASK,EAAcL,EAAgE,CAC5F,OAAOA,GAAQ,IACjB,CAUO,SAASM,EACdN,EACmC,CACnC,OAQEO,EAAUP,CAAG,GASbQ,EAAQR,CAAG,GAQXS,EAAST,CAAG,GASZU,EAASV,CAAG,GASZW,EAASX,CAAG,GASZY,EAAUZ,CAAG,GASba,EAAUb,CAAG,GASbc,EAAad,CAAG,GAQhBe,EAAYf,CAAG,GASfgB,EAAgBhB,CAAG,GACnBA,aAAeiB,GACfjB,aAAekB,CAEnB,CAKO,SAASX,EAAUP,EAAiF,CACzG,OAAOA,aAAemB,CACxB,CAKO,SAASL,EACdd,EACuB,CACvB,OAAOA,aAAeoB,CACxB,CAKO,SAASL,EAAYf,EAAuF,CACjH,OAAOA,aAAeqB,CACxB,CAKO,SAASL,EAAgBhB,EAAuF,CACrH,OAAOA,aAAesB,CACxB,CAKO,SAASd,EAAQR,EAA+E,CACrG,OAAOA,aAAeuB,CACxB,CAKO,SAASd,EAAST,EAAgF,CACvG,OAAOA,aAAewB,CACxB,CAKO,SAASd,EAASV,EAAgF,CACvG,OAAOA,aAAeyB,CACxB,CAKO,SAASd,EAASX,EAAgF,CACvG,OAAOA,aAAe0B,CACxB,CAKO,SAASd,EAAUZ,EAAiF,CACzG,OAAOA,aAAe2B,CACxB,CAKO,SAASd,EAAUb,EAAiF,CACzG,OAAOA,aAAe4B,CACxB,CAYO,SAASC,EACd7B,EACwB,CACxB,MAAO,aAAcA,CACvB,CAWO,SAAS8B,EAAkBC,EAAsBC,EAAkB,CACxE,MAAM,IAAI,MAAM,8BAA8BA,CAAQ,eAAeD,CAAY,GAAG,CACtF,CAcO,SAASE,EAAsBC,EAAmC,CACvE,IAAMC,EAAQD,EAAY,OAAO,UAAWE,GAAUA,IAAU,UAAYA,IAAU,SAAS,EAC/F,OAAID,EAAQ,EACHD,EAAY,OAAO,OAErBC,CACT","names":["isBool","arg","isString","isNumber","convertNumber","isLargeNumber","isEmptyOption","isEncodedEntryFunctionArgument","isBcsBool","isBcsU8","isBcsU16","isBcsU32","isBcsU64","isBcsU128","isBcsU256","isBcsAddress","isBcsString","isBcsFixedBytes","MoveVector","MoveOption","Bool","AccountAddress","MoveString","FixedBytes","U8","U16","U32","U64","U128","U256","isScriptDataInput","throwTypeMismatch","expectedType","position","findFirstNonSignerArg","functionAbi","index","param"]}

package/dist/esm/chunk-JNNFNYDO.mjs

@@ -1,2 +0,0 @@
-import{a as m}from"./chunk-DOVH6HPL.mjs";import{e as h,j as d}from"./chunk-C3Q23D22.mjs";import{a as u}from"./chunk-7CRQNXR5.mjs";import{a as f}from"./chunk-H4YAL2IL.mjs";import{a as S}from"./chunk-A3VO773Q.mjs";import{a as g}from"./chunk-RXHER6EA.mjs";import{b as s}from"./chunk-VHY6ZATX.mjs";import{sha3_256 as H}from"@noble/hashes/sha3";import{secp256k1 as y}from"@noble/curves/secp256k1";import{HDKey as A}from"@scure/bip32";var i=class i extends f{constructor(e){super();let t=s.fromHexInput(e),{length:r}=t.toUint8Array();if(r===i.LENGTH)this.key=t;else if(r===i.COMPRESSED_LENGTH){let o=y.ProjectivePoint.fromHex(t.toUint8Array());this.key=s.fromHexInput(o.toRawBytes(!1))}else throw new Error(`PublicKey length should be ${i.LENGTH} or ${i.COMPRESSED_LENGTH}, received ${r}`)}verifySignature(e){let{message:t,signature:r}=e,o=m(t),c=s.fromHexInput(o).toUint8Array(),x=H(c),P=r.toUint8Array();return y.verify(P,x,this.key.toUint8Array(),{lowS:!0})}toUint8Array(){return this.key.toUint8Array()}serialize(e){e.serializeBytes(this.key.toUint8Array())}deserialize(e){let t=e.deserializeBytes();return new l(t)}static deserialize(e){let t=e.deserializeBytes();return new i(t)}static isPublicKey(e){return e instanceof i}static isInstance(e){return"key"in e&&e.key?.data?.length===i.LENGTH}};i.LENGTH=65,i.COMPRESSED_LENGTH=33;var p=i,n=class n extends g{constructor(e,t){super();let r=u.parseHexInput(e,"secp256k1",t);if(r.toUint8Array().length!==n.LENGTH)throw new Error(`PrivateKey length should be ${n.LENGTH}`);this.key=r}static generate(){let e=y.utils.randomPrivateKey();return new n(e,!1)}static fromDerivationPath(e,t){if(!h(e))throw new Error(`Invalid derivation path ${e}`);return n.fromDerivationPathInner(e,d(t))}static fromDerivationPathInner(e,t){let{privateKey:r}=A.fromMasterSeed(t).derive(e);if(r===null)throw new Error("Invalid key");return new n(r,!1)}sign(e){let t=m(e),r=s.fromHexInput(t),o=H(r.toUint8Array()),c=y.sign(o,this.key.toUint8Array(),{lowS:!0});return new l(c.toCompactRawBytes())}publicKey(){let e=y.getPublicKey(this.key.toUint8Array(),!1);return new p(e)}toUint8Array(){return this.key.toUint8Array()}toString(){return this.toHexString()}toHexString(){return this.key.toString()}toAIP80String(){return u.formatPrivateKey(this.key.toString(),"secp256k1")}serialize(e){e.serializeBytes(this.toUint8Array())}static deserialize(e){let t=e.deserializeBytes();return new n(t,!1)}static isPrivateKey(e){return e instanceof n}};n.LENGTH=32;var v=n,a=class a extends S{constructor(e){super();let t=s.fromHexInput(e);if(t.toUint8Array().length!==a.LENGTH)throw new Error(`Signature length should be ${a.LENGTH}, received ${t.toUint8Array().length}`);this.data=t}toUint8Array(){return this.data.toUint8Array()}serialize(e){e.serializeBytes(this.data.toUint8Array())}static deserialize(e){let t=e.deserializeBytes();return new a(t)}};a.LENGTH=64;var l=a;export{p as a,v as b,l as c};
-//# sourceMappingURL=chunk-JNNFNYDO.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/secp256k1.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sha3_256 } from \"@noble/hashes/sha3\";\nimport { secp256k1 } from \"@noble/curves/secp256k1\";\nimport { HDKey } from \"@scure/bip32\";\nimport { Serializable, Deserializer, Serializer } from \"../../bcs\";\nimport { Hex } from \"../hex\";\nimport { HexInput, PrivateKeyVariants } from \"../../types\";\nimport { isValidBIP44Path, mnemonicToSeed } from \"./hdKey\";\nimport { PrivateKey } from \"./privateKey\";\nimport { PublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { convertSigningMessage } from \"./utils\";\n\n/**\n * Represents a Secp256k1 ECDSA public key.\n *\n * @extends PublicKey\n * @property LENGTH - The length of the Secp256k1 public key in bytes.\n * @group Implementation\n * @category Serialization\n */\nexport class Secp256k1PublicKey extends PublicKey {\n  // Secp256k1 ecdsa public keys contain a prefix indicating compression and two 32-byte coordinates.\n  static readonly LENGTH: number = 65;\n\n  // If it's compressed, it is only 33 bytes\n  static readonly COMPRESSED_LENGTH: number = 33;\n\n  // Hex value of the public key\n  private readonly key: Hex;\n\n  /**\n   * Create a new PublicKey instance from a HexInput, which can be a string or Uint8Array.\n   * This constructor validates the length of the provided signature data.\n   *\n   * @param hexInput - A HexInput (string or Uint8Array) representing the signature data.\n   * @throws Error if the length of the signature data is not equal to Secp256k1Signature.LENGTH.\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(hexInput: HexInput) {\n    super();\n\n    const hex = Hex.fromHexInput(hexInput);\n    const { length } = hex.toUint8Array();\n    if (length === Secp256k1PublicKey.LENGTH) {\n      this.key = hex;\n    } else if (length === Secp256k1PublicKey.COMPRESSED_LENGTH) {\n      const point = secp256k1.ProjectivePoint.fromHex(hex.toUint8Array());\n      this.key = Hex.fromHexInput(point.toRawBytes(false));\n    } else {\n      throw new Error(\n        `PublicKey length should be ${Secp256k1PublicKey.LENGTH} or ${Secp256k1PublicKey.COMPRESSED_LENGTH}, received ${length}`,\n      );\n    }\n  }\n\n  // region PublicKey\n  /**\n   * Verifies a Secp256k1 signature against the public key.\n   *\n   * This function checks the validity of a signature for a given message, ensuring that the signature is canonical as a malleability check.\n   *\n   * @param args - The arguments for verifying the signature.\n   * @param args.message - The message that was signed.\n   * @param args.signature - The signature to verify against the public key.\n   * @group Implementation\n   * @category Serialization\n   */\n  verifySignature(args: VerifySignatureArgs): boolean {\n    const { message, signature } = args;\n    const messageToVerify = convertSigningMessage(message);\n    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();\n    const messageSha3Bytes = sha3_256(messageBytes);\n    const signatureBytes = signature.toUint8Array();\n    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true });\n  }\n\n  /**\n   * Get the data as a Uint8Array representation.\n   *\n   * @returns Uint8Array representation of the data.\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    return this.key.toUint8Array();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  /**\n   * Serializes the data into a byte array using the provided serializer.\n   * This function is essential for converting data into a format suitable for transmission or storage.\n   *\n   * @param serializer - The serializer instance used to convert the data.\n   * @group Implementation\n   * @category Serialization\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.key.toUint8Array());\n  }\n\n  /**\n   * Deserializes a Secp256k1Signature from the provided deserializer.\n   * This function allows you to reconstruct a Secp256k1Signature object from its serialized byte representation.\n   *\n   * @param deserializer - The deserializer instance used to read the serialized data.\n   * @group Implementation\n   * @category Serialization\n   */\n  // eslint-disable-next-line class-methods-use-this\n  deserialize(deserializer: Deserializer) {\n    const hex = deserializer.deserializeBytes();\n    return new Secp256k1Signature(hex);\n  }\n\n  static deserialize(deserializer: Deserializer): Secp256k1PublicKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Secp256k1PublicKey(bytes);\n  }\n\n  // endregion\n\n  /**\n   * Determine if the provided public key is an instance of Secp256k1PublicKey.\n   *\n   * @deprecated use `instanceof Secp256k1PublicKey` instead\n   * @param publicKey - The public key to check.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey {\n    return publicKey instanceof Secp256k1PublicKey;\n  }\n\n  /**\n   * Determines if the provided public key is a valid instance of a Secp256k1 public key.\n   * This function checks for the presence of a \"key\" property and validates the length of the key data.\n   *\n   * @param publicKey - The public key to validate.\n   * @returns A boolean indicating whether the public key is a valid Secp256k1 public key.\n   * @group Implementation\n   * @category Serialization\n   */\n  static isInstance(publicKey: PublicKey): publicKey is Secp256k1PublicKey {\n    return \"key\" in publicKey && (publicKey.key as any)?.data?.length === Secp256k1PublicKey.LENGTH;\n  }\n}\n\n/**\n * Represents a Secp256k1 ECDSA private key, providing functionality to create, sign messages,\n * derive public keys, and serialize/deserialize the key.\n * @group Implementation\n * @category Serialization\n */\nexport class Secp256k1PrivateKey extends Serializable implements PrivateKey {\n  /**\n   * Length of Secp256k1 ecdsa private key\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * The private key bytes\n   * @private\n   * @group Implementation\n   * @category Serialization\n   */\n  private readonly key: Hex;\n\n  // region Constructors\n\n  /**\n   * Create a new PrivateKey instance from a Uint8Array or String.\n   *\n   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   * @param strict If true, private key must AIP-80 compliant.\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(hexInput: HexInput, strict?: boolean) {\n    super();\n\n    const privateKeyHex = PrivateKey.parseHexInput(hexInput, PrivateKeyVariants.Secp256k1, strict);\n    if (privateKeyHex.toUint8Array().length !== Secp256k1PrivateKey.LENGTH) {\n      throw new Error(`PrivateKey length should be ${Secp256k1PrivateKey.LENGTH}`);\n    }\n\n    this.key = privateKeyHex;\n  }\n\n  /**\n   * Generate a new random private key.\n   *\n   * @returns Secp256k1PrivateKey - A newly generated Secp256k1 private key.\n   * @group Implementation\n   * @category Serialization\n   */\n  static generate(): Secp256k1PrivateKey {\n    const hexInput = secp256k1.utils.randomPrivateKey();\n    return new Secp256k1PrivateKey(hexInput, false);\n  }\n\n  /**\n   * Derives a private key from a mnemonic seed phrase using a specified BIP44 path.\n   *\n   * @param path - The BIP44 path to derive the key from.\n   * @param mnemonics - The mnemonic seed phrase used for key generation.\n   *\n   * @returns The generated private key.\n   *\n   * @throws Error if the provided path is not a valid BIP44 path.\n   * @group Implementation\n   * @category Serialization\n   */\n  static fromDerivationPath(path: string, mnemonics: string): Secp256k1PrivateKey {\n    if (!isValidBIP44Path(path)) {\n      throw new Error(`Invalid derivation path ${path}`);\n    }\n    return Secp256k1PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));\n  }\n\n  /**\n   * Derives a private key from a specified BIP44 path using a given seed.\n   * This function is essential for generating keys that follow the hierarchical deterministic (HD) wallet structure.\n   *\n   * @param path - The BIP44 path used for key derivation.\n   * @param seed - The seed phrase created by the mnemonics, represented as a Uint8Array.\n   * @returns The generated private key as an instance of Secp256k1PrivateKey.\n   * @throws Error if the derived private key is invalid.\n   * @group Implementation\n   * @category Serialization\n   */\n  private static fromDerivationPathInner(path: string, seed: Uint8Array): Secp256k1PrivateKey {\n    const { privateKey } = HDKey.fromMasterSeed(seed).derive(path);\n    // library returns privateKey as Uint8Array | null\n    if (privateKey === null) {\n      throw new Error(\"Invalid key\");\n    }\n\n    return new Secp256k1PrivateKey(privateKey, false);\n  }\n\n  // endregion\n\n  // region PrivateKey\n\n  /**\n   * Sign the given message with the private key.\n   * This function generates a cryptographic signature for the provided message, ensuring the signature is canonical and non-malleable.\n   *\n   * @param message - A message in HexInput format to be signed.\n   * @returns Signature - The generated signature for the provided message.\n   * @group Implementation\n   * @category Serialization\n   */\n  sign(message: HexInput): Secp256k1Signature {\n    const messageToSign = convertSigningMessage(message);\n    const messageBytes = Hex.fromHexInput(messageToSign);\n    const messageHashBytes = sha3_256(messageBytes.toUint8Array());\n    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array(), { lowS: true });\n    return new Secp256k1Signature(signature.toCompactRawBytes());\n  }\n\n  /**\n   * Derive the Secp256k1PublicKey from this private key.\n   *\n   * @returns Secp256k1PublicKey The derived public key.\n   * @group Implementation\n   * @category Serialization\n   */\n  publicKey(): Secp256k1PublicKey {\n    const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);\n    return new Secp256k1PublicKey(bytes);\n  }\n\n  /**\n   * Get the private key in bytes (Uint8Array).\n   *\n   * @returns\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    return this.key.toUint8Array();\n  }\n\n  /**\n   * Get the private key as a string representation.\n   *\n   * @returns string representation of the private key\n   * @group Implementation\n   * @category Serialization\n   */\n  toString(): string {\n    return this.toHexString();\n  }\n\n  /**\n   * Get the private key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the private key.\n   */\n  toHexString(): string {\n    return this.key.toString();\n  }\n\n  /**\n   * Get the private key as a AIP-80 compliant hex string.\n   *\n   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)\n   *\n   * @returns AIP-80 compliant string representation of the private key.\n   */\n  toAIP80String(): string {\n    return PrivateKey.formatPrivateKey(this.key.toString(), PrivateKeyVariants.Secp256k1);\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Secp256k1PrivateKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Secp256k1PrivateKey(bytes, false);\n  }\n\n  // endregion\n\n  /**\n   * Determines if the provided private key is an instance of Secp256k1PrivateKey.\n   *\n   * @param privateKey - The private key to be checked.\n   *\n   * @deprecated use `instanceof Secp256k1PrivateKey` instead\n   * @group Implementation\n   * @category Serialization\n   */\n  static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey {\n    return privateKey instanceof Secp256k1PrivateKey;\n  }\n}\n\n/**\n * Represents a signature of a message signed using a Secp256k1 ECDSA private key.\n *\n * @group Implementation\n * @category Serialization\n */\nexport class Secp256k1Signature extends Signature {\n  /**\n   * Secp256k1 ecdsa signatures are 256-bit.\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly LENGTH = 64;\n\n  /**\n   * The signature bytes\n   * @private\n   * @group Implementation\n   * @category Serialization\n   */\n  private readonly data: Hex;\n\n  // region Constructors\n\n  /**\n   * Create a new Signature instance from a Uint8Array or String.\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(hexInput: HexInput) {\n    super();\n    const data = Hex.fromHexInput(hexInput);\n    if (data.toUint8Array().length !== Secp256k1Signature.LENGTH) {\n      throw new Error(\n        `Signature length should be ${Secp256k1Signature.LENGTH}, received ${data.toUint8Array().length}`,\n      );\n    }\n    this.data = data;\n  }\n\n  // endregion\n\n  // region Signature\n\n  toUint8Array(): Uint8Array {\n    return this.data.toUint8Array();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.data.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Secp256k1Signature {\n    const hex = deserializer.deserializeBytes();\n    return new Secp256k1Signature(hex);\n  }\n\n  // endregion\n}\n"],"mappings":"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","names":["sha3_256","secp256k1","HDKey","_Secp256k1PublicKey","PublicKey","hexInput","hex","Hex","length","point","secp256k1","args","message","signature","messageToVerify","convertSigningMessage","messageBytes","messageSha3Bytes","sha3_256","signatureBytes","serializer","deserializer","Secp256k1Signature","bytes","publicKey","Secp256k1PublicKey","_Secp256k1PrivateKey","Serializable","strict","privateKeyHex","PrivateKey","path","mnemonics","isValidBIP44Path","mnemonicToSeed","seed","privateKey","HDKey","messageToSign","messageHashBytes","Secp256k1PrivateKey","_Secp256k1Signature","Signature","data"]}

package/dist/esm/chunk-JXCZTOYC.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-JXCZTOYC.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/chunk-K233I26C.mjs

@@ -1,2 +0,0 @@
-import{c as a}from"./chunk-KK5HUWF6.mjs";import{u as n}from"./chunk-VHNX2NUR.mjs";import{b as s}from"./chunk-LQOSHBB7.mjs";async function d(e){let{aptosConfig:o,options:t}=e,r={query:n,variables:{where_condition:t?.where,offset:t?.offset,limit:t?.limit,order_by:t?.orderBy}};return(await a({aptosConfig:o,query:r,originMethod:"getObjectData"})).current_objects}async function f(e){let{aptosConfig:o,objectAddress:t,options:r}=e,c={object_address:{_eq:s.from(t).toStringLong()}};return(await d({aptosConfig:o,options:{...r,where:c}}))[0]}export{d as a,f as b};
-//# sourceMappingURL=chunk-K233I26C.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/object.ts"],"sourcesContent":["import { AptosConfig } from \"../api/aptosConfig\";\nimport { AccountAddressInput, AccountAddress } from \"../core\";\nimport { PaginationArgs, OrderByArg, GetObjectDataQueryResponse, WhereArg } from \"../types\";\nimport { GetObjectDataQuery } from \"../types/generated/operations\";\nimport { GetObjectData } from \"../types/generated/queries\";\nimport { CurrentObjectsBoolExp } from \"../types/generated/types\";\nimport { queryIndexer } from \"./general\";\n\n/**\n * Retrieves the current objects based on specified filtering and pagination options.\n *\n * @param args - The arguments for retrieving object data.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param [args.options] - Optional parameters for pagination and filtering.\n * @param [args.options.offset] - The number of items to skip before starting to collect the result set.\n * @param [args.options.limit] - The maximum number of items to return.\n * @param [args.options.orderBy] - The criteria for ordering the results.\n * @param [args.options.where] - The conditions to filter the results.\n * @returns The current objects that match the specified criteria.\n * @group Implementation\n */\nexport async function getObjectData(args: {\n  aptosConfig: AptosConfig;\n  options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]> & WhereArg<CurrentObjectsBoolExp>;\n}): Promise<GetObjectDataQueryResponse> {\n  const { aptosConfig, options } = args;\n\n  const graphqlQuery = {\n    query: GetObjectData,\n    variables: {\n      where_condition: options?.where,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n  const data = await queryIndexer<GetObjectDataQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getObjectData\",\n  });\n\n  return data.current_objects;\n}\n\n/**\n * Retrieves the object data associated with a specific object address.\n * This function allows you to access detailed information about an object in the Aptos blockchain.\n *\n * @param args - The arguments for retrieving object data.\n * @param args.aptosConfig - The configuration for connecting to the Aptos blockchain.\n * @param args.objectAddress - The address of the object whose data is being retrieved.\n * @param args.options - Optional parameters for pagination and ordering of the results.\n * @group Implementation\n */\nexport async function getObjectDataByObjectAddress(args: {\n  aptosConfig: AptosConfig;\n  objectAddress: AccountAddressInput;\n  options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;\n}): Promise<GetObjectDataQueryResponse[0]> {\n  const { aptosConfig, objectAddress, options } = args;\n  const address = AccountAddress.from(objectAddress).toStringLong();\n\n  const whereCondition: { object_address: { _eq: string } } = {\n    object_address: { _eq: address },\n  };\n  return (await getObjectData({ aptosConfig, options: { ...options, where: whereCondition } }))[0];\n}\n"],"mappings":"2HAqBA,eAAsBA,EAAcC,EAGI,CACtC,GAAM,CAAE,YAAAC,EAAa,QAAAC,CAAQ,EAAIF,EAE3BG,EAAe,CACnB,MAAOC,EACP,UAAW,CACT,gBAAiBF,GAAS,MAC1B,OAAQA,GAAS,OACjB,MAAOA,GAAS,MAChB,SAAUA,GAAS,OACrB,CACF,EAOA,OANa,MAAMG,EAAiC,CAClD,YAAAJ,EACA,MAAOE,EACP,aAAc,eAChB,CAAC,GAEW,eACd,CAYA,eAAsBG,EAA6BN,EAIR,CACzC,GAAM,CAAE,YAAAC,EAAa,cAAAM,EAAe,QAAAL,CAAQ,EAAIF,EAG1CQ,EAAsD,CAC1D,eAAgB,CAAE,IAHJC,EAAe,KAAKF,CAAa,EAAE,aAAa,CAG/B,CACjC,EACA,OAAQ,MAAMR,EAAc,CAAE,YAAAE,EAAa,QAAS,CAAE,GAAGC,EAAS,MAAOM,CAAe,CAAE,CAAC,GAAG,CAAC,CACjG","names":["getObjectData","args","aptosConfig","options","graphqlQuery","GetObjectData","queryIndexer","getObjectDataByObjectAddress","objectAddress","whereCondition","AccountAddress"]}

package/dist/esm/chunk-L6KVC7CJ.mjs

@@ -1,2 +0,0 @@
-import{a as h}from"./chunk-ZS2IVRHT.mjs";import{a as T}from"./chunk-GTVMJJQQ.mjs";import{a as f}from"./chunk-OLGEN23M.mjs";import{a as d}from"./chunk-B23VO5TB.mjs";import{d as c,e as u,f as g,i as m,j as p,k as y,l as A}from"./chunk-53IBOHXB.mjs";import{a,b as o,c as i,d as s,e,g as r}from"./chunk-GRRBXHVG.mjs";var P=class{constructor(n){this.config=n,this.build=new f(this.config),this.simulate=new h(this.config),this.submit=new T(this.config),this.batch=new d(this.config)}async getTransactions(n){return a({aptosConfig:this.config,...n})}async getTransactionByVersion(n){return i({aptosConfig:this.config,...n})}async getTransactionByHash(n){return s({aptosConfig:this.config,...n})}async isPendingTransaction(n){return e({aptosConfig:this.config,...n})}async waitForTransaction(n){return r({aptosConfig:this.config,...n})}async getGasPriceEstimation(){return o({aptosConfig:this.config})}getSigningMessage(n){return c(n)}async publishPackageTransaction(n){return y({aptosConfig:this.config,...n})}async rotateAuthKey(n){return A({aptosConfig:this.config,...n})}sign(n){return u({...n})}signAsFeePayer(n){return g({...n})}async batchTransactionsForSingleAccount(n){try{let{sender:t,data:l,options:b}=n;this.batch.forSingleAccount({sender:t,data:l,options:b})}catch(t){throw new Error(`failed to submit transactions with error: ${t}`)}}async signAndSubmitTransaction(n){return m({aptosConfig:this.config,...n})}async signAndSubmitAsFeePayer(n){return p({aptosConfig:this.config,...n})}};export{P as a};
-//# sourceMappingURL=chunk-L6KVC7CJ.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/transaction.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosConfig } from \"./aptosConfig\";\nimport {\n  getGasPriceEstimation,\n  getTransactionByHash,\n  getTransactionByVersion,\n  getTransactions,\n  isTransactionPending,\n  waitForTransaction,\n} from \"../internal/transaction\";\nimport {\n  AnyNumber,\n  CommittedTransactionResponse,\n  GasEstimation,\n  HexInput,\n  PaginationArgs,\n  PendingTransactionResponse,\n  TransactionResponse,\n  WaitForTransactionOptions,\n} from \"../types\";\nimport {\n  FeePayerOrFeePayerAuthenticatorOrNeither,\n  getSigningMessage,\n  publicPackageTransaction,\n  rotateAuthKey,\n  signAndSubmitAsFeePayer,\n  signAndSubmitTransaction,\n  signAsFeePayer,\n  signTransaction,\n} from \"../internal/transactionSubmission\";\nimport {\n  AccountAuthenticator,\n  AnyRawTransaction,\n  InputGenerateTransactionOptions,\n  InputGenerateTransactionPayloadData,\n} from \"../transactions\";\nimport { AccountAddressInput, PrivateKeyInput } from \"../core\";\nimport { Account } from \"../account\";\nimport { Build } from \"./transactionSubmission/build\";\nimport { Simulate } from \"./transactionSubmission/simulate\";\nimport { Submit } from \"./transactionSubmission/submit\";\nimport { TransactionManagement } from \"./transactionSubmission/management\";\nimport { SimpleTransaction } from \"../transactions/instances/simpleTransaction\";\n\n/**\n * Represents a transaction in the Aptos blockchain,\n * providing methods to build, simulate, submit, and manage transactions.\n * This class encapsulates functionalities for querying transaction details,\n * estimating gas prices, signing transactions, and handling transaction states.\n *\n * This class is used as part of the Aptos object, so should be called like so:\n * @example\n * ```typescript\n * import { Account, Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n *\n * const APTOS_COIN = \"0x1::aptos_coin::AptosCoin\";\n * const COIN_STORE = `0x1::coin::CoinStore<${APTOS_COIN}>`;\n * const ALICE_INITIAL_BALANCE = 100_000_000;\n * const TRANSFER_AMOUNT = 100;\n *\n * async function example() {\n *   console.log(\n *     \"This example will create two accounts (Alice and Bob), fund them, and transfer between them.\",\n *   );\n *\n *   // Set up the client\n *   const config = new AptosConfig({ network: Network.DEVNET });\n *   const aptos = new Aptos(config);\n *\n *   // Generate two account credentials\n *   // Each account has a private key, a public key, and an address\n *   const alice = Account.generate();\n *   const bob = Account.generate();\n *\n *   console.log(\"=== Addresses ===\\n\");\n *   console.log(`Alice's address is: ${alice.accountAddress}`);\n *   console.log(`Bob's address is: ${bob.accountAddress}`);\n *\n *   // Fund the accounts using a faucet\n *   console.log(\"\\n=== Funding accounts ===\\n\");\n *\n *   await aptos.fundAccount({\n *     accountAddress: alice.accountAddress,\n *     amount: ALICE_INITIAL_BALANCE,\n *   });\n *\n *   // Send a transaction from Alice's account to Bob's account\n *   const txn = await aptos.transaction.build.simple({\n *     sender: alice.accountAddress,\n *     data: {\n *       // All transactions on Aptos are implemented via smart contracts.\n *       function: \"0x1::aptos_account::transfer\",\n *       functionArguments: [bob.accountAddress, 100],\n *     },\n *   });\n *\n *   console.log(\"\\n=== Transfer transaction ===\\n\");\n *   // Both signs and submits\n *   const committedTxn = await aptos.signAndSubmitTransaction({\n *     signer: alice,\n *     transaction: txn,\n *  });\n *   // Waits for Aptos to verify and execute the transaction\n *   const executedTransaction = await aptos.waitForTransaction({\n *     transactionHash: committedTxn.hash,\n *   });\n *   console.log(\"Transaction hash:\", executedTransaction.hash);\n *\n *  console.log(\"\\n=== Balances after transfer ===\\n\");\n *  const newAliceAccountBalance = await aptos.getAccountResource({\n *    accountAddress: alice.accountAddress,\n *    resourceType: COIN_STORE,\n *  });\n *  const newAliceBalance = Number(newAliceAccountBalance.coin.value);\n *  console.log(`Alice's balance is: ${newAliceBalance}`);\n *\n *  const newBobAccountBalance = await aptos.getAccountResource({\n *    accountAddress: bob.accountAddress,\n *    resourceType: COIN_STORE,\n *  });\n *  const newBobBalance = Number(newBobAccountBalance.coin.value);\n *  console.log(`Bob's balance is: ${newBobBalance}`);\n * }\n *\n * example();\n * ```\n * @group Transaction\n */\nexport class Transaction {\n  readonly config: AptosConfig;\n\n  readonly build: Build;\n\n  readonly simulate: Simulate;\n\n  readonly submit: Submit;\n\n  readonly batch: TransactionManagement;\n\n  /**\n   * Creates an instance of the Aptos client with the specified configuration.\n   * This allows you to interact with the Aptos blockchain using the provided settings.\n   *\n   * @param config - The configuration settings for the Aptos client.\n   * @param config.network - The network to connect to (e.g., Testnet, Mainnet).\n   * @param config.nodeUrl - The URL of the Aptos node to connect to.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * async function runExample() {\n   *     // Create a new Aptos client instance\n   *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify the network\n   *     const aptos = new Aptos(config);\n   *\n   *     console.log(\"Aptos client created successfully:\", aptos);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  constructor(config: AptosConfig) {\n    this.config = config;\n    this.build = new Build(this.config);\n    this.simulate = new Simulate(this.config);\n    this.submit = new Submit(this.config);\n    this.batch = new TransactionManagement(this.config);\n  }\n\n  /**\n   * Queries on-chain transactions, excluding pending transactions.\n   * Use this function to retrieve historical transactions from the blockchain.\n   *\n   * @param args Optional parameters for pagination.\n   * @param args.options Optional pagination options.\n   * @param args.options.offset The number of the transaction to start with.\n   * @param args.options.limit The number of results to return.\n   *\n   * @returns An array of on-chain transactions.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Fetch transactions with pagination\n   *   const transactions = await aptos.getTransactions({\n   *     options: {\n   *       offset: 0, // Start from the first transaction\n   *       limit: 10, // Limit to 10 results\n   *     },\n   *   });\n   *\n   *   console.log(transactions);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async getTransactions(args?: { options?: PaginationArgs }): Promise<TransactionResponse[]> {\n    return getTransactions({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries on-chain transaction by version. This function will not return pending transactions.\n   *\n   * @param args - The arguments for querying the transaction.\n   * @param args.ledgerVersion - Transaction version is an unsigned 64-bit number.\n   * @returns On-chain transaction. Only on-chain transactions have versions, so this\n   * function cannot be used to query pending transactions.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Fetching a transaction by its version\n   *   const transaction = await aptos.getTransactionByVersion({ ledgerVersion: 1 }); // replace 1 with a real version\n   *   console.log(transaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async getTransactionByVersion(args: { ledgerVersion: AnyNumber }): Promise<TransactionResponse> {\n    return getTransactionByVersion({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries on-chain transactions by their transaction hash, returning both pending and committed transactions.\n   *\n   * @param args - The arguments for querying the transaction.\n   * @param args.transactionHash - The transaction hash should be a hex-encoded bytes string with a 0x prefix.\n   * @returns The transaction from the mempool (pending) or the on-chain (committed) transaction.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Fetch a transaction by its hash\n   *   const transaction = await aptos.getTransactionByHash({ transactionHash: \"0x123\" }); // replace with a real transaction hash\n   *\n   *   console.log(transaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async getTransactionByHash(args: { transactionHash: HexInput }): Promise<TransactionResponse> {\n    return getTransactionByHash({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Defines if the specified transaction is currently in a pending state.\n   * This function helps you determine the status of a transaction using its hash.\n   *\n   * @param args - The arguments for the function.\n   * @param args.transactionHash - A hash of the transaction in hexadecimal format.\n   * @returns `true` if the transaction is in a pending state and `false` otherwise.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Check if the transaction is pending using its hash\n   *   const isPendingTransaction = await aptos.isPendingTransaction({ transactionHash: \"0x123\" }); // replace with a real transaction hash\n   *   console.log(\"Is the transaction pending?\", isPendingTransaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async isPendingTransaction(args: { transactionHash: HexInput }): Promise<boolean> {\n    return isTransactionPending({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Waits for a transaction to move past the pending state and provides the transaction response.\n   * There are 4 cases.\n   * 1. Transaction is successfully processed and committed to the chain.\n   *    - The function will resolve with the transaction response from the API.\n   * 2. Transaction is rejected for some reason, and is therefore not committed to the blockchain.\n   *    - The function will throw an AptosApiError with an HTTP status code indicating some problem with the request.\n   * 3. Transaction is committed but execution failed, meaning no changes were\n   *    written to the blockchain state.\n   *    - If `checkSuccess` is true, the function will throw a FailedTransactionError\n   *      If `checkSuccess` is false, the function will resolve with the transaction response where the `success` field is false.\n   * 4. Transaction does not move past the pending state within `args.options.timeoutSecs` seconds.\n   *    - The function will throw a WaitForTransactionError\n   *\n   * @param args.transactionHash - The hash of a transaction previously submitted to the blockchain.\n   * @param args.options - Optional parameters for waiting behavior.\n   * @param args.options.timeoutSecs - Timeout in seconds. Defaults to 20 seconds.\n   * @param args.options.checkSuccess - A boolean which controls whether the function will error if the transaction failed.\n   * Defaults to true.\n   * @returns The transaction on-chain response.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Wait for a transaction to complete using its hash\n   *   const transactionHash = \"0x123\"; // replace with a real transaction hash\n   *   const transactionResponse = await aptos.waitForTransaction({\n   *     transactionHash,\n   *     options: {\n   *       timeoutSecs: 30, // specify your own timeout if needed\n   *       checkSuccess: true,\n   *     },\n   *   });\n   *\n   *   console.log(transactionResponse);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async waitForTransaction(args: {\n    transactionHash: HexInput;\n    options?: WaitForTransactionOptions;\n  }): Promise<CommittedTransactionResponse> {\n    return waitForTransaction({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Estimates the gas unit price required to process a transaction on the Aptos blockchain in a timely manner.\n   * This helps users to understand the cost associated with their transactions.\n   * {@link https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price}\n   *\n   * @returns An object containing the estimated gas price.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET }); // Specify your network\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Getting the gas price estimation\n   *   const gasPriceEstimation = await aptos.getGasPriceEstimation();\n   *\n   *   console.log(\"Estimated Gas Price:\", gasPriceEstimation);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async getGasPriceEstimation(): Promise<GasEstimation> {\n    return getGasPriceEstimation({\n      aptosConfig: this.config,\n    });\n  }\n\n  /**\n   * Returns a signing message for a transaction, allowing a user to sign it using their preferred method before submission to the network.\n   *\n   * @param args - The arguments for obtaining the signing message.\n   * @param args.transaction - A raw transaction for signing elsewhere.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *     const transaction = await aptos.transaction.build.simple({\n   *         sender: \"0x1\", // replace with a real sender address\n   *         data: {\n   *             function: \"0x1::aptos_account::transfer\",\n   *             functionArguments: [\"0x2\", 100], // replace with a real destination address\n   *         },\n   *     });\n   *\n   *     const message = await aptos.getSigningMessage({ transaction });\n   *     console.log(message);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  // eslint-disable-next-line class-methods-use-this\n  getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {\n    return getSigningMessage(args);\n  }\n\n  /**\n   * Generates a transaction to publish a Move package to the blockchain.\n   * This function helps you create a transaction that can be simulated or submitted to the chain for publishing a package.\n   *\n   * To get the `metadataBytes` and `byteCode`, can compile using Aptos CLI with command\n   * `aptos move compile --save-metadata ...`,\n   *\n   * {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}\n   *\n   * @param args The arguments for publishing the package.\n   * @param args.account The publisher account.\n   * @param args.metadataBytes The package metadata bytes.\n   * @param args.moduleBytecode An array of the bytecode of each module in the package in compiler output order.\n   * @param args.options Optional settings for generating the transaction.\n   *\n   * @returns A SimpleTransaction that can be simulated or submitted to the chain.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Replace with a real account address\n   *   const account = \"0x1\";\n   *   const metadataBytes = \"0x...\"; // replace with real metadata bytes\n   *   const byteCode = \"0x...\"; // replace with real module bytecode\n   *\n   *   const transaction = await aptos.publishPackageTransaction({\n   *     account,\n   *     metadataBytes,\n   *     moduleBytecode: [byteCode],\n   *   });\n   *\n   *   console.log(transaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async publishPackageTransaction(args: {\n    account: AccountAddressInput;\n    metadataBytes: HexInput;\n    moduleBytecode: Array<HexInput>;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SimpleTransaction> {\n    return publicPackageTransaction({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Rotate an account's authentication key. After rotation, only the new private key can be used to sign transactions for the account.\n   * Note: Only legacy Ed25519 scheme is supported for now.\n   * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}\n   *\n   * @param args The arguments for rotating the auth key.\n   * @param args.fromAccount The account to rotate the auth key for.\n   * @param args.toNewPrivateKey The new private key to rotate to.\n   *\n   * @returns PendingTransactionResponse\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network, Account, PrivateKey } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Rotate the authentication key for an account\n   *   const response = await aptos.rotateAuthKey({\n   *     // replace with a real account\n   *     fromAccount: Account.generate(),\n   *     // replace with a real private key\n   *     toNewPrivateKey: new PrivateKey(\"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\"),\n   *   });\n   *\n   *   console.log(response);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async rotateAuthKey(args: { fromAccount: Account; toNewPrivateKey: PrivateKeyInput }): Promise<TransactionResponse> {\n    return rotateAuthKey({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Sign a transaction that can later be submitted to the chain.\n   * This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.\n   *\n   * @param args - The arguments for signing the transaction.\n   * @param args.signer - The account that will sign the transaction.\n   * @param args.transaction - A raw transaction to sign.\n   *\n   * @returns AccountAuthenticator - The authenticator for the signed transaction.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   const sender = Account.generate(); // Generate a new account for signing\n   *   const transaction = await aptos.transaction.build.simple({\n   *     sender: sender.accountAddress,\n   *     data: {\n   *       function: \"0x1::aptos_account::transfer\",\n   *       functionArguments: [ \"0x1\", 100 ], // replace with a real account address and amount\n   *     },\n   *   });\n   *\n   *   const signedTransaction = await aptos.transaction.sign({\n   *     signer: sender,\n   *     transaction,\n   *   }); // Sign the transaction\n   *\n   *   console.log(\"Signed Transaction:\", signedTransaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  // eslint-disable-next-line class-methods-use-this\n  sign(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n    return signTransaction({\n      ...args,\n    });\n  }\n\n  /**\n   * Sign a transaction as a fee payer that can later be submitted to the chain.\n   * This function ensures that the transaction is marked with the fee payer's address, allowing it to be processed correctly.\n   *\n   * @param args - The arguments for signing the transaction.\n   * @param args.signer - The fee payer signer account.\n   * @param args.transaction - A raw transaction to sign on. This transaction must include a `feePayerAddress` property.\n   *\n   * @returns AccountAuthenticator - The authenticator for the signed transaction.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   const sender = Account.generate(); // Generate a new account for the fee payer\n   *   const transaction = await aptos.transaction.build.simple({\n   *     // All transactions on Aptos are implemented via smart contracts.\n   *     function: \"0x1::aptos_account::transfer\",\n   *     functionArguments: [sender.accountAddress, 100],\n   *     feePayerAddress: sender.accountAddress, // Set the fee payer address\n   *   });\n   *\n   *   const signedTransaction = await aptos.transaction.signAsFeePayer({\n   *     signer: sender,\n   *     transaction,\n   *   });\n   *\n   *   console.log(\"Signed transaction as fee payer:\", signedTransaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  // eslint-disable-next-line class-methods-use-this\n  signAsFeePayer(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n    return signAsFeePayer({\n      ...args,\n    });\n  }\n\n  // TRANSACTION SUBMISSION //\n\n  /**\n   * @deprecated Prefer to use `aptos.transaction.batch.forSingleAccount()`\n   *\n   * Batch transactions for a single account by submitting multiple transaction payloads.\n   * This function is useful for efficiently processing and submitting transactions that do not depend on each other, such as\n   * batch funding or batch token minting.\n   *\n   * @param args - The arguments for batching transactions.\n   * @param args.sender - The sender account to sign and submit the transactions.\n   * @param args.data - An array of transaction payloads to be processed.\n   * @param args.options - Optional. Transaction generation configurations (excluding accountSequenceNumber).\n   *\n   * @throws Error if any worker failure occurs during submission.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network, Account } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   * const sender = Account.generate(); // Generate a new account for sending transactions\n   *\n   * async function runExample() {\n   *   const transactions = [\n   *     { }, // Build your first transaction payload\n   *     { }, // Build your second transaction payload\n   *   ];\n   *\n   *   // Batch transactions for the single account\n   *   await aptos.batchTransactionsForSingleAccount({\n   *     sender,\n   *     data: transactions,\n   *   });\n   *\n   *   console.log(\"Batch transactions submitted successfully.\");\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Transaction\n   */\n  async batchTransactionsForSingleAccount(args: {\n    sender: Account;\n    data: InputGenerateTransactionPayloadData[];\n    options?: Omit<InputGenerateTransactionOptions, \"accountSequenceNumber\">;\n  }): Promise<void> {\n    try {\n      const { sender, data, options } = args;\n      this.batch.forSingleAccount({ sender, data, options });\n    } catch (error: any) {\n      throw new Error(`failed to submit transactions with error: ${error}`);\n    }\n  }\n\n  /**\n   * Sign and submit a single signer transaction to the blockchain.\n   * This function allows you to execute a transaction after signing it with the specified account.\n   *\n   * @param args The arguments for signing and submitting the transaction.\n   * @param args.signer The signer account to sign the transaction.\n   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   const sender = Account.generate(); // Generate a new account for sending the transaction\n   *   const transaction = await aptos.transaction.build.simple({\n   *     sender: sender.accountAddress,\n   *     data: {\n   *       function: \"0x1::aptos_account::transfer\",\n   *       functionArguments: [ \"0x1\", 100 ], // replace with a real account address\n   *     },\n   *   });\n   *\n   *   // Sign and submit the transaction\n   *   const pendingTransaction = await aptos.signAndSubmitTransaction({\n   *     signer: sender,\n   *     transaction,\n   *   });\n   *\n   *   console.log(pendingTransaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @return PendingTransactionResponse\n   * @group Transaction\n   */\n  async signAndSubmitTransaction(\n    args: FeePayerOrFeePayerAuthenticatorOrNeither & {\n      signer: Account;\n      transaction: AnyRawTransaction;\n    },\n  ): Promise<PendingTransactionResponse> {\n    return signAndSubmitTransaction({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Sign and submit a single signer transaction as the fee payer to chain given an authenticator by the sender of the transaction.\n   *\n   * @param args.feePayer The fee payer account to sign the transaction\n   * @param args.senderAuthenticator The AccountAuthenticator signed by the sender of the transaction\n   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses\n   *\n   * @example\n   * const transaction = await aptos.transaction.build.simple({sender: alice.accountAddress, feePayer: true ...})\n   * const senderAuthenticator = alice.signTransactionWithAuthenticator(transaction)\n   * const pendingTransaction = await aptos.signAndSubmitAsFeePayer({\n   *  senderAuthenticator,\n   *  feePayer: bob,\n   *  transaction,\n   * })\n   *\n   * @return PendingTransactionResponse\n   * @group Transaction\n   */\n  async signAndSubmitAsFeePayer(args: {\n    feePayer: Account;\n    senderAuthenticator: AccountAuthenticator;\n    transaction: AnyRawTransaction;\n  }): Promise<PendingTransactionResponse> {\n    return signAndSubmitAsFeePayer({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n}\n"],"mappings":"yTAkIO,IAAMA,EAAN,KAAkB,CAkCvB,YAAYC,EAAqB,CAC/B,KAAK,OAASA,EACd,KAAK,MAAQ,IAAIC,EAAM,KAAK,MAAM,EAClC,KAAK,SAAW,IAAIC,EAAS,KAAK,MAAM,EACxC,KAAK,OAAS,IAAIC,EAAO,KAAK,MAAM,EACpC,KAAK,MAAQ,IAAIC,EAAsB,KAAK,MAAM,CACpD,CAmCA,MAAM,gBAAgBC,EAAqE,CACzF,OAAOC,EAAgB,CACrB,YAAa,KAAK,OAClB,GAAGD,CACL,CAAC,CACH,CA0BA,MAAM,wBAAwBA,EAAkE,CAC9F,OAAOE,EAAwB,CAC7B,YAAa,KAAK,OAClB,GAAGF,CACL,CAAC,CACH,CA0BA,MAAM,qBAAqBA,EAAmE,CAC5F,OAAOG,EAAqB,CAC1B,YAAa,KAAK,OAClB,GAAGH,CACL,CAAC,CACH,CA0BA,MAAM,qBAAqBA,EAAuD,CAChF,OAAOI,EAAqB,CAC1B,YAAa,KAAK,OAClB,GAAGJ,CACL,CAAC,CACH,CA+CA,MAAM,mBAAmBA,EAGiB,CACxC,OAAOK,EAAmB,CACxB,YAAa,KAAK,OAClB,GAAGL,CACL,CAAC,CACH,CA0BA,MAAM,uBAAgD,CACpD,OAAOM,EAAsB,CAC3B,YAAa,KAAK,MACpB,CAAC,CACH,CAgCA,kBAAkBN,EAAsD,CACtE,OAAOO,EAAkBP,CAAI,CAC/B,CA4CA,MAAM,0BAA0BA,EAKD,CAC7B,OAAOQ,EAAyB,CAAE,YAAa,KAAK,OAAQ,GAAGR,CAAK,CAAC,CACvE,CAmCA,MAAM,cAAcA,EAAgG,CAClH,OAAOS,EAAc,CAAE,YAAa,KAAK,OAAQ,GAAGT,CAAK,CAAC,CAC5D,CAyCA,KAAKA,EAAiF,CACpF,OAAOU,EAAgB,CACrB,GAAGV,CACL,CAAC,CACH,CAwCA,eAAeA,EAAiF,CAC9F,OAAOW,EAAe,CACpB,GAAGX,CACL,CAAC,CACH,CA4CA,MAAM,kCAAkCA,EAItB,CAChB,GAAI,CACF,GAAM,CAAE,OAAAY,EAAQ,KAAAC,EAAM,QAAAC,CAAQ,EAAId,EAClC,KAAK,MAAM,iBAAiB,CAAE,OAAAY,EAAQ,KAAAC,EAAM,QAAAC,CAAQ,CAAC,CACvD,OAASC,EAAY,CACnB,MAAM,IAAI,MAAM,6CAA6CA,CAAK,EAAE,CACtE,CACF,CAwCA,MAAM,yBACJf,EAIqC,CACrC,OAAOgB,EAAyB,CAC9B,YAAa,KAAK,OAClB,GAAGhB,CACL,CAAC,CACH,CAqBA,MAAM,wBAAwBA,EAIU,CACtC,OAAOiB,EAAwB,CAC7B,YAAa,KAAK,OAClB,GAAGjB,CACL,CAAC,CACH,CACF","names":["Transaction","config","Build","Simulate","Submit","TransactionManagement","args","getTransactions","getTransactionByVersion","getTransactionByHash","isTransactionPending","waitForTransaction","getGasPriceEstimation","getSigningMessage","publicPackageTransaction","rotateAuthKey","signTransaction","signAsFeePayer","sender","data","options","error","signAndSubmitTransaction","signAndSubmitAsFeePayer"]}

package/dist/esm/chunk-MAWGZICD.mjs

@@ -1,2 +0,0 @@
-import{d as s}from"./chunk-P5CM4C2G.mjs";import{b as i}from"./chunk-BPHCRTHD.mjs";import{c as n}from"./chunk-7OUPEQRN.mjs";import{b as o}from"./chunk-LQOSHBB7.mjs";var c=class a{constructor(t){this.signingScheme=0;let{privateKey:e,address:r}=t;this.privateKey=e,this.publicKey=e.publicKey(),this.accountAddress=r?o.from(r):this.publicKey.authKey().derivedAddress()}static generate(){let t=n.generate();return new a({privateKey:t})}static fromDerivationPath(t){let{path:e,mnemonic:r}=t,u=n.fromDerivationPath(e,r);return new a({privateKey:u})}verifySignature(t){return this.publicKey.verifySignature(t)}signWithAuthenticator(t){return new i(this.publicKey,this.privateKey.sign(t))}signTransactionWithAuthenticator(t){return new i(this.publicKey,this.signTransaction(t))}sign(t){return this.privateKey.sign(t)}signTransaction(t){return this.sign(s(t))}};export{c as a};
-//# sourceMappingURL=chunk-MAWGZICD.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/Ed25519Account.ts"],"sourcesContent":["import { AccountAuthenticatorEd25519 } from \"../transactions/authenticator/account\";\nimport { HexInput, SigningScheme } from \"../types\";\nimport { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature } from \"../core/crypto\";\nimport type { Account } from \"./Account\";\nimport { AnyRawTransaction } from \"../transactions/types\";\nimport { generateSigningMessageForTransaction } from \"../transactions/transactionBuilder/signingMessage\";\n\n/**\n * Arguments required to create an instance of an Ed25519 signer.\n *\n * @param privateKey - The private key used for signing.\n * @param address - Optional account address associated with the signer.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface Ed25519SignerConstructorArgs {\n  privateKey: Ed25519PrivateKey;\n  address?: AccountAddressInput;\n}\n\n/**\n * Arguments for creating an Ed25519 signer from a derivation path.\n *\n * @param path - The derivation path for the Ed25519 key.\n * @param mnemonic - The mnemonic phrase used to generate the key.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface Ed25519SignerFromDerivationPathArgs {\n  path: string;\n  mnemonic: string;\n}\n\n/**\n * Arguments required to verify an Ed25519 signature against a given message.\n *\n * @param message - The message to be verified, represented in hexadecimal format.\n * @param signature - The Ed25519 signature to validate.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface VerifyEd25519SignatureArgs {\n  message: HexInput;\n  signature: Ed25519Signature;\n}\n\n/**\n * Represents an Ed25519 account that provides signing capabilities through an Ed25519 private key.\n * This class allows for the creation of accounts, signing messages and transactions, and verifying signatures.\n *\n * Note: Generating an instance of this class does not create the account on-chain.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class Ed25519Account implements Account {\n  /**\n   * Private key associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly privateKey: Ed25519PrivateKey;\n\n  readonly publicKey: Ed25519PublicKey;\n\n  readonly accountAddress: AccountAddress;\n\n  readonly signingScheme = SigningScheme.Ed25519;\n\n  // region Constructors\n\n  /**\n   * Creates an instance of the Ed25519Signer with the specified parameters.\n   * This constructor initializes the private key, public key, and account address for the signer.\n   *\n   * @param args - The constructor arguments for the Ed25519Signer.\n   * @param args.privateKey - The private key used for signing.\n   * @param args.address - The optional account address; if not provided, it will derive the address from the public key.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  constructor(args: Ed25519SignerConstructorArgs) {\n    const { privateKey, address } = args;\n    this.privateKey = privateKey;\n    this.publicKey = privateKey.publicKey();\n    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();\n  }\n\n  /**\n   * Generates a new Ed25519 account using a randomly generated private key.\n   * This function is useful for creating a signer that can be used for cryptographic operations.\n   *\n   * @returns {Ed25519Account} The newly generated Ed25519 account.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static generate(): Ed25519Account {\n    const privateKey = Ed25519PrivateKey.generate();\n    return new Ed25519Account({ privateKey });\n  }\n\n  /**\n   * Derives an Ed25519 account using a specified BIP44 path and mnemonic seed phrase.\n   *\n   * @param args - The arguments for deriving the account.\n   * @param args.path - The BIP44 derive hardened path, e.g., m/44'/637'/0'/0'/0'.\n   * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}\n   * @param args.mnemonic - The mnemonic seed phrase of the account.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static fromDerivationPath(args: Ed25519SignerFromDerivationPathArgs) {\n    const { path, mnemonic } = args;\n    const privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);\n    return new Ed25519Account({ privateKey });\n  }\n  // endregion\n\n  // region Account\n  /**\n   * Verify the given message and signature with the public key.\n   *\n   * @param args - The arguments for verifying the signature.\n   * @param args.message - Raw message data in HexInput format.\n   * @param args.signature - Signed message signature.\n   * @returns A boolean indicating whether the signature is valid.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  verifySignature(args: VerifyEd25519SignatureArgs): boolean {\n    return this.publicKey.verifySignature(args);\n  }\n\n  /**\n   * Sign a message using the account's Ed25519 private key.\n   * This function returns an AccountAuthenticator containing the signature along with the account's public key.\n   *\n   * @param message - The signing message, represented as hexadecimal input.\n   * @returns An AccountAuthenticator containing the signature and the account's public key.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signWithAuthenticator(message: HexInput): AccountAuthenticatorEd25519 {\n    return new AccountAuthenticatorEd25519(this.publicKey, this.privateKey.sign(message));\n  }\n\n  /**\n   * Sign a transaction using the account's Ed25519 private key.\n   * This function returns an AccountAuthenticator that contains the signature of the transaction along with the account's public key.\n   *\n   * @param transaction - The raw transaction to be signed.\n   * @returns An AccountAuthenticator containing the signature and the public key.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorEd25519 {\n    return new AccountAuthenticatorEd25519(this.publicKey, this.signTransaction(transaction));\n  }\n\n  /**\n   * Sign the given message using the account's Ed25519 private key.\n   * @param message - The message to be signed in HexInput format.\n   * @returns Signature - The resulting signature of the signed message.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  sign(message: HexInput): Ed25519Signature {\n    return this.privateKey.sign(message);\n  }\n\n  /**\n   * Sign the given transaction using the available signing capabilities.\n   * This function helps ensure that the transaction is properly authenticated before submission.\n   *\n   * @param transaction - The transaction to be signed.\n   * @returns Signature - The resulting signature for the transaction.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signTransaction(transaction: AnyRawTransaction): Ed25519Signature {\n    return this.sign(generateSigningMessageForTransaction(transaction));\n  }\n\n  // endregion\n}\n"],"mappings":"oKAuDO,IAAMA,EAAN,MAAMC,CAAkC,CA0B7C,YAAYC,EAAoC,CAdhD,KAAS,cAAgB,EAevB,GAAM,CAAE,WAAAC,EAAY,QAAAC,CAAQ,EAAIF,EAChC,KAAK,WAAaC,EAClB,KAAK,UAAYA,EAAW,UAAU,EACtC,KAAK,eAAiBC,EAAUC,EAAe,KAAKD,CAAO,EAAI,KAAK,UAAU,QAAQ,EAAE,eAAe,CACzG,CAUA,OAAO,UAA2B,CAChC,IAAMD,EAAaG,EAAkB,SAAS,EAC9C,OAAO,IAAIL,EAAe,CAAE,WAAAE,CAAW,CAAC,CAC1C,CAYA,OAAO,mBAAmBD,EAA2C,CACnE,GAAM,CAAE,KAAAK,EAAM,SAAAC,CAAS,EAAIN,EACrBC,EAAaG,EAAkB,mBAAmBC,EAAMC,CAAQ,EACtE,OAAO,IAAIP,EAAe,CAAE,WAAAE,CAAW,CAAC,CAC1C,CAcA,gBAAgBD,EAA2C,CACzD,OAAO,KAAK,UAAU,gBAAgBA,CAAI,CAC5C,CAWA,sBAAsBO,EAAgD,CACpE,OAAO,IAAIC,EAA4B,KAAK,UAAW,KAAK,WAAW,KAAKD,CAAO,CAAC,CACtF,CAWA,iCAAiCE,EAA6D,CAC5F,OAAO,IAAID,EAA4B,KAAK,UAAW,KAAK,gBAAgBC,CAAW,CAAC,CAC1F,CASA,KAAKF,EAAqC,CACxC,OAAO,KAAK,WAAW,KAAKA,CAAO,CACrC,CAWA,gBAAgBE,EAAkD,CAChE,OAAO,KAAK,KAAKC,EAAqCD,CAAW,CAAC,CACpE,CAGF","names":["Ed25519Account","_Ed25519Account","args","privateKey","address","AccountAddress","Ed25519PrivateKey","path","mnemonic","message","AccountAuthenticatorEd25519","transaction","generateSigningMessageForTransaction"]}

package/dist/esm/chunk-OLGEN23M.mjs

@@ -1,2 +0,0 @@
-import{a as t}from"./chunk-53IBOHXB.mjs";import{a as p}from"./chunk-FJ5J7CVW.mjs";import{e as s}from"./chunk-PIPDQFL2.mjs";import{a as i}from"./chunk-T7X4GZDU.mjs";import{c as a}from"./chunk-44EHAKKW.mjs";import{a as e}from"./chunk-ZD2TY5N3.mjs";import{b as r}from"./chunk-LQOSHBB7.mjs";var c=class{constructor(n){this.config=n}async simple(n){return t({aptosConfig:this.config,...n})}async scriptComposer(n){let o=new p(this.config);await o.init();let d=(await n.builder(o)).build(),u=await s({aptosConfig:this.config,payload:a.load(new e(d)),...n});return new i(u,n.withFeePayer===!0?r.ZERO:void 0)}async multiAgent(n){return t({aptosConfig:this.config,...n})}};export{c as a};
-//# sourceMappingURL=chunk-OLGEN23M.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/transactionSubmission/build.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccountAddress, AccountAddressInput } from \"../../core\";\nimport { generateTransaction } from \"../../internal/transactionSubmission\";\nimport {\n  InputGenerateTransactionPayloadData,\n  InputGenerateTransactionOptions,\n  AptosScriptComposer,\n  TransactionPayloadScript,\n  generateRawTransaction,\n} from \"../../transactions\";\nimport { MultiAgentTransaction } from \"../../transactions/instances/multiAgentTransaction\";\nimport { SimpleTransaction } from \"../../transactions/instances/simpleTransaction\";\nimport { AptosConfig } from \"../aptosConfig\";\nimport { Deserializer } from \"../../bcs\";\n\n/**\n * A class to handle all `Build` transaction operations.\n * @group Implementation\n */\nexport class Build {\n  readonly config: AptosConfig;\n\n  /**\n   * Initializes a new instance of the Aptos client with the specified configuration.\n   * This allows you to interact with the Aptos blockchain using the provided settings.\n   *\n   * @param config - The configuration settings for the Aptos client.\n   * @param config.network - The network to connect to (e.g., TESTNET, MAINNET).\n   * @param config.nodeUrl - The URL of the Aptos node to connect to.\n   * @param config.account - The account details for authentication.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * async function runExample() {\n   *     // Create a configuration for the Aptos client\n   *     const config = new AptosConfig({\n   *         network: Network.TESTNET, // specify the network\n   *         nodeUrl: \"https://testnet.aptos.dev\", // specify the node URL\n   *     });\n   *\n   *     // Initialize the Aptos client\n   *     const aptos = new Aptos(config);\n   *\n   *     console.log(\"Aptos client initialized:\", aptos);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Implementation\n   */\n  constructor(config: AptosConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Build a simple transaction.\n   *\n   * This function allows you to create a transaction with specified sender and data.\n   *\n   * @param args.sender - The sender account address.\n   * @param args.data - The transaction data.\n   * @param args.options - Optional transaction configurations.\n   * @param args.withFeePayer - Whether there is a fee payer for the transaction.\n   *\n   * @returns SimpleTransaction\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Build a simple transaction\n   *   const transaction = await aptos.transaction.simple({\n   *     sender: \"0x1\", // replace with a real sender account address\n   *     data: {\n   *       function: \"0x1::aptos_account::transfer\",\n   *       functionArguments: [\"0x2\", 100], // replace with a real destination account address\n   *     },\n   *     options: {\n   *       gasUnitPrice: 100, // specify your own gas unit price if needed\n   *       maxGasAmount: 1000, // specify your own max gas amount if needed\n   *     },\n   *   });\n   *\n   *   console.log(transaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Implementation\n   */\n  async simple(args: {\n    sender: AccountAddressInput;\n    data: InputGenerateTransactionPayloadData;\n    options?: InputGenerateTransactionOptions;\n    withFeePayer?: boolean;\n  }): Promise<SimpleTransaction> {\n    return generateTransaction({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Build a transaction from a series of Move calls.\n   *\n   * This function allows you to create a transaction with a list of Move calls.\n   *\n   * Right now we only tested this logic with single signer and we will add support\n   * for mutli agent transactions if needed.\n   *\n   * @param args.sender - The sender account address.\n   * @param args.builder - The closure to construct the list of calls.\n   * @param args.options - Optional transaction configurations.\n   * @param args.withFeePayer - Whether there is a fee payer for the transaction.\n   *\n   * @returns SimpleTransaction\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Build a transaction from a chained series of Move calls.\n   *   const transaction = await aptos.transaction.build.scriptComposer({\n   *     sender: \"0x1\", // replace with a real sender account address\n   *     builder: builder: async (builder) => {\n   *       const coin = await builder.addBatchedCalls({\n   *          function: \"0x1::coin::withdraw\",\n   *          functionArguments: [CallArgument.new_signer(0), 1],\n   *          typeArguments: [\"0x1::aptos_coin::AptosCoin\"],\n   *        });\n   *\n   *        // Pass the returned value from the first function call to the second call\n   *        const fungibleAsset = await builder.addBatchedCalls({\n   *          function: \"0x1::coin::coin_to_fungible_asset\",\n   *          functionArguments: [coin[0]],\n   *          typeArguments: [\"0x1::aptos_coin::AptosCoin\"],\n   *        });\n   *\n   *        await builder.addBatchedCalls({\n   *          function: \"0x1::primary_fungible_store::deposit\",\n   *          functionArguments: [singleSignerED25519SenderAccount.accountAddress, fungibleAsset[0]],\n   *          typeArguments: [],\n   *        });\n   *        return builder;\n   *     },\n   *     options: {\n   *       gasUnitPrice: 100, // specify your own gas unit price if needed\n   *       maxGasAmount: 1000, // specify your own max gas amount if needed\n   *     },\n   *   });\n   *\n   *   console.log(transaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   */\n  async scriptComposer(args: {\n    sender: AccountAddressInput;\n    builder: (builder: AptosScriptComposer) => Promise<AptosScriptComposer>;\n    options?: InputGenerateTransactionOptions;\n    withFeePayer?: boolean;\n  }): Promise<SimpleTransaction> {\n    const composer = new AptosScriptComposer(this.config);\n    await composer.init();\n    const builder = await args.builder(composer);\n    const bytes = builder.build();\n    const rawTxn = await generateRawTransaction({\n      aptosConfig: this.config,\n      payload: TransactionPayloadScript.load(new Deserializer(bytes)),\n      ...args,\n    });\n    return new SimpleTransaction(rawTxn, args.withFeePayer === true ? AccountAddress.ZERO : undefined);\n  }\n\n  /**\n   * Build a multi-agent transaction that allows multiple signers to authorize a transaction.\n   *\n   * @param args - The parameters for creating the multi-agent transaction.\n   * @param args.sender - The sender account address.\n   * @param args.data - The transaction data.\n   * @param args.secondarySignerAddresses - An array of the secondary signers' account addresses.\n   * @param args.options - Optional transaction configurations.\n   * @param args.withFeePayer - Whether there is a fee payer for the transaction.\n   *\n   * @returns MultiAgentTransaction\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Build a multi-agent transaction\n   *   const transaction = await aptos.multiAgent({\n   *     sender: \"0x1\", // replace with a real sender account address\n   *     data: {\n   *       // Transaction data structure\n   *       function: \"0x1::aptos_account::transfer\",\n   *       functionArguments: [\"0x2\", 100], // replace with a real destination account address and amount\n   *     },\n   *     secondarySignerAddresses: [\"0x3\", \"0x4\"], // replace with real secondary signer addresses\n   *     options: {\n   *       // Optional transaction configurations\n   *       maxGasAmount: \"1000\",\n   *       gasUnitPrice: \"1\",\n   *     },\n   *   });\n   *\n   *   console.log(transaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Implementation\n   */\n  async multiAgent(args: {\n    sender: AccountAddressInput;\n    data: InputGenerateTransactionPayloadData;\n    secondarySignerAddresses: AccountAddressInput[];\n    options?: InputGenerateTransactionOptions;\n    withFeePayer?: boolean;\n  }): Promise<MultiAgentTransaction> {\n    return generateTransaction({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"+RAqBO,IAAMA,EAAN,KAAY,CAgCjB,YAAYC,EAAqB,CAC/B,KAAK,OAASA,CAChB,CAyCA,MAAM,OAAOC,EAKkB,CAC7B,OAAOC,EAAoB,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CAClE,CA4DA,MAAM,eAAeA,EAKU,CAC7B,IAAME,EAAW,IAAIC,EAAoB,KAAK,MAAM,EACpD,MAAMD,EAAS,KAAK,EAEpB,IAAME,GADU,MAAMJ,EAAK,QAAQE,CAAQ,GACrB,MAAM,EACtBG,EAAS,MAAMC,EAAuB,CAC1C,YAAa,KAAK,OAClB,QAASC,EAAyB,KAAK,IAAIC,EAAaJ,CAAK,CAAC,EAC9D,GAAGJ,CACL,CAAC,EACD,OAAO,IAAIS,EAAkBJ,EAAQL,EAAK,eAAiB,GAAOU,EAAe,KAAO,MAAS,CACnG,CA4CA,MAAM,WAAWV,EAMkB,CACjC,OAAOC,EAAoB,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CAClE,CACF","names":["Build","config","args","generateTransaction","composer","AptosScriptComposer","bytes","rawTxn","generateRawTransaction","TransactionPayloadScript","Deserializer","SimpleTransaction","AccountAddress"]}

package/dist/esm/chunk-ONGH5DXZ.mjs

@@ -1,2 +0,0 @@
-import{a as n}from"./chunk-27ESCVVC.mjs";import{b as i}from"./chunk-LQOSHBB7.mjs";import{a as d}from"./chunk-RXHER6EA.mjs";var o=class t extends d{constructor(e,s,r){super(),this.rawTransaction=e,this.feePayerAddress=r,this.secondarySignerAddresses=s}serialize(e){this.rawTransaction.serialize(e),e.serializeVector(this.secondarySignerAddresses),this.feePayerAddress===void 0?e.serializeBool(!1):(e.serializeBool(!0),this.feePayerAddress.serialize(e))}static deserialize(e){let s=n.deserialize(e),r=e.deserializeVector(i),c=e.deserializeBool(),a;return c&&(a=i.deserialize(e)),new t(s,r,a)}};export{o as a};
-//# sourceMappingURL=chunk-ONGH5DXZ.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/instances/multiAgentTransaction.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { AccountAddress } from \"../../core\";\nimport { RawTransaction } from \"./rawTransaction\";\n\n/**\n * Represents a multi-agent transaction that can be serialized and deserialized.\n * This transaction includes a raw transaction, optional fee payer address, and multiple secondary signer addresses.\n *\n * @param rawTransaction The raw transaction to be executed.\n * @param secondarySignerAddresses An array of secondary signer addresses involved in the transaction.\n * @param feePayerAddress An optional account address that sponsors the transaction's gas fees.\n * @group Implementation\n * @category Transactions\n */\nexport class MultiAgentTransaction extends Serializable {\n  public rawTransaction: RawTransaction;\n\n  public feePayerAddress?: AccountAddress | undefined;\n\n  public secondarySignerAddresses: AccountAddress[];\n\n  /**\n   * Represents a MultiAgentTransaction that can be submitted to the Aptos chain for execution.\n   * This class encapsulates the raw transaction data, the secondary signer addresses, and an optional fee payer address.\n   *\n   * @param rawTransaction The raw transaction data.\n   * @param secondarySignerAddresses An array of secondary signer addresses.\n   * @param feePayerAddress An optional account address that sponsors the gas fees.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(\n    rawTransaction: RawTransaction,\n    secondarySignerAddresses: AccountAddress[],\n    feePayerAddress?: AccountAddress,\n  ) {\n    super();\n    this.rawTransaction = rawTransaction;\n    this.feePayerAddress = feePayerAddress;\n    this.secondarySignerAddresses = secondarySignerAddresses;\n  }\n\n  /**\n   * Serializes the transaction data, including the raw transaction, secondary signer addresses, and fee payer address.\n   * This function is essential for preparing the transaction for transmission or storage in a serialized format.\n   *\n   * @param serializer - The serializer instance used to serialize the transaction data.\n   * @group Implementation\n   * @category Transactions\n   */\n  serialize(serializer: Serializer): void {\n    this.rawTransaction.serialize(serializer);\n\n    serializer.serializeVector<AccountAddress>(this.secondarySignerAddresses);\n\n    if (this.feePayerAddress === undefined) {\n      serializer.serializeBool(false);\n    } else {\n      serializer.serializeBool(true);\n      this.feePayerAddress.serialize(serializer);\n    }\n  }\n\n  /**\n   * Deserializes a MultiAgentTransaction from the provided deserializer.\n   * This function allows you to reconstruct a MultiAgentTransaction object from its serialized form, including any secondary\n   * signer addresses and the fee payer address if present.\n   *\n   * @param deserializer - The deserializer instance used to read the serialized data.\n   * @group Implementation\n   * @category Transactions\n   */\n  static deserialize(deserializer: Deserializer): MultiAgentTransaction {\n    const rawTransaction = RawTransaction.deserialize(deserializer);\n\n    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);\n\n    const feePayerPresent = deserializer.deserializeBool();\n    let feePayerAddress;\n    if (feePayerPresent) {\n      feePayerAddress = AccountAddress.deserialize(deserializer);\n    }\n\n    return new MultiAgentTransaction(rawTransaction, secondarySignerAddresses, feePayerAddress);\n  }\n}\n"],"mappings":"2HAoBO,IAAMA,EAAN,MAAMC,UAA8BC,CAAa,CAiBtD,YACEC,EACAC,EACAC,EACA,CACA,MAAM,EACN,KAAK,eAAiBF,EACtB,KAAK,gBAAkBE,EACvB,KAAK,yBAA2BD,CAClC,CAUA,UAAUE,EAA8B,CACtC,KAAK,eAAe,UAAUA,CAAU,EAExCA,EAAW,gBAAgC,KAAK,wBAAwB,EAEpE,KAAK,kBAAoB,OAC3BA,EAAW,cAAc,EAAK,GAE9BA,EAAW,cAAc,EAAI,EAC7B,KAAK,gBAAgB,UAAUA,CAAU,EAE7C,CAWA,OAAO,YAAYC,EAAmD,CACpE,IAAMJ,EAAiBK,EAAe,YAAYD,CAAY,EAExDH,EAA2BG,EAAa,kBAAkBE,CAAc,EAExEC,EAAkBH,EAAa,gBAAgB,EACjDF,EACJ,OAAIK,IACFL,EAAkBI,EAAe,YAAYF,CAAY,GAGpD,IAAIN,EAAsBE,EAAgBC,EAA0BC,CAAe,CAC5F,CACF","names":["MultiAgentTransaction","_MultiAgentTransaction","Serializable","rawTransaction","secondarySignerAddresses","feePayerAddress","serializer","deserializer","RawTransaction","AccountAddress","feePayerPresent"]}

package/dist/esm/chunk-OPD5EKOA.mjs

@@ -1,2 +0,0 @@
-import{a as o,b as A}from"./chunk-CGTMSLVZ.mjs";import{a as u}from"./chunk-2YKERRHD.mjs";import{d as e}from"./chunk-P5CM4C2G.mjs";import{g as a}from"./chunk-BPHCRTHD.mjs";import{k as c}from"./chunk-BHVSIRNF.mjs";import{b as s}from"./chunk-RXHER6EA.mjs";import{sha3_256 as d}from"@noble/hashes/sha3";var g=class p extends u{constructor({signer:t,accountAddress:n,authenticationFunction:i}){super();this.signingScheme=2;if(!c(i))throw new Error(`Invalid authentication function ${i} passed into AbstractedAccount`);this.authenticationFunction=i,this.accountAddress=n,this.publicKey=new A(this.accountAddress),this.sign=r=>new o(t(r))}static fromPermissionedSigner({signer:t,accountAddress:n}){return new p({signer:i=>{let r=new s;return t.publicKey.serialize(r),t.sign(i).serialize(r),r.toUint8Array()},accountAddress:n??t.accountAddress,authenticationFunction:"0x1::permissioned_delegation::authenticate"})}signWithAuthenticator(t){return new a(this.authenticationFunction,d(t),this.sign(d(t)).toUint8Array())}signTransactionWithAuthenticator(t){return this.signWithAuthenticator(e(t))}signTransaction(t){return this.sign(e(t))}setSigner(t){this.sign=n=>new o(t(n))}};export{g as a};
-//# sourceMappingURL=chunk-OPD5EKOA.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/AbstractedAccount.ts"],"sourcesContent":["import { sha3_256 } from \"@noble/hashes/sha3\";\nimport { AccountAddress } from \"../core\";\nimport { AbstractPublicKey, AbstractSignature } from \"../core/crypto/abstraction\";\nimport { SigningScheme, HexInput } from \"../types\";\nimport { Account } from \"./Account\";\nimport { AnyRawTransaction } from \"../transactions/types\";\nimport { generateSigningMessageForTransaction } from \"../transactions/transactionBuilder/signingMessage\";\nimport { AccountAuthenticatorAbstraction } from \"../transactions/authenticator/account\";\nimport { Ed25519Account } from \"./Ed25519Account\";\nimport { Serializer } from \"../bcs/serializer\";\nimport { isValidFunctionInfo } from \"../utils/helpers\";\n\ntype AbstractedAccountConstructorArgs = {\n  /**\n   * The account address of the account.\n   */\n  accountAddress: AccountAddress;\n  /**\n   * The signer function signs transactions and returns the `authenticator` bytes in the `AbstractionAuthData`.\n   *\n   * @param digest - The SHA256 hash of the transaction signing message\n   * @returns The `authenticator` bytes that can be used to verify the signature.\n   */\n  signer: (digest: HexInput) => HexInput;\n  /**\n   * The authentication function that will be used to verify the signature.\n   *\n   * @example\n   * ```ts\n   * const authenticationFunction = `${accountAddress}::permissioned_delegation::authenticate`;\n   * ```\n   */\n  authenticationFunction: string;\n};\n\nexport class AbstractedAccount extends Account {\n  public readonly publicKey: AbstractPublicKey;\n\n  readonly accountAddress: AccountAddress;\n\n  readonly authenticationFunction: string;\n\n  readonly signingScheme = SigningScheme.SingleKey;\n\n  constructor({ signer, accountAddress, authenticationFunction }: AbstractedAccountConstructorArgs) {\n    super();\n\n    if (!isValidFunctionInfo(authenticationFunction)) {\n      throw new Error(`Invalid authentication function ${authenticationFunction} passed into AbstractedAccount`);\n    }\n\n    this.authenticationFunction = authenticationFunction;\n    this.accountAddress = accountAddress;\n    this.publicKey = new AbstractPublicKey(this.accountAddress);\n    this.sign = (digest: HexInput) => new AbstractSignature(signer(digest));\n  }\n\n  /**\n   * Creates an `AbstractedAccount` from an `Ed25519Account` that has a permissioned signer function and\n   * using the `0x1::permissioned_delegation::authenticate` function to verify the signature.\n   *\n   * @param signer - The `Ed25519Account` that can be used to sign permissioned transactions.\n   * @returns The `AbstractedAccount`\n   */\n  public static fromPermissionedSigner({\n    signer,\n    accountAddress,\n  }: {\n    signer: Ed25519Account;\n    accountAddress?: AccountAddress;\n  }) {\n    return new AbstractedAccount({\n      signer: (digest: HexInput) => {\n        const serializer = new Serializer();\n        signer.publicKey.serialize(serializer);\n        signer.sign(digest).serialize(serializer);\n        return serializer.toUint8Array();\n      },\n      accountAddress: accountAddress ?? signer.accountAddress,\n      authenticationFunction: \"0x1::permissioned_delegation::authenticate\",\n    });\n  }\n\n  signWithAuthenticator(message: HexInput): AccountAuthenticatorAbstraction {\n    return new AccountAuthenticatorAbstraction(\n      this.authenticationFunction,\n      sha3_256(message),\n      this.sign(sha3_256(message)).toUint8Array(),\n    );\n  }\n\n  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorAbstraction {\n    return this.signWithAuthenticator(generateSigningMessageForTransaction(transaction));\n  }\n\n  sign: (message: HexInput) => AbstractSignature;\n\n  signTransaction(transaction: AnyRawTransaction): AbstractSignature {\n    return this.sign(generateSigningMessageForTransaction(transaction));\n  }\n\n  /**\n   * Update the signer function for the account. This can be done after asynchronous operations are complete\n   * to update the context of the signer function.\n   *\n   * @param signer - The new signer function to use for the account.\n   */\n  public setSigner(signer: (digest: HexInput) => HexInput): void {\n    this.sign = (digest: HexInput) => new AbstractSignature(signer(digest));\n  }\n}\n"],"mappings":"6PAAA,OAAS,YAAAA,MAAgB,qBAmClB,IAAMC,EAAN,MAAMC,UAA0BC,CAAQ,CAS7C,YAAY,CAAE,OAAAC,EAAQ,eAAAC,EAAgB,uBAAAC,CAAuB,EAAqC,CAChG,MAAM,EAHR,KAAS,cAAgB,EAKnB,IAACC,EAAoBD,CAAsB,EAC7C,MAAM,IAAI,MAAM,mCAAmCA,CAAsB,gCAAgC,EAG3G,KAAK,uBAAyBA,EAC9B,KAAK,eAAiBD,EACtB,KAAK,UAAY,IAAIG,EAAkB,KAAK,cAAc,EAC1D,KAAK,KAAQC,GAAqB,IAAIC,EAAkBN,EAAOK,CAAM,CAAC,CACxE,CASA,OAAc,uBAAuB,CACnC,OAAAL,EACA,eAAAC,CACF,EAGG,CACD,OAAO,IAAIH,EAAkB,CAC3B,OAASO,GAAqB,CAC5B,IAAME,EAAa,IAAIC,EACvB,OAAAR,EAAO,UAAU,UAAUO,CAAU,EACrCP,EAAO,KAAKK,CAAM,EAAE,UAAUE,CAAU,EACjCA,EAAW,aAAa,CACjC,EACA,eAAgBN,GAAkBD,EAAO,eACzC,uBAAwB,4CAC1B,CAAC,CACH,CAEA,sBAAsBS,EAAoD,CACxE,OAAO,IAAIC,EACT,KAAK,uBACLC,EAASF,CAAO,EAChB,KAAK,KAAKE,EAASF,CAAO,CAAC,EAAE,aAAa,CAC5C,CACF,CAEA,iCAAiCG,EAAiE,CAChG,OAAO,KAAK,sBAAsBC,EAAqCD,CAAW,CAAC,CACrF,CAIA,gBAAgBA,EAAmD,CACjE,OAAO,KAAK,KAAKC,EAAqCD,CAAW,CAAC,CACpE,CAQO,UAAUZ,EAA8C,CAC7D,KAAK,KAAQK,GAAqB,IAAIC,EAAkBN,EAAOK,CAAM,CAAC,CACxE,CACF","names":["sha3_256","AbstractedAccount","_AbstractedAccount","Account","signer","accountAddress","authenticationFunction","isValidFunctionInfo","AbstractPublicKey","digest","AbstractSignature","serializer","Serializer","message","AccountAuthenticatorAbstraction","sha3_256","transaction","generateSigningMessageForTransaction"]}

package/dist/esm/chunk-P5CM4C2G.mjs

@@ -1,2 +0,0 @@
-import{c as T,d as c}from"./chunk-27ESCVVC.mjs";import{g as A,h as a}from"./chunk-RJ7F4JDV.mjs";import{sha3_256 as y}from"@noble/hashes/sha3";function d(e){return e.feePayerAddress?new c(e.rawTransaction,e.secondarySignerAddresses??[],e.feePayerAddress):e.secondarySignerAddresses?new T(e.rawTransaction,e.secondarySignerAddresses):e.rawTransaction}function n(e,r){let i=y.create();if(!r.startsWith("APTOS::"))throw new Error(`Domain separator needs to start with 'APTOS::'.  Provided - ${r}`);i.update(r);let s=i.digest(),o=e,t=new Uint8Array(s.length+o.length);return t.set(s),t.set(o,s.length),t}function u(e){return n(e.bcsToBytes(),`APTOS::${e.constructor.name}`)}function S(e){let r=d(e);return e.feePayerAddress?n(r.bcsToBytes(),a):e.secondarySignerAddresses?n(r.bcsToBytes(),a):n(r.bcsToBytes(),A)}export{d as a,n as b,u as c,S as d};
-//# sourceMappingURL=chunk-P5CM4C2G.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/transactionBuilder/signingMessage.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file handles the generation of the signing message.\n * @group Implementation\n * @category Transactions\n */\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport { RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT } from \"../../utils/const\";\nimport { FeePayerRawTransaction, MultiAgentRawTransaction } from \"../instances\";\nimport { AnyRawTransaction, AnyRawTransactionInstance } from \"../types\";\nimport { Serializable } from \"../../bcs\";\n\n/**\n * Derives the appropriate raw transaction type based on the provided transaction details.\n * This function helps in identifying whether the transaction is a FeePayerRawTransaction,\n * MultiAgentRawTransaction, or a standard RawTransaction.\n *\n * @param transaction - An object representing an Aptos transaction, which may include:\n *   - feePayerAddress - The address of the fee payer (optional).\n *   - secondarySignerAddresses - An array of secondary signer addresses (optional).\n *   - rawTransaction - The raw transaction data.\n *\n * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction\n * @group Implementation\n * @category Transactions\n */\nexport function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {\n  if (transaction.feePayerAddress) {\n    return new FeePayerRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses ?? [],\n      transaction.feePayerAddress,\n    );\n  }\n  if (transaction.secondarySignerAddresses) {\n    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);\n  }\n\n  return transaction.rawTransaction;\n}\n\n/**\n * Generates the 'signing message' form of a message to be signed.\n * This function combines a domain separator with the byte representation of the message to create a signing message.\n *\n * @param bytes - The byte representation of the message to be signed and sent to the chain.\n * @param domainSeparator - A domain separator that starts with 'APTOS::'.\n *\n * @returns The Uint8Array of the signing message.\n * @group Implementation\n * @category Transactions\n */\nexport function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array {\n  const hash = sha3Hash.create();\n\n  if (!domainSeparator.startsWith(\"APTOS::\")) {\n    throw new Error(`Domain separator needs to start with 'APTOS::'.  Provided - ${domainSeparator}`);\n  }\n\n  hash.update(domainSeparator);\n\n  const prefix = hash.digest();\n\n  const body = bytes;\n\n  const mergedArray = new Uint8Array(prefix.length + body.length);\n  mergedArray.set(prefix);\n  mergedArray.set(body, prefix.length);\n\n  return mergedArray;\n}\n\n/**\n * @deprecated\n * Use CryptoHashable instead by having your class implement it and call hash() to get the signing message.\n *\n * Generates the 'signing message' form of a serializable value by serializing it and using the constructor name as the domain\n * separator.\n *\n * @param serializable - An object that has a BCS serialized form.\n *\n * @returns The Uint8Array of the signing message.\n * @group Implementation\n * @category Transactions\n */\nexport function generateSigningMessageForSerializable(serializable: Serializable): Uint8Array {\n  return generateSigningMessage(serializable.bcsToBytes(), `APTOS::${serializable.constructor.name}`);\n}\n\n/**\n * Generates the 'signing message' form of a transaction by deriving the type of transaction and applying the appropriate domain\n * separator based on the presence of a fee payer or secondary signers.\n *\n * @param transaction - A transaction that is to be signed, which can include a fee payer address or secondary signer addresses.\n *\n * @returns The Uint8Array of the signing message.\n * @group Implementation\n * @category Transactions\n */\nexport function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array {\n  const rawTxn = deriveTransactionType(transaction);\n  if (transaction.feePayerAddress) {\n    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);\n  }\n  if (transaction.secondarySignerAddresses) {\n    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);\n  }\n  return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_SALT);\n}\n"],"mappings":"gGAQA,OAAS,YAAYA,MAAgB,qBAoB9B,SAASC,EAAsBC,EAA2D,CAC/F,OAAIA,EAAY,gBACP,IAAIC,EACTD,EAAY,eACZA,EAAY,0BAA4B,CAAC,EACzCA,EAAY,eACd,EAEEA,EAAY,yBACP,IAAIE,EAAyBF,EAAY,eAAgBA,EAAY,wBAAwB,EAG/FA,EAAY,cACrB,CAaO,SAASG,EAAuBC,EAAmBC,EAAqC,CAC7F,IAAMC,EAAOC,EAAS,OAAO,EAE7B,GAAI,CAACF,EAAgB,WAAW,SAAS,EACvC,MAAM,IAAI,MAAM,+DAA+DA,CAAe,EAAE,EAGlGC,EAAK,OAAOD,CAAe,EAE3B,IAAMG,EAASF,EAAK,OAAO,EAErBG,EAAOL,EAEPM,EAAc,IAAI,WAAWF,EAAO,OAASC,EAAK,MAAM,EAC9D,OAAAC,EAAY,IAAIF,CAAM,EACtBE,EAAY,IAAID,EAAMD,EAAO,MAAM,EAE5BE,CACT,CAeO,SAASC,EAAsCC,EAAwC,CAC5F,OAAOT,EAAuBS,EAAa,WAAW,EAAG,UAAUA,EAAa,YAAY,IAAI,EAAE,CACpG,CAYO,SAASC,EAAqCb,EAA4C,CAC/F,IAAMc,EAASf,EAAsBC,CAAW,EAChD,OAAIA,EAAY,gBACPG,EAAuBW,EAAO,WAAW,EAAGC,CAA8B,EAE/Ef,EAAY,yBACPG,EAAuBW,EAAO,WAAW,EAAGC,CAA8B,EAE5EZ,EAAuBW,EAAO,WAAW,EAAGE,CAAoB,CACzE","names":["sha3Hash","deriveTransactionType","transaction","FeePayerRawTransaction","MultiAgentRawTransaction","generateSigningMessage","bytes","domainSeparator","hash","sha3Hash","prefix","body","mergedArray","generateSigningMessageForSerializable","serializable","generateSigningMessageForTransaction","rawTxn","RAW_TRANSACTION_WITH_DATA_SALT","RAW_TRANSACTION_SALT"]}

package/dist/esm/chunk-PC25RPDV.mjs

@@ -1,2 +0,0 @@
-import{a as r}from"./chunk-53IBOHXB.mjs";import{i as d,n as a,q as i}from"./chunk-5W2ERBGY.mjs";import{j as m}from"./chunk-BHVSIRNF.mjs";async function y(n){let{aptosConfig:t,sender:o,authenticationFunction:e,options:s}=n,{moduleAddress:c,moduleName:u,functionName:p}=m(e);return r({aptosConfig:t,sender:o,data:{function:"0x1::account_abstraction::add_authentication_function",typeArguments:[],functionArguments:[c,u,p],abi:{typeParameters:[],parameters:[new d,new a(i()),new a(i())]}},options:s})}async function I(n){let{aptosConfig:t,sender:o,authenticationFunction:e,options:s}=n,{moduleAddress:c,moduleName:u,functionName:p}=m(e);return r({aptosConfig:t,sender:o,data:{function:"0x1::account_abstraction::remove_authentication_function",typeArguments:[],functionArguments:[c,u,p],abi:{typeParameters:[],parameters:[new d,new a(i()),new a(i())]}},options:s})}async function C(n){let{aptosConfig:t,sender:o,options:e}=n;return r({aptosConfig:t,sender:o,data:{function:"0x1::account_abstraction::remove_authenticator",typeArguments:[],functionArguments:[],abi:{typeParameters:[],parameters:[]}},options:e})}export{y as a,I as b,C as c};
-//# sourceMappingURL=chunk-PC25RPDV.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/abstraction.ts"],"sourcesContent":["import {\n  SimpleTransaction,\n  InputGenerateTransactionOptions,\n  TypeTagAddress,\n  TypeTagStruct,\n  stringStructTag,\n} from \"../transactions\";\nimport { AccountAddressInput } from \"../core\";\nimport { generateTransaction } from \"./transactionSubmission\";\nimport { MoveFunctionId } from \"../types\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { getFunctionParts } from \"../utils/helpers\";\n\nexport async function addAuthenticationFunctionTransaction(args: {\n  aptosConfig: AptosConfig;\n  sender: AccountAddressInput;\n  authenticationFunction: string;\n  options?: InputGenerateTransactionOptions;\n}): Promise<SimpleTransaction> {\n  const { aptosConfig, sender, authenticationFunction, options } = args;\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(authenticationFunction as MoveFunctionId);\n  return generateTransaction({\n    aptosConfig,\n    sender,\n    data: {\n      function: \"0x1::account_abstraction::add_authentication_function\",\n      typeArguments: [],\n      functionArguments: [moduleAddress, moduleName, functionName],\n      abi: {\n        typeParameters: [],\n        parameters: [new TypeTagAddress(), new TypeTagStruct(stringStructTag()), new TypeTagStruct(stringStructTag())],\n      },\n    },\n    options,\n  });\n}\n\nexport async function removeAuthenticationFunctionTransaction(args: {\n  aptosConfig: AptosConfig;\n  sender: AccountAddressInput;\n  authenticationFunction: string;\n  options?: InputGenerateTransactionOptions;\n}) {\n  const { aptosConfig, sender, authenticationFunction, options } = args;\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(authenticationFunction as MoveFunctionId);\n  return generateTransaction({\n    aptosConfig,\n    sender,\n    data: {\n      function: \"0x1::account_abstraction::remove_authentication_function\",\n      typeArguments: [],\n      functionArguments: [moduleAddress, moduleName, functionName],\n      abi: {\n        typeParameters: [],\n        parameters: [new TypeTagAddress(), new TypeTagStruct(stringStructTag()), new TypeTagStruct(stringStructTag())],\n      },\n    },\n    options,\n  });\n}\n\nexport async function removeDispatchableAuthenticatorTransaction(args: {\n  aptosConfig: AptosConfig;\n  sender: AccountAddressInput;\n  options?: InputGenerateTransactionOptions;\n}) {\n  const { aptosConfig, sender, options } = args;\n  return generateTransaction({\n    aptosConfig,\n    sender,\n    data: {\n      function: \"0x1::account_abstraction::remove_authenticator\",\n      typeArguments: [],\n      functionArguments: [],\n      abi: { typeParameters: [], parameters: [] },\n    },\n    options,\n  });\n}\n"],"mappings":"yIAaA,eAAsBA,EAAqCC,EAK5B,CAC7B,GAAM,CAAE,YAAAC,EAAa,OAAAC,EAAQ,uBAAAC,EAAwB,QAAAC,CAAQ,EAAIJ,EAC3D,CAAE,cAAAK,EAAe,WAAAC,EAAY,aAAAC,CAAa,EAAIC,EAAiBL,CAAwC,EAC7G,OAAOM,EAAoB,CACzB,YAAAR,EACA,OAAAC,EACA,KAAM,CACJ,SAAU,wDACV,cAAe,CAAC,EAChB,kBAAmB,CAACG,EAAeC,EAAYC,CAAY,EAC3D,IAAK,CACH,eAAgB,CAAC,EACjB,WAAY,CAAC,IAAIG,EAAkB,IAAIC,EAAcC,EAAgB,CAAC,EAAG,IAAID,EAAcC,EAAgB,CAAC,CAAC,CAC/G,CACF,EACA,QAAAR,CACF,CAAC,CACH,CAEA,eAAsBS,EAAwCb,EAK3D,CACD,GAAM,CAAE,YAAAC,EAAa,OAAAC,EAAQ,uBAAAC,EAAwB,QAAAC,CAAQ,EAAIJ,EAC3D,CAAE,cAAAK,EAAe,WAAAC,EAAY,aAAAC,CAAa,EAAIC,EAAiBL,CAAwC,EAC7G,OAAOM,EAAoB,CACzB,YAAAR,EACA,OAAAC,EACA,KAAM,CACJ,SAAU,2DACV,cAAe,CAAC,EAChB,kBAAmB,CAACG,EAAeC,EAAYC,CAAY,EAC3D,IAAK,CACH,eAAgB,CAAC,EACjB,WAAY,CAAC,IAAIG,EAAkB,IAAIC,EAAcC,EAAgB,CAAC,EAAG,IAAID,EAAcC,EAAgB,CAAC,CAAC,CAC/G,CACF,EACA,QAAAR,CACF,CAAC,CACH,CAEA,eAAsBU,EAA2Cd,EAI9D,CACD,GAAM,CAAE,YAAAC,EAAa,OAAAC,EAAQ,QAAAE,CAAQ,EAAIJ,EACzC,OAAOS,EAAoB,CACzB,YAAAR,EACA,OAAAC,EACA,KAAM,CACJ,SAAU,iDACV,cAAe,CAAC,EAChB,kBAAmB,CAAC,EACpB,IAAK,CAAE,eAAgB,CAAC,EAAG,WAAY,CAAC,CAAE,CAC5C,EACA,QAAAE,CACF,CAAC,CACH","names":["addAuthenticationFunctionTransaction","args","aptosConfig","sender","authenticationFunction","options","moduleAddress","moduleName","functionName","getFunctionParts","generateTransaction","TypeTagAddress","TypeTagStruct","stringStructTag","removeAuthenticationFunctionTransaction","removeDispatchableAuthenticatorTransaction"]}

package/dist/esm/chunk-PIPDQFL2.mjs

@@ -1,2 +0,0 @@
-import{a as w,d as dn,e as An,g as $}from"./chunk-XRVZAEQO.mjs";import{r as un}from"./chunk-IMYNN4TW.mjs";import{a as sn}from"./chunk-W2C5KRUQ.mjs";import{b as cn}from"./chunk-GRRBXHVG.mjs";import{a as on}from"./chunk-KK5HUWF6.mjs";import{a as rn}from"./chunk-ONGH5DXZ.mjs";import{a as f}from"./chunk-YWSDONJJ.mjs";import{a as an}from"./chunk-T7X4GZDU.mjs";import{a as Y,c as nn,d as tn}from"./chunk-27ESCVVC.mjs";import{c as z,d as L,e as Z,f as F,g as j,h as J,i as Q}from"./chunk-44EHAKKW.mjs";import{a as X}from"./chunk-LS3IDL2N.mjs";import{b as D,c as en,d as M,e as R,f as T}from"./chunk-BQYKFATL.mjs";import{a as q,b as l,c as H,d as h,e as x,f as B}from"./chunk-BPHCRTHD.mjs";import{b as O,c as V}from"./chunk-QUJM5W4L.mjs";import{a as E,b as p}from"./chunk-2TRQERBL.mjs";import{a as G}from"./chunk-JNNFNYDO.mjs";import{a as v}from"./chunk-XW3BXTCZ.mjs";import{i as b,j as k}from"./chunk-HVIF6DW6.mjs";import{b as N,d as W}from"./chunk-7OUPEQRN.mjs";import{a as C}from"./chunk-YOZBVVKL.mjs";import{a as U}from"./chunk-BMPHQ3E7.mjs";import{g as S}from"./chunk-4RXKALLC.mjs";import{b as K,c as _}from"./chunk-RJ7F4JDV.mjs";import{j as y}from"./chunk-BHVSIRNF.mjs";import{b as u}from"./chunk-LQOSHBB7.mjs";import{b as P}from"./chunk-VHY6ZATX.mjs";import{sha3_256 as ln}from"@noble/hashes/sha3";async function Ln(n){if(un(n))return wn(n);let{moduleAddress:e,moduleName:t,functionName:i}=y(n.function),r=await yn({key:"entry-function",moduleAddress:e,moduleName:t,functionName:i,aptosConfig:n.aptosConfig,abi:n.abi,fetch:dn});return hn({...n,abi:r})}function hn(n){let e=n.abi,{moduleAddress:t,moduleName:i,functionName:r}=y(n.function),a=w(n.typeArguments);if(a.length!==e.typeParameters.length)throw new Error(`Type argument count mismatch, expected ${e.typeParameters.length}, received ${a.length}`);let o=n.functionArguments.map((s,d)=>$(n.function,e,s,d,a));if(o.length!==e.parameters.length)throw new Error(`Too few arguments for '${t}::${i}::${r}', expected ${e.parameters.length} but got ${o.length}`);let c=F.build(`${t}::${i}`,r,a,o);if("multisigAddress"in n){let s=u.from(n.multisigAddress);return new Z(new J(s,new Q(c)))}return new L(c)}async function Zn(n){let{moduleAddress:e,moduleName:t,functionName:i}=y(n.function),r=await yn({key:"view-function",moduleAddress:e,moduleName:t,functionName:i,aptosConfig:n.aptosConfig,abi:n.abi,fetch:An});return Tn({abi:r,...n})}function Tn(n){let e=n.abi,{moduleAddress:t,moduleName:i,functionName:r}=y(n.function),a=w(n.typeArguments);if(a.length!==e.typeParameters.length)throw new Error(`Type argument count mismatch, expected ${e.typeParameters.length}, received ${a.length}`);let o=n?.functionArguments?.map((c,s)=>$(n.function,e,c,s,a))??[];if(o.length!==e.parameters.length)throw new Error(`Too few arguments for '${t}::${i}::${r}', expected ${e.parameters.length} but got ${o.length}`);return F.build(`${t}::${i}`,r,a,o)}function wn(n){return new z(new j(P.fromHexInput(n.bytecode).toUint8Array(),w(n.typeArguments),n.functionArguments))}async function In(n){let{aptosConfig:e,sender:t,payload:i,options:r,feePayerAddress:a}=n,o=async()=>S[e.network]?{chainId:S[e.network]}:{chainId:(await on({aptosConfig:e})).chain_id},c=async()=>r?.gasUnitPrice?{gasEstimate:r.gasUnitPrice}:{gasEstimate:(await cn({aptosConfig:e})).gas_estimate},s=async()=>{let g=async()=>r?.accountSequenceNumber!==void 0?r.accountSequenceNumber:(await sn({aptosConfig:e,accountAddress:t})).sequence_number;if(a&&u.from(a).equals(u.ZERO))try{return await g()}catch{return 0}else return g()},[{chainId:d},{gasEstimate:m},I]=await Promise.all([o(),c(),s()]),{maxGasAmount:fn,gasUnitPrice:gn,expireTimestamp:pn}={maxGasAmount:r?.maxGasAmount?BigInt(r.maxGasAmount):BigInt(2e5),gasUnitPrice:r?.gasUnitPrice??BigInt(m),expireTimestamp:r?.expireTimestamp??BigInt(Math.floor(Date.now()/1e3)+20)};return new Y(u.from(t),BigInt(I),i,BigInt(fn),BigInt(gn),BigInt(pn),new X(d))}async function jn(n){let{aptosConfig:e,sender:t,payload:i,options:r,feePayerAddress:a}=n,o=await In({aptosConfig:e,sender:t,payload:i,options:r,feePayerAddress:a});if("secondarySignerAddresses"in n){let c=n.secondarySignerAddresses?.map(s=>u.from(s))??[];return new rn(o,c,n.feePayerAddress?u.from(n.feePayerAddress):void 0)}return new an(o,n.feePayerAddress?u.from(n.feePayerAddress):void 0)}function Jn(n){let{signerPublicKey:e,transaction:t,secondarySignersPublicKeys:i,feePayerPublicKey:r}=n,a=A(e);if(t.feePayerAddress){let c=new tn(t.rawTransaction,t.secondarySignerAddresses??[],t.feePayerAddress),s=[];t.secondarySignerAddresses&&(i?s=i.map(I=>A(I)):s=Array.from({length:t.secondarySignerAddresses.length},()=>A(void 0)));let d=A(r),m=new R(a,t.secondarySignerAddresses??[],s,{address:t.feePayerAddress,authenticator:d});return new f(c.raw_txn,m).bcsToBytes()}if(t.secondarySignerAddresses){let c=new nn(t.rawTransaction,t.secondarySignerAddresses),s=[];i?s=i.map(m=>A(m)):s=Array.from({length:t.secondarySignerAddresses.length},()=>A(void 0));let d=new M(a,t.secondarySignerAddresses,s);return new f(c.raw_txn,d).bcsToBytes()}let o;if(a instanceof l)o=new D(a.public_key,a.signature);else if(a instanceof h||a instanceof x)o=new T(a);else if(a instanceof B)o=new T(a);else throw new Error("Invalid public key");return new f(t.rawTransaction,o).bcsToBytes()}function A(n){if(!n)return new B;let t=b.isInstance(n)||v.isInstance(n)||G.isInstance(n)?new E(n):n,i=new W(new Uint8Array(64));if(N.isInstance(t))return new l(t,i);if(E.isInstance(t))return b.isInstance(t.publicKey)?new h(t,new p(k.getSimulationSignature())):new h(t,new p(i));if(O.isInstance(t))return new x(t,new V({signatures:t.publicKeys.map(()=>new p(i)),bitmap:t.createBitmap({bits:Array(t.publicKeys.length).fill(0).map((r,a)=>a)})}));throw new Error("Unsupported PublicKey used for simulations")}function Pn(n){let{transaction:e,feePayerAuthenticator:t,additionalSignersAuthenticators:i}=n,r=U(q,n.senderAuthenticator),a;if(e.feePayerAddress){if(!t)throw new Error("Must provide a feePayerAuthenticator argument to generate a signed fee payer transaction");a=new R(r,e.secondarySignerAddresses??[],i??[],{address:e.feePayerAddress,authenticator:t})}else if(e.secondarySignerAddresses){if(!i)throw new Error("Must provide a additionalSignersAuthenticators argument to generate a signed multi agent transaction");a=new M(r,e.secondarySignerAddresses,i)}else r instanceof l?a=new D(r.public_key,r.signature):r instanceof H?a=new en(r.public_key,r.signature):a=new T(r);return new f(e.rawTransaction,a).bcsToBytes()}function mn(n){let e=ln.create();for(let t of n)e.update(t);return e.digest()}var Sn=mn(["APTOS::Transaction"]);function Qn(n){let e=Pn(n);return new P(mn([Sn,new Uint8Array([0]),e])).toString()}async function yn({key:n,moduleAddress:e,moduleName:t,functionName:i,aptosConfig:r,abi:a,fetch:o}){return a!==void 0?a:C(async()=>o(e,t,i,r),`${n}-${r.network}-${e}-${t}-${i}`,1e3*60*5)()}export{Ln as a,hn as b,Zn as c,Tn as d,In as e,jn as f,Jn as g,A as h,Pn as i,mn as j,Qn as k};
-//# sourceMappingURL=chunk-PIPDQFL2.mjs.map