@aptos-labs/ts-sdk 1.13.0-zeta.1 → 1.13.1-zeta.1

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/ed25519.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ed25519 } from \"@noble/curves/ed25519\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Hex } from \"../hex\";\nimport { HexInput, SigningScheme as AuthenticationKeyScheme } from \"../../types\";\nimport {\n  isValidHardenedPath,\n  fromDerivationPath as fromDerivationPathInner,\n  mnemonicToSeed,\n} from \"./hdKey\";\nimport { PrivateKey } from \"./privateKey\";\nimport { AccountPublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { convertSigningMessage } from \"./utils\";\n\n/**\n * L is the value that greater than or equal to will produce a non-canonical signature, and must be rejected\n */\nconst L: number[] = [\n  0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\n];\n\n/**\n * Represents the public key of an Ed25519 key pair.\n *\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentication keys.\n *\n * Ed25519 scheme is represented in the SDK as `Legacy authentication key` and also\n * as `AnyPublicKey` that represents any `Unified authentication key`\n */\nexport class Ed25519PublicKey extends AccountPublicKey {\n  /**\n   * Length of an Ed25519 public key\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * Bytes of the public key\n   * @private\n   */\n  private readonly key: Hex;\n\n  /**\n   * Create a new PublicKey instance from a Uint8Array or String.\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   */\n  constructor(hexInput: HexInput) {\n    super();\n\n    const hex = Hex.fromHexInput(hexInput);\n    if (hex.toUint8Array().length !== Ed25519PublicKey.LENGTH) {\n      throw new Error(`PublicKey length should be ${Ed25519PublicKey.LENGTH}`);\n    }\n    this.key = hex;\n  }\n\n  // region AccountPublicKey\n\n  /**\n   * Verifies a signed data with a public key\n   * @param args.message a signed message as a Hex string or Uint8Array\n   * @param args.signature the signature of the message\n   */\n  verifySignature(args: VerifySignatureArgs): boolean {\n    const { message, signature } = args;\n    if (!(signature instanceof Ed25519Signature)) {\n      return false;\n    }\n    const messageToVerify = convertSigningMessage(message);\n    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();\n    const signatureBytes = signature.toUint8Array();\n    const publicKeyBytes = this.key.toUint8Array();\n    // Also verify malleability\n    if (!signature.isCanonicalSignature()) {\n      return false;\n    }\n\n    return ed25519.verify(signatureBytes, messageBytes, publicKeyBytes);\n  }\n\n  authKey(): AuthenticationKey {\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: AuthenticationKeyScheme.Ed25519,\n      input: this.toUint8Array(),\n    });\n  }\n\n  /**\n   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   */\n  toUint8Array(): Uint8Array {\n    return this.key.toUint8Array();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.key.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Ed25519PublicKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Ed25519PublicKey(bytes);\n  }\n\n  // endregion\n\n  /**\n   * @deprecated use `instanceof Ed25519PublicKey` instead.\n   */\n  static isPublicKey(publicKey: AccountPublicKey): publicKey is Ed25519PublicKey {\n    return publicKey instanceof Ed25519PublicKey;\n  }\n}\n\n/**\n * Represents the private key of an Ed25519 key pair.\n */\nexport class Ed25519PrivateKey extends Serializable implements PrivateKey {\n  /**\n   * Length of an Ed25519 private key\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * The Ed25519 key seed to use for BIP-32 compatibility\n   * See more {@link https://github.com/satoshilabs/slips/blob/master/slip-0010.md}\n   */\n  static readonly SLIP_0010_SEED = \"ed25519 seed\";\n\n  /**\n   * The Ed25519 signing key\n   * @private\n   */\n  private readonly signingKey: Hex;\n\n  // region Constructors\n\n  /**\n   * Create a new PrivateKey instance from a Uint8Array or String.\n   *\n   * @param hexInput HexInput (string or Uint8Array)\n   */\n  constructor(hexInput: HexInput) {\n    super();\n\n    const privateKeyHex = Hex.fromHexInput(hexInput);\n    if (privateKeyHex.toUint8Array().length !== Ed25519PrivateKey.LENGTH) {\n      throw new Error(`PrivateKey length should be ${Ed25519PrivateKey.LENGTH}`);\n    }\n\n    // Create keyPair from Private key in Uint8Array format\n    this.signingKey = privateKeyHex;\n  }\n\n  /**\n   * Generate a new random private key.\n   *\n   * @returns Ed25519PrivateKey\n   */\n  static generate(): Ed25519PrivateKey {\n    const keyPair = ed25519.utils.randomPrivateKey();\n    return new Ed25519PrivateKey(keyPair);\n  }\n\n  /**\n   * Derives a private key from a mnemonic seed phrase.\n   *\n   * To derive multiple keys from the same phrase, change the path\n   *\n   * IMPORTANT: Ed25519 supports hardened derivation only (since it lacks a key homomorphism,\n   * so non-hardened derivation cannot work)\n   *\n   * @param path the BIP44 path\n   * @param mnemonics the mnemonic seed phrase\n   */\n  static fromDerivationPath(path: string, mnemonics: string): Ed25519PrivateKey {\n    if (!isValidHardenedPath(path)) {\n      throw new Error(`Invalid derivation path ${path}`);\n    }\n    return new Ed25519PrivateKey(fromDerivationPathInner(path, Ed25519PrivateKey.SLIP_0010_SEED, mnemonicToSeed(mnemonics)));\n  }\n\n  // endregion\n\n  // region PrivateKey\n\n  /**\n   * Derive the Ed25519PublicKey for this private key.\n   *\n   * @returns Ed25519PublicKey\n   */\n  publicKey(): Ed25519PublicKey {\n    const bytes = ed25519.getPublicKey(this.signingKey.toUint8Array());\n    return new Ed25519PublicKey(bytes);\n  }\n\n  /**\n   * Sign the given message with the private key.\n   *\n   * @param message a message as a string or Uint8Array\n   * @returns Signature\n   */\n  sign(message: HexInput): Ed25519Signature {\n    const messageToSign = convertSigningMessage(message);\n    const messageBytes = Hex.fromHexInput(messageToSign).toUint8Array();\n    const signatureBytes = ed25519.sign(messageBytes, this.signingKey.toUint8Array());\n    return new Ed25519Signature(signatureBytes);\n  }\n\n  /**\n   * Get the private key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the private key\n   */\n  toUint8Array(): Uint8Array {\n    return this.signingKey.toUint8Array();\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  toString(): string {\n    return this.signingKey.toString();\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): Ed25519PrivateKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Ed25519PrivateKey(bytes);\n  }\n\n  // endregion\n\n  /**\n   * @deprecated use `instanceof Ed25519PrivateKey` instead.\n   */\n  static isPrivateKey(privateKey: PrivateKey): privateKey is Ed25519PrivateKey {\n    return privateKey instanceof Ed25519PrivateKey;\n  }\n}\n\n/**\n * A signature of a message signed using an Ed25519 private key\n */\nexport class Ed25519Signature extends Signature {\n  /**\n   * Length of an Ed25519 signature\n   */\n  static readonly LENGTH = 64;\n\n  /**\n   * The signature bytes\n   * @private\n   */\n  private readonly data: Hex;\n\n  // region Constructors\n\n  constructor(hexInput: HexInput) {\n    super();\n    const data = Hex.fromHexInput(hexInput);\n    if (data.toUint8Array().length !== Ed25519Signature.LENGTH) {\n      throw new Error(`Signature length should be ${Ed25519Signature.LENGTH}`);\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): Ed25519Signature {\n    const bytes = deserializer.deserializeBytes();\n    return new Ed25519Signature(bytes);\n  }\n\n  /**\n   * Checks if an ED25519 signature is non-canonical.\n   *\n   * Comes from Aptos Core\n   * https://github.com/aptos-labs/aptos-core/blob/main/crates/aptos-crypto/src/ed25519/ed25519_sigs.rs#L47-L85\n   */\n  isCanonicalSignature(): boolean {\n    const s = this.toUint8Array().slice(32);\n\n    for (let i = s.length - 1; i >= 0; i -= 1) {\n      if (s[i] < L[i]) {\n        return true;\n      }\n      if (s[i] > L[i]) {\n        return false;\n      }\n    }\n    // As this stage S == L which implies a non-canonical S.\n    return false;\n  }\n\n  // endregion\n}\n"],"mappings":"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","names":["ed25519","L","_Ed25519PublicKey","AccountPublicKey","hexInput","hex","Hex","args","message","signature","Ed25519Signature","messageToVerify","convertSigningMessage","messageBytes","signatureBytes","publicKeyBytes","ed25519","AuthenticationKey","serializer","deserializer","bytes","publicKey","Ed25519PublicKey","_Ed25519PrivateKey","Serializable","privateKeyHex","keyPair","path","mnemonics","isValidHardenedPath","fromDerivationPath","mnemonicToSeed","messageToSign","privateKey","Ed25519PrivateKey","_Ed25519Signature","Signature","data","s","i"]}

package/dist/esm/chunk-WF737YNO.mjs

@@ -1,2 +0,0 @@
-import{d as s}from"./chunk-YU7DNMEA.mjs";import{d as p}from"./chunk-4AOGG725.mjs";import{a as u,b as y}from"./chunk-ULUMROUJ.mjs";import{b as a}from"./chunk-B645DPPF.mjs";import{b as i}from"./chunk-VAZQVN5V.mjs";import{b as g}from"./chunk-U7EZI5D5.mjs";var m=class o{constructor(e){this.signingScheme=2;let{privateKey:t,address:r}=e;this.privateKey=t,this.publicKey=new u(t.publicKey()),this.accountAddress=r?g.from(r):this.publicKey.authKey().derivedAddress()}static generate(e={}){let{scheme:t=0}=e,r;switch(t){case 0:r=i.generate();break;case 2:r=a.generate();break;default:throw new Error(`Unsupported signature scheme ${t}`)}return new o({privateKey:r})}static fromDerivationPath(e){let{scheme:t=0,path:r,mnemonic:c}=e,n;switch(t){case 0:n=i.fromDerivationPath(r,c);break;case 2:n=a.fromDerivationPath(r,c);break;default:throw new Error(`Unsupported signature scheme ${t}`)}return new o({privateKey:n})}verifySignature(e){return this.publicKey.verifySignature(e)}signWithAuthenticator(e){let t=this.sign(s(e)),r=new y(t);return new p(this.publicKey,r)}sign(e){return this.privateKey.sign(e)}signTransaction(e){return this.sign(s(e))}};export{m as a};
-//# sourceMappingURL=chunk-WF737YNO.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/multiKey.ts"],"sourcesContent":["import { SigningScheme as AuthenticationKeyScheme } from \"../../types\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializer } from \"../../bcs/serializer\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { AccountPublicKey, PublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { AnyPublicKey, AnySignature } from \"./singleKey\";\n\n/* eslint-disable no-bitwise */\n\nfunction bitCount(byte: number) {\n  let n = byte;\n  n -= (n >> 1) & 0x55555555;\n  n = (n & 0x33333333) + ((n >> 2) & 0x33333333);\n  return (((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;\n}\n\n/* eslint-enable no-bitwise */\n\n/**\n * Represents the public key of a multi-agent account.\n *\n * The public keys of each individual agent can be any type of public key supported by Aptos.\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentication keys.\n */\nexport class MultiKey extends AccountPublicKey {\n  /**\n   * List of any public keys\n   */\n  public readonly publicKeys: AnyPublicKey[];\n\n  /**\n   * The minimum number of valid signatures required, for the number of public keys specified\n   */\n  public readonly signaturesRequired: number;\n\n  // region Constructors\n\n  constructor(args: { publicKeys: Array<PublicKey>; signaturesRequired: number }) {\n    super();\n    const { publicKeys, signaturesRequired } = args;\n\n    // Validate number of public keys is greater than signature required\n    if (signaturesRequired < 1) {\n      throw new Error(\"The number of required signatures needs to be greater than 0\");\n    }\n\n    // Validate number of public keys is greater than signature required\n    if (publicKeys.length < signaturesRequired) {\n      throw new Error(\n        `Provided ${publicKeys.length} public keys is smaller than the ${signaturesRequired} required signatures`,\n      );\n    }\n\n    // Make sure that all keys are normalized to the SingleKey authentication scheme\n    this.publicKeys = publicKeys.map((publicKey) =>\n      publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey),\n    );\n\n    this.signaturesRequired = signaturesRequired;\n  }\n\n  // endregion\n\n  // region AccountPublicKey\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  verifySignature(args: VerifySignatureArgs): boolean {\n    throw new Error(\"not implemented\");\n  }\n\n  authKey(): AuthenticationKey {\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: AuthenticationKeyScheme.MultiKey,\n      input: this.toUint8Array(),\n    });\n  }\n\n  toUint8Array(): Uint8Array {\n    return this.bcsToBytes();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeVector(this.publicKeys);\n    serializer.serializeU8(this.signaturesRequired);\n  }\n\n  static deserialize(deserializer: Deserializer): MultiKey {\n    const keys = deserializer.deserializeVector(AnyPublicKey);\n    const signaturesRequired = deserializer.deserializeU8();\n\n    return new MultiKey({ publicKeys: keys, signaturesRequired });\n  }\n\n  // endregion\n\n  /**\n   * Create a bitmap that holds the mapping from the original public keys\n   * to the signatures passed in\n   *\n   * @param args.bits array of the index mapping to the matching public keys\n   * @returns Uint8array bit map\n   */\n  createBitmap(args: { bits: number[] }): Uint8Array {\n    const { bits } = args;\n    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.\n    // The decimal value of 0b10000000 is 128.\n    const firstBitInByte = 128;\n    const bitmap = new Uint8Array([0, 0, 0, 0]);\n\n    // Check if duplicates exist in bits\n    const dupCheckSet = new Set();\n\n    bits.forEach((bit: number, idx: number) => {\n      if (idx + 1 > this.publicKeys.length) {\n        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);\n      }\n\n      if (dupCheckSet.has(bit)) {\n        throw new Error(`Duplicate bit ${bit} detected.`);\n      }\n\n      dupCheckSet.add(bit);\n\n      const byteOffset = Math.floor(bit / 8);\n\n      let byte = bitmap[byteOffset];\n\n      // eslint-disable-next-line no-bitwise\n      byte |= firstBitInByte >> bit % 8;\n\n      bitmap[byteOffset] = byte;\n    });\n\n    return bitmap;\n  }\n\n  getIndex(publicKey: PublicKey): number {\n\n    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey)\n    const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());\n\n    if (index !== -1) {\n        return index;\n    } \n    throw new Error(\"Public key not found in MultiKey\");\n  \n  }\n}\n\nexport class MultiSignature extends Signature {\n  /**\n   * Number of bytes in the bitmap representing who signed the transaction (32-bits)\n   */\n  static BITMAP_LEN: number = 4;\n\n  /**\n   * Maximum number of Ed25519 signatures supported\n   */\n  static MAX_SIGNATURES_SUPPORTED = MultiSignature.BITMAP_LEN * 8;\n\n  /**\n   * The list of underlying Ed25519 signatures\n   */\n  public readonly signatures: AnySignature[];\n\n  /**\n   * 32-bit Bitmap representing who signed the transaction\n   *\n   * This is represented where each public key can be masked to determine whether the message was signed by that key.\n   */\n  public readonly bitmap: Uint8Array;\n\n  /**\n   * Signature for a K-of-N multi-sig transaction.\n   *\n   * @see {@link\n   * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}\n   *\n   * @param args.signatures A list of signatures\n   * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth\n   * signature should be provided in `signatures`. Bits are read from left to right\n   */\n  constructor(args: { signatures: Array<Signature | AnySignature>; bitmap: Uint8Array | number[] }) {\n    super();\n    const { signatures, bitmap } = args;\n\n    if (signatures.length > MultiSignature.MAX_SIGNATURES_SUPPORTED) {\n      throw new Error(`The number of signatures cannot be greater than ${MultiSignature.MAX_SIGNATURES_SUPPORTED}`);\n    }\n\n    // Make sure that all signatures are normalized to the SingleKey authentication scheme\n    this.signatures = signatures.map((signature) =>\n      signature instanceof AnySignature ? signature : new AnySignature(signature),\n    );\n\n    if (!(bitmap instanceof Uint8Array)) {\n      this.bitmap = MultiSignature.createBitmap({ bits: bitmap });\n    } else if (bitmap.length !== MultiSignature.BITMAP_LEN) {\n      throw new Error(`\"bitmap\" length should be ${MultiSignature.BITMAP_LEN}`);\n    } else {\n      this.bitmap = bitmap;\n    }\n\n    const nSignatures = this.bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);\n    if (nSignatures !== this.signatures.length) {\n      throw new Error(`Expecting ${nSignatures} signatures from the bitmap, but got ${this.signatures.length}`);\n    }\n  }\n\n  /**\n   * Helper method to create a bitmap out of the specified bit positions\n   * @param args.bits The bitmap positions that should be set. A position starts at index 0.\n   * Valid position should range between 0 and 31.\n   * @example\n   * Here's an example of valid `bits`\n   * ```\n   * [0, 2, 31]\n   * ```\n   * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.\n   * The result bitmap should be 0b1010000000000000000000000000001\n   *\n   * @returns bitmap that is 32bit long\n   */\n  static createBitmap(args: { bits: number[] }): Uint8Array {\n    const { bits } = args;\n    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.\n    // The decimal value of 0b10000000 is 128.\n    const firstBitInByte = 128;\n    const bitmap = new Uint8Array([0, 0, 0, 0]);\n\n    // Check if duplicates exist in bits\n    const dupCheckSet = new Set();\n\n    bits.forEach((bit: number) => {\n      if (bit >= MultiSignature.MAX_SIGNATURES_SUPPORTED) {\n        throw new Error(`Cannot have a signature larger than ${MultiSignature.MAX_SIGNATURES_SUPPORTED - 1}.`);\n      }\n\n      if (dupCheckSet.has(bit)) {\n        throw new Error(\"Duplicate bits detected.\");\n      }\n\n      dupCheckSet.add(bit);\n\n      const byteOffset = Math.floor(bit / 8);\n\n      let byte = bitmap[byteOffset];\n\n      // eslint-disable-next-line no-bitwise\n      byte |= firstBitInByte >> bit % 8;\n\n      bitmap[byteOffset] = byte;\n    });\n\n    return bitmap;\n  }\n\n  // region Signature\n\n  toUint8Array(): Uint8Array {\n    return this.bcsToBytes();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    // Note: we should not need to serialize the vector length, as it can be derived from the bitmap\n    serializer.serializeVector(this.signatures);\n    serializer.serializeBytes(this.bitmap);\n  }\n\n  static deserialize(deserializer: Deserializer): MultiSignature {\n    const bitmap = deserializer.deserializeBytes();\n    const nSignatures = bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);\n    const signatures: AnySignature[] = [];\n    for (let i = 0; i < nSignatures; i += 1) {\n      const signature = AnySignature.deserialize(deserializer);\n      signatures.push(signature);\n    }\n    return new MultiSignature({ signatures, bitmap });\n  }\n\n  // endregion\n}\n"],"mappings":"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","names":["bitCount","byte","n","MultiKey","_MultiKey","AccountPublicKey","args","publicKeys","signaturesRequired","publicKey","AnyPublicKey","AuthenticationKey","serializer","deserializer","keys","bits","firstBitInByte","bitmap","dupCheckSet","bit","idx","byteOffset","anyPublicKey","index","pk","_MultiSignature","Signature","signatures","signature","AnySignature","nSignatures","acc","i","MultiSignature"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/account.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Account as AccountModule} from \"../account\"\nimport { AccountAddress, PrivateKey, AccountAddressInput } from \"../core\";\nimport {\n  AccountData,\n  AnyNumber,\n  GetAccountCoinsDataResponse,\n  GetAccountCollectionsWithOwnedTokenResponse,\n  GetAccountOwnedObjectsResponse,\n  GetAccountOwnedTokensFromCollectionResponse,\n  GetAccountOwnedTokensQueryResponse,\n  LedgerVersionArg,\n  MoveModuleBytecode,\n  MoveResource,\n  MoveStructId,\n  OrderByArg,\n  PaginationArgs,\n  TokenStandardArg,\n  TransactionResponse,\n  WhereArg,\n} from \"../types\";\nimport {\n  deriveAccountFromPrivateKey,\n  getAccountCoinAmount,\n  getAccountCoinsCount,\n  getAccountCoinsData,\n  getAccountCollectionsWithOwnedTokens,\n  getAccountOwnedObjects,\n  getAccountOwnedTokens,\n  getAccountOwnedTokensFromCollectionAddress,\n  getAccountTokensCount,\n  getAccountTransactionsCount,\n  getInfo,\n  getModule,\n  getModules,\n  getResource,\n  getResources,\n  getTransactions,\n  lookupOriginalAccountAddress,\n} from \"../internal/account\";\nimport { APTOS_COIN, ProcessorType } from \"../utils/const\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { waitForIndexerOnVersion } from \"./utils\";\nimport { CurrentFungibleAssetBalancesBoolExp } from \"../types/generated/types\";\n\n/**\n * A class to query all `Account` related queries on Aptos.\n */\nexport class Account {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Queries the current state for an Aptos account given its account address\n   *\n   * @param args.accountAddress Aptos account address\n   *\n   * @returns The account data\n   *\n   * @example An example of the returned account\n   * ```\n   * {\n   *    sequence_number: \"1\",\n   *    authentication_key: \"0x5307b5f4bc67829097a8ba9b43dba3b88261eeccd1f709d9bde240fc100fbb69\"\n   * }\n   * ```\n   */\n  async getAccountInfo(args: { accountAddress: AccountAddressInput }): Promise<AccountData> {\n    return getInfo({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for all modules in an account given an account address\n   *\n   * Note: In order to get all account modules, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number module to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account modules\n   */\n\n  async getAccountModules(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs & LedgerVersionArg;\n  }): Promise<MoveModuleBytecode[]> {\n    return getModules({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for a specific account module given account address and module name\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.moduleName The name of the module\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account module\n   *\n   * @example\n   * const module = await aptos.getAccountModule({accountAddress:\"0x456\"})\n   * // An example of an account module response\n   * ```\n   * {\n   *    bytecode: \"0xa11ceb0b0600000006010002030206050807070f0d081c200\",\n   *    abi: { address: \"0x1\" }\n   * }\n   * ```\n   */\n  async getAccountModule(args: {\n    accountAddress: AccountAddressInput;\n    moduleName: string;\n    options?: LedgerVersionArg;\n  }): Promise<MoveModuleBytecode> {\n    return getModule({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries account transactions given an account address\n   *\n   * Note: In order to get all account transactions, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @example\n   * const transactions = await aptos.getAccountTransactions({accountAddress:\"0x456\"})\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number transaction to start returning results from\n   * @param args.options.limit The number of results to return\n   *\n   * @returns The account transactions\n   */\n  async getAccountTransactions(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs;\n  }): Promise<TransactionResponse[]> {\n    return getTransactions({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries all account resources given an account address\n   *\n   * Note: In order to get all account resources, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @example\n   * const resources = await aptos.getAccountResources({accountAddress:\"0x456\"})\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number resource to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   * @returns Account resources\n   */\n  async getAccountResources(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs & LedgerVersionArg;\n  }): Promise<MoveResource[]> {\n    return getResources({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries a specific account resource given account address and resource type. Note that the default is `any` in order\n   * to allow for ease of accessing properties of the object.\n   *\n   * @type The typed output of the resource\n   * @param args.accountAddress Aptos account address\n   * @param args.resourceType String representation of an on-chain Move struct type, i.e \"0x1::aptos_coin::AptosCoin\"\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account resource\n   *\n   * @example\n   * const resource = await aptos.getAccountResource({accountAddress:\"0x456\"})\n   *\n   */\n  async getAccountResource<T extends {} = any>(args: {\n    accountAddress: AccountAddressInput;\n    resourceType: MoveStructId;\n    options?: LedgerVersionArg;\n  }): Promise<T> {\n    return getResource<T>({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Looks up the account address for a given authentication key\n   *\n   * This handles both if the account's authentication key has been rotated or not.\n   *\n   * @example\n   * const accountAddress = await aptos.lookupOriginalAccountAddress({authenticationKey:account.accountAddress})\n   *\n   * @param args.authenticationKey The authentication key\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   * @returns Promise<AccountAddress> The accountAddress associated with the authentication key\n   */\n  async lookupOriginalAccountAddress(args: {\n    authenticationKey: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: LedgerVersionArg;\n  }): Promise<AccountAddress> {\n    return lookupOriginalAccountAddress({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries the current count of tokens owned by an account\n   *\n   * @example\n   * const tokensCount = await aptos.getAccountTokensCount({accountAddress:\"0x456\"})\n   *\n   * @param args.accountAddress The account address\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of tokens owned by the account\n   */\n  async getAccountTokensCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR,\n    });\n    return getAccountTokensCount({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the account's current owned tokens.\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @example\n   * const accountOwnedTokens = await aptos.getAccountOwnedTokens({accountAddress:\"0x456\"})\n   *\n   * @param args.accountAddress The account address we want to get the tokens for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number token to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Tokens array with the token data\n   */\n  async getAccountOwnedTokens(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;\n  }): Promise<GetAccountOwnedTokensQueryResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.TOKEN_V2_PROCESSOR,\n    });\n    return getAccountOwnedTokens({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries all current tokens of a specific collection that an account owns by the collection address\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @example\n   * const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({accountAddress:\"0x123\", collectionAddress:\"0x456\"})\n   *\n   * @param args.accountAddress The account address we want to get the tokens for\n   * @param args.collectionAddress The address of the collection being queried\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number token to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Tokens array with the token data\n   */\n  async getAccountOwnedTokensFromCollectionAddress(args: {\n    accountAddress: AccountAddressInput;\n    collectionAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;\n  }): Promise<GetAccountOwnedTokensFromCollectionResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.TOKEN_V2_PROCESSOR,\n    });\n    return getAccountOwnedTokensFromCollectionAddress({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries for all collections that an account currently has tokens for.\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @example\n   * const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the collections for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number collection to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Collections array with the collections data\n   */\n  async getAccountCollectionsWithOwnedTokens(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;\n  }): Promise<GetAccountCollectionsWithOwnedTokenResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.TOKEN_V2_PROCESSOR,\n    });\n    return getAccountCollectionsWithOwnedTokens({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the current count of transactions submitted by an account\n   *\n   * @example\n   * const accountTransactionsCount = await aptos.getAccountTransactionsCount({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of transactions made by an account\n   */\n  async getAccountTransactionsCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR,\n    });\n    return getAccountTransactionsCount({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries an account's coins data\n   *\n   * @example\n   * const accountCoinsData = await aptos.getAccountCoinsData({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the coins data for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.offset optional. The number coin to start returning results from\n   * @param args.options.limit optional. The number of results to return\n   * @param args.options.orderBy optional. The order to sort the coins by\n   * @param args.options.where optional. Filter the results by\n   * @returns Array with the coins data\n   */\n  async getAccountCoinsData(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs &\n      OrderByArg<GetAccountCoinsDataResponse[0]> &\n      WhereArg<CurrentFungibleAssetBalancesBoolExp>;\n  }): Promise<GetAccountCoinsDataResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getAccountCoinsData({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the current count of an account's coins aggregated\n   *\n   * @example\n   * const accountCoinsCount = await aptos.getAccountCoinsCount({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of the aggregated count of all account's coins\n   */\n  async getAccountCoinsCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getAccountCoinsCount({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries the account's APT amount\n   *\n   * @example\n   * const accountAPTAmount = await aptos.getAccountAPTAmount({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current amount of account's APT\n   */\n  async getAccountAPTAmount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    return this.getAccountCoinAmount({ coinType: APTOS_COIN, ...args });\n  }\n\n  /**\n   * Queries the account's coin amount by the coin type\n   *\n   * @example\n   * const accountCoinAmount = await aptos.getAccountCoinAmount({accountAddress:\"0x123\", coinType:\"0x1::aptos_coin::AptosCoin\"})\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.coinType The coin type to query\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current amount of account's coin\n   */\n  async getAccountCoinAmount(args: {\n    accountAddress: AccountAddressInput;\n    coinType: MoveStructId;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getAccountCoinAmount({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries an account's owned objects\n   *\n   * @example\n   * const accountOwnedObjects = await aptos.getAccountOwnedObjects({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the objects for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.offset The starting position to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the objects by\n   * @returns Objects array with the object data\n   */\n  async getAccountOwnedObjects(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;\n  }): Promise<GetAccountOwnedObjectsResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.DEFAULT,\n    });\n    return getAccountOwnedObjects({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Derives an account by providing a private key.\n   * This functions resolves the provided private key type and derives the public key from it.\n   *\n   * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and\n   * auth key using the SingleKey scheme locally.\n   *\n   * If the privateKey is a ED25519 type, it looks up the authentication key on chain, and uses it to resolve\n   * whether it is a Legacy ED25519 key or a Unified ED25519 key. It then derives the account based\n   * on that.\n   *\n   * @example\n   * const account = await aptos.deriveAccountFromPrivateKey({privateKey:new Ed25519PrivateKey(\"0x123\")})\n   *\n   * @param args.privateKey An account private key\n   * @returns Account type\n   */\n  async deriveAccountFromPrivateKey(args: { privateKey: PrivateKey }): Promise<AccountModule> {\n    return deriveAccountFromPrivateKey({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"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","names":["Account","config","args","getInfo","getModules","getModule","getTransactions","getResources","getResource","lookupOriginalAccountAddress","waitForIndexerOnVersion","getAccountTokensCount","getAccountOwnedTokens","getAccountOwnedTokensFromCollectionAddress","getAccountCollectionsWithOwnedTokens","getAccountTransactionsCount","getAccountCoinsData","getAccountCoinsCount","APTOS_COIN","getAccountCoinAmount","getAccountOwnedObjects","deriveAccountFromPrivateKey"]}

package/dist/esm/chunk-YPBHGSXY.mjs

@@ -1,2 +0,0 @@
-import{c as E}from"./chunk-EMFDNUP2.mjs";import{e as x,f as v}from"./chunk-OVXWFD2N.mjs";import{a as b}from"./chunk-2Z4N3GLA.mjs";import{a as l}from"./chunk-MX3YIOU5.mjs";import{a as K}from"./chunk-XJ3HRNOP.mjs";import{a as m,l as h,m as A}from"./chunk-ZUDMSBVZ.mjs";import{b as S}from"./chunk-3J2Q7O57.mjs";import{c as _}from"./chunk-S5HG2QUD.mjs";import{b as d}from"./chunk-52DBSOFA.mjs";import{b as f}from"./chunk-AOCNYMMX.mjs";import{jwtDecode as w}from"jwt-decode";import{bls12_381 as s}from"@noble/curves/bls12-381";var I="APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST";function C(e){return new TextEncoder().encode(e)}var j=s.G2.hashToCurve(C("APTOS_KEYLESS_PEPPER_PINKAS_VUF_SECRET_KEY_BASE"),{DST:I}).toAffine();function F(e){let{jwt:n,uidKey:r}=e,t=w(n),i=new d;i.serializeStr(t.iss),i.serializeStr(t.aud),i.serializeStr(t[r||"sub"]),i.serializeStr(r||"sub");let p=i.toUint8Array(),o=s.G1.hashToCurve(p,{DST:"APTOS_PEPPER_SERVICE_BLS12381_VUF_DST"}).toAffine();return s.G1.ProjectivePoint.fromAffine(o)}async function H(e){let{aptosConfig:n,pepperInput:r,pepperBase:t}=e,{data:i}=await E({aptosConfig:n,path:"vrf-pub-key",originMethod:"getPepper"}),p=s.G2.ProjectivePoint.fromHex(i.vrf_public_key_hex_string);return s.verifyShortSignature(t,r,p)}async function R(e){let{aptosConfig:n,jwt:r,ephemeralKeyPair:t,uidKey:i,verify:p}=e,{derivationPath:o}=e,a={jwt_b64:r,epk:t.publicKey.bcsToHex().toStringWithoutPrefix(),exp_date_secs:Number(t.expiryDateSecs),epk_blinder:f.fromHexInput(t.blinder).toStringWithoutPrefix(),uid_key:i},{data:c}=await x({aptosConfig:n,path:"fetch",body:a,originMethod:"getPepper",overrides:{WITH_CREDENTIALS:!1}}),P=f.fromHexInput(c.signature).toUint8Array();if(p&&!H({aptosConfig:n,pepperBase:P,pepperInput:F(e)}))throw new Error("Unable to verify");let u=s.pairing(s.G1.ProjectivePoint.fromHex(P),s.G2.ProjectivePoint.fromAffine(j));return o===void 0&&(o=_),l.fromDerivationPath(o,s.fields.Fp12.toBytes(u)).slice(0,31)}async function D(e){let{aptosConfig:n,jwt:r,ephemeralKeyPair:t,pepper:i,uidKey:p,extraFieldKey:o}=e,a=w(r),c;if(o){let T=a[o];c=`"${o}":"${T}",`}let P={jwt_b64:r,epk:t.publicKey.bcsToHex().toStringWithoutPrefix(),epk_blinder:f.fromHexInput(t.blinder).toStringWithoutPrefix(),exp_date_secs:Number(t.expiryDateSecs),exp_horizon_secs:m,pepper:f.fromHexInput(i).toStringWithoutPrefix(),extra_field:o,uid_key:p||"sub"},{data:u}=await v({aptosConfig:n,path:"prove",body:P,originMethod:"getProof",overrides:{WITH_CREDENTIALS:!1}}),y=u.proof,g=new h({a:y.a,b:y.b,c:y.c});return new A({proof:g,extraField:c,trainingWheelsSignature:S.fromHex(u.training_wheels_signature)})}async function z(e){let{fetchProofAsync:n}=e,{pepper:r,disableConnect:t}=e;if((r||t)&&(t=!0),r===void 0)r=await R(e);else if(f.fromHexInput(r).toUint8Array().length!==31)throw new Error("Pepper needs to be 31 bytes");let i=D({...e,pepper:r}),p=n?i:await i,o=l.fromJWTAndProof({...e,proofFetcherOrData:p,pepper:r});if(t===!0)return o;let a=o.deriveAptosConnectPublicKey(),c=new K({publicKeys:[o.publicKey,a],signaturesRequired:1});return new b({multiKey:c,signers:[o]})}export{R as a,D as b,z as c};
-//# sourceMappingURL=chunk-YPBHGSXY.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/keyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file contains the underlying implementations for exposed API surface in\n * the {@link api/oidb}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * faucet namespace and without having a dependency cycle error.\n */\nimport { jwtDecode } from \"jwt-decode\";\nimport { bls12_381 as bls } from \"@noble/curves/bls12-381\";\nimport { ProjPointType } from \"@noble/curves/abstract/weierstrass\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { getAptosPepperService, postAptosPepperService, postAptosProvingService } from \"../client\";\nimport {\n  APTOS_BIP44_DEFAULT_DERIVATION_PATH,\n  EPK_HORIZON_SECS,\n  EphemeralSignature,\n  Groth16Zkp,\n  Hex,\n  MultiKey,\n  SignedGroth16Signature,\n} from \"../core\";\nimport { HexInput } from \"../types\";\nimport { Serializer } from \"../bcs\";\nimport { EphemeralKeyPair, KeylessAccount, MultiKeyAccount } from \"../account\";\nimport { PepperFetchResponse, ProverResponse } from \"../types/keyless\";\n\nconst APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST = \"APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST\";\n\nfunction stringToUint8Array(str: string): Uint8Array {\n  const encoder = new TextEncoder();\n  return encoder.encode(str);\n}\n\nconst PINKAS_VUF_SECRET_KEY_BASE_AFFINE = bls.G2.hashToCurve(\n  stringToUint8Array(\"APTOS_KEYLESS_PEPPER_PINKAS_VUF_SECRET_KEY_BASE\"),\n  { DST: APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST },\n).toAffine();\n\nfunction getPepperInput(args: { jwt: string; uidKey?: string }): ProjPointType<bigint> {\n  const { jwt, uidKey } = args;\n  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);\n  const serializer = new Serializer();\n  serializer.serializeStr(jwtPayload.iss);\n  serializer.serializeStr(jwtPayload.aud);\n  serializer.serializeStr(jwtPayload[uidKey || \"sub\"]);\n  serializer.serializeStr(uidKey || \"sub\");\n  const serial = serializer.toUint8Array();\n  const msg = bls.G1.hashToCurve(serial, { DST: \"APTOS_PEPPER_SERVICE_BLS12381_VUF_DST\" }).toAffine();\n  const pp = bls.G1.ProjectivePoint.fromAffine(msg);\n  return pp;\n}\n\nasync function verifyPepperBase(args: {\n  aptosConfig: AptosConfig;\n  pepperInput: ProjPointType<bigint>;\n  pepperBase: Uint8Array;\n}): Promise<boolean> {\n  const { aptosConfig, pepperInput, pepperBase } = args;\n  const { data: pubKeyResponse } = await getAptosPepperService<any, { vrf_public_key_hex_string: string }>({\n    aptosConfig,\n    path: \"vrf-pub-key\",\n    originMethod: \"getPepper\",\n  });\n  const publicKeyFromService = bls.G2.ProjectivePoint.fromHex(pubKeyResponse.vrf_public_key_hex_string);\n  return bls.verifyShortSignature(pepperBase, pepperInput, publicKeyFromService);\n}\n\nexport async function getPepper(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  derivationPath?: string;\n  verify?: boolean;\n}): Promise<Uint8Array> {\n  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, verify } = args;\n  let { derivationPath } = args;\n\n  const body = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),\n    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    uid_key: uidKey,\n  };\n  // console.log(JSON.stringify(body));\n  const { data } = await postAptosPepperService<any, PepperFetchResponse>({\n    aptosConfig,\n    path: \"fetch\",\n    body,\n    originMethod: \"getPepper\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n  const pepperBase = Hex.fromHexInput(data.signature).toUint8Array();\n\n  if (verify) {\n    const pepperVerified = verifyPepperBase({ aptosConfig, pepperBase, pepperInput: getPepperInput(args) });\n    if (!pepperVerified) {\n      throw new Error(\"Unable to verify\");\n    }\n  }\n  // This takes the BLS VUF H(m)^sk and transforms it into a Pinkas VUF e(H(m), g_3^sk), where g_3 is the base of the secret key (computed pseudo-randomly via hash-to-curve).\n  // This gives us the freedom of either decentralizing the pepper service as a BLS-based MPC or on top of the validators, by reusing the Pinkas WVUF-based randomness infrastructure.\n  const newPepperBase = bls.pairing(\n    bls.G1.ProjectivePoint.fromHex(pepperBase),\n    bls.G2.ProjectivePoint.fromAffine(PINKAS_VUF_SECRET_KEY_BASE_AFFINE),\n  );\n\n  if (derivationPath === undefined) {\n    derivationPath = APTOS_BIP44_DEFAULT_DERIVATION_PATH;\n  }\n  const pepper = KeylessAccount.fromDerivationPath(derivationPath, bls.fields.Fp12.toBytes(newPepperBase));\n  return pepper.slice(0, 31);\n}\n\nexport async function getProof(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  pepper: HexInput;\n  uidKey?: string;\n  extraFieldKey?: string;\n}): Promise<SignedGroth16Signature> {\n  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;\n  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);\n  let extraField;\n  if (extraFieldKey) {\n    const extraFieldVal = jwtPayload[extraFieldKey];\n    extraField = `\"${extraFieldKey}\":\"${extraFieldVal}\",`;\n  }\n  const json = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),\n    exp_horizon_secs: EPK_HORIZON_SECS,\n    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),\n    extra_field: extraFieldKey,\n    uid_key: uidKey || \"sub\",\n  };\n\n  const { data } = await postAptosProvingService<any, ProverResponse>({\n    aptosConfig,\n    path: \"prove\",\n    body: json,\n    originMethod: \"getProof\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n\n  const proofPoints = data.proof;\n  const proof = new Groth16Zkp({\n    a: proofPoints.a,\n    b: proofPoints.b,\n    c: proofPoints.c,\n  });\n\n  const signedProof = new SignedGroth16Signature({\n    proof,\n    extraField,\n    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),\n  });\n  return signedProof;\n}\n\nexport async function deriveKeylessAccount(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  pepper?: HexInput;\n  extraFieldKey?: string;\n  disableConnect?: boolean;\n  fetchProofAsync?: boolean;\n}): Promise<KeylessAccount | MultiKeyAccount> {\n  const { fetchProofAsync } = args;\n  let { pepper, disableConnect } = args;\n\n  if (pepper || disableConnect) {\n    disableConnect = true;\n  }\n  if (pepper === undefined) {\n    pepper = await getPepper(args);\n  } else if (Hex.fromHexInput(pepper).toUint8Array().length !== 31) {\n    throw new Error(\"Pepper needs to be 31 bytes\");\n  }\n\n  const proofPromise = getProof({ ...args, pepper });\n  const proof = fetchProofAsync ? proofPromise : await proofPromise;\n\n  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proofFetcherOrData: proof, pepper });\n\n  if (disableConnect === true) {\n    return keylessAccount;\n  }\n\n  const aptosConnectPublicKey = keylessAccount.deriveAptosConnectPublicKey();\n\n  const multiKey = new MultiKey({\n    publicKeys: [keylessAccount.publicKey, aptosConnectPublicKey],\n    signaturesRequired: 1,\n  });\n  return new MultiKeyAccount({ multiKey, signers: [keylessAccount] });\n}\n"],"mappings":"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","names":["jwtDecode","bls","APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST","stringToUint8Array","str","PINKAS_VUF_SECRET_KEY_BASE_AFFINE","bls","getPepperInput","args","jwt","uidKey","jwtPayload","jwtDecode","serializer","Serializer","serial","msg","verifyPepperBase","aptosConfig","pepperInput","pepperBase","pubKeyResponse","getAptosPepperService","publicKeyFromService","getPepper","ephemeralKeyPair","verify","derivationPath","body","Hex","data","postAptosPepperService","newPepperBase","APTOS_BIP44_DEFAULT_DERIVATION_PATH","KeylessAccount","getProof","pepper","extraFieldKey","extraField","extraFieldVal","json","EPK_HORIZON_SECS","postAptosProvingService","proofPoints","proof","Groth16Zkp","SignedGroth16Signature","EphemeralSignature","deriveKeylessAccount","fetchProofAsync","disableConnect","proofPromise","keylessAccount","aptosConnectPublicKey","multiKey","MultiKey","MultiKeyAccount"]}

package/dist/esm/chunk-YU7DNMEA.mjs

@@ -1,2 +0,0 @@
-import{a as g,c as t,d as s}from"./chunk-ED6PYTNG.mjs";import{f as A,g as T}from"./chunk-2HXKDHMA.mjs";import{sha3_256 as y}from"@noble/hashes/sha3";function f(n){return n.feePayerAddress?new s(n.rawTransaction,n.secondarySignerAddresses??[],n.feePayerAddress):n.secondarySignerAddresses?new t(n.rawTransaction,n.secondarySignerAddresses):n.rawTransaction}function i(n,e){let o=y.create();o.update(`APTOS::${e}`);let r=o.digest(),c=n,a=new Uint8Array(r.length+c.length);return a.set(r),a.set(c,r.length),a}function S(n){return i(n.bcsToBytes(),n.constructor.name)}function p(n){let e=f(n);if(e instanceof g)return i(e.bcsToBytes(),A);if(e instanceof t||e instanceof s)return i(e.bcsToBytes(),T);throw new Error(`Unknown transaction type to sign on: ${e}`)}export{f as a,i as b,S as c,p as d};
-//# sourceMappingURL=chunk-YU7DNMEA.mjs.map

package/dist/esm/chunk-YU7DNMEA.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 transaction creation lifecycle.\n * It holds different operations to generate a transaction payload, a raw transaction,\n * and a signed transaction that can be simulated, signed and submitted to chain.\n */\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport {\n  RAW_TRANSACTION_SALT,\n  RAW_TRANSACTION_WITH_DATA_SALT,\n} from \"../../utils/const\";\nimport {\n  FeePayerRawTransaction,\n  MultiAgentRawTransaction,\n  RawTransaction,\n} from \"../instances\";\nimport {\n  AnyRawTransaction, AnyRawTransactionInstance,\n} from \"../types\";\nimport { Serializable } from \"../../bcs\";\n\n/**\n * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction\n *\n * @param transaction A aptos transaction type\n *\n * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction\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\nexport function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array {\n  const hash = sha3Hash.create();\n\n  hash.update(`APTOS::${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\nexport function generateSigningMessageForSerializable(obj: Serializable): Uint8Array {\n  return generateSigningMessage(obj.bcsToBytes(), obj.constructor.name);\n}\n\nexport function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array {\n  const rawTxn = deriveTransactionType(transaction);\n  if (rawTxn instanceof RawTransaction) {\n    return generateSigningMessage(rawTxn.bcsToBytes(),RAW_TRANSACTION_SALT);\n  } if (rawTxn instanceof MultiAgentRawTransaction || rawTxn instanceof FeePayerRawTransaction) {\n    return generateSigningMessage(rawTxn.bcsToBytes(),RAW_TRANSACTION_WITH_DATA_SALT);\n  }\n  throw new Error(`Unknown transaction type to sign on: ${rawTxn}`);\n}\n\n"],"mappings":"uGAQA,OAAS,YAAYA,MAAgB,qBAsB9B,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,CAEO,SAASG,EAAuBC,EAAmBC,EAAqC,CAC7F,IAAMC,EAAOC,EAAS,OAAO,EAE7BD,EAAK,OAAO,UAAUD,CAAe,EAAE,EAEvC,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,EAA+B,CACnF,OAAOT,EAAuBS,EAAI,WAAW,EAAGA,EAAI,YAAY,IAAI,CACtE,CAEO,SAASC,EAAqCb,EAA4C,CAC/F,IAAMc,EAASf,EAAsBC,CAAW,EAChD,GAAIc,aAAkBC,EACpB,OAAOZ,EAAuBW,EAAO,WAAW,EAAEE,CAAoB,EACtE,GAAIF,aAAkBZ,GAA4BY,aAAkBb,EACpE,OAAOE,EAAuBW,EAAO,WAAW,EAAEG,CAA8B,EAElF,MAAM,IAAI,MAAM,wCAAwCH,CAAM,EAAE,CAClE","names":["sha3Hash","deriveTransactionType","transaction","FeePayerRawTransaction","MultiAgentRawTransaction","generateSigningMessage","bytes","domainSeparator","hash","sha3Hash","prefix","body","mergedArray","generateSigningMessageForSerializable","obj","generateSigningMessageForTransaction","rawTxn","RawTransaction","RAW_TRANSACTION_SALT","RAW_TRANSACTION_WITH_DATA_SALT"]}

package/dist/esm/chunk-ZUDMSBVZ.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\nimport { AccountPublicKey, PublicKey } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { Deserializer, Serializable, Serializer } from \"../../bcs\";\nimport { Hex } from \"../hex\";\nimport { HexInput, EphemeralCertificate, AnyPublicKeyVariant, SigningScheme } from \"../../types\";\nimport { EphemeralPublicKey, EphemeralSignature } from \"./ephemeral\";\nimport { bigIntToBytesLE, bytesToBigIntLE, hashASCIIStrToField, poseidonHash } from \"./poseidon\";\nimport { AuthenticationKey } from \"../authenticationKey\";\n\nexport const EPK_HORIZON_SECS = 10000000;\nexport const MAX_AUD_VAL_BYTES = 120;\nexport const MAX_UID_KEY_BYTES = 30;\nexport const MAX_UID_VAL_BYTES = 330;\nexport const MAX_ISS_VAL_BYTES = 120;\nexport const MAX_EXTRA_FIELD_BYTES = 350;\nexport const MAX_JWT_HEADER_B64_BYTES = 300;\nexport const MAX_COMMITED_EPK_BYTES = 93;\n\n/**\n * Represents the KeylessPublicKey public key\n *\n * KeylessPublicKey authentication key is represented in the SDK as `AnyPublicKey`.\n */\nexport class KeylessPublicKey extends AccountPublicKey {\n  static readonly ADDRESS_SEED_LENGTH: number = 32;\n\n  readonly iss: string;\n\n  readonly addressSeed: Uint8Array;\n\n  constructor(iss: string, addressSeed: HexInput) {\n    super();\n    const addressSeedBytes = Hex.fromHexInput(addressSeed).toUint8Array();\n    if (addressSeedBytes.length !== KeylessPublicKey.ADDRESS_SEED_LENGTH) {\n      throw new Error(`Address seed length in bytes should be ${KeylessPublicKey.ADDRESS_SEED_LENGTH}`);\n    }\n\n    this.iss = iss;\n    this.addressSeed = addressSeedBytes;\n  }\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   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   */\n  toUint8Array(): Uint8Array {\n    return this.bcsToBytes();\n  }\n\n  /**\n   * Get the public key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the public key\n   */\n  toString(): string {\n    return Hex.fromHexInput(this.toUint8Array()).toString();\n  }\n\n  /**\n   * Verifies a signed data with a public key\n   *\n   * @param args.message message\n   * @param args.signature The signature\n   * @returns true if the signature is valid\n   */\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {\n    // TODO\n    return true;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.iss);\n    serializer.serializeBytes(this.addressSeed);\n  }\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  static load(deserializer: Deserializer): KeylessPublicKey {\n    const iss = deserializer.deserializeStr();\n    const addressSeed = deserializer.deserializeBytes();\n    return new KeylessPublicKey(iss, addressSeed);\n  }\n\n  static isPublicKey(publicKey: PublicKey): publicKey is KeylessPublicKey {\n    return publicKey instanceof KeylessPublicKey;\n  }\n\n  static create(args: {\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n  }): KeylessPublicKey {\n    computeAddressSeed(args);\n    return new KeylessPublicKey(args.iss, computeAddressSeed(args));\n  }\n}\n\nexport function computeAddressSeed(args: {\n  uidKey: string;\n  uidVal: string;\n  aud: string;\n  pepper: HexInput;\n}): Uint8Array {\n  const { uidKey, uidVal, aud, pepper } = args;\n\n  const fields = [\n    bytesToBigIntLE(Hex.fromHexInput(pepper).toUint8Array()),\n    hashASCIIStrToField(aud, MAX_AUD_VAL_BYTES),\n    hashASCIIStrToField(uidVal, MAX_UID_VAL_BYTES),\n    hashASCIIStrToField(uidKey, MAX_UID_KEY_BYTES),\n  ];\n\n  return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ADDRESS_SEED_LENGTH);\n}\n\nexport class OpenIdSignatureOrZkProof extends Signature {\n  public readonly signature: Signature;\n\n  constructor(signature: Signature) {\n    super();\n    this.signature = signature;\n  }\n\n  /**\n   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   */\n  toUint8Array(): Uint8Array {\n    return this.signature.toUint8Array();\n  }\n\n  /**\n   * Get the public key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the public key\n   */\n  toString(): string {\n    return this.signature.toString();\n  }\n\n  serialize(serializer: Serializer): void {\n    if (this.signature instanceof OpenIdSignature) {\n      serializer.serializeU32AsUleb128(EphemeralCertificate.OpenIdSignature);\n      this.signature.serialize(serializer);\n    } else if (this.signature instanceof SignedGroth16Signature) {\n      serializer.serializeU32AsUleb128(EphemeralCertificate.ZkProof);\n      this.signature.serialize(serializer);\n    } else {\n      throw new Error(\"Not a valid OIDB signature\");\n    }\n  }\n\n  static deserialize(deserializer: Deserializer): OpenIdSignatureOrZkProof {\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case EphemeralCertificate.ZkProof:\n        return new OpenIdSignatureOrZkProof(SignedGroth16Signature.load(deserializer));\n      case EphemeralCertificate.OpenIdSignature:\n        return new OpenIdSignatureOrZkProof(OpenIdSignature.load(deserializer));\n      default:\n        throw new Error(`Unknown variant index for EphemeralCertificate: ${index}`);\n    }\n  }\n}\n\nexport class Groth16Zkp extends Serializable {\n  a: Uint8Array;\n\n  b: Uint8Array;\n\n  c: Uint8Array;\n\n  constructor(args: { a: HexInput; b: HexInput; c: HexInput }) {\n    super();\n    const { a, b, c } = args;\n    this.a = Hex.fromHexInput(a).toUint8Array();\n    this.b = Hex.fromHexInput(b).toUint8Array();\n    this.c = Hex.fromHexInput(c).toUint8Array();\n  }\n\n  toUint8Array(): Uint8Array {\n    const serializer = new Serializer();\n    this.serialize(serializer);\n    return serializer.toUint8Array();\n  }\n\n  serialize(serializer: Serializer): void {\n    // There's currently only one variant\n    serializer.serializeU32AsUleb128(0);\n    serializer.serializeFixedBytes(this.a);\n    serializer.serializeFixedBytes(this.b);\n    serializer.serializeFixedBytes(this.c);\n  }\n\n  static deserialize(deserializer: Deserializer): Groth16Zkp {\n    // Ignored, as there's currently only one possible ZKP variant\n    deserializer.deserializeUleb128AsU32();\n    const a = deserializer.deserializeFixedBytes(32);\n    const b = deserializer.deserializeFixedBytes(64);\n    const c = deserializer.deserializeFixedBytes(32);\n    return new Groth16Zkp({ a, b, c });\n  }\n}\n\nexport class SignedGroth16Signature extends Signature {\n  readonly proof: Groth16Zkp;\n\n  readonly expHorizonSecs: bigint;\n\n  readonly extraField?: string;\n\n  readonly overrideAudVal?: string;\n\n  readonly trainingWheelsSignature?: EphemeralSignature;\n\n  constructor(args: {\n    proof: Groth16Zkp;\n    expHorizonSecs?: bigint;\n    extraField?: string;\n    overrideAudVal?: string;\n    trainingWheelsSignature?: EphemeralSignature;\n  }) {\n    super();\n    const { proof, expHorizonSecs = BigInt(EPK_HORIZON_SECS), 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   * Get the signature in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the signature\n   */\n  toUint8Array(): Uint8Array {\n    const serializer = new Serializer();\n    this.serialize(serializer);\n    return serializer.toUint8Array();\n  }\n\n  /**\n   * Get the signature as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the signature\n   */\n  toString(): string {\n    return this.toString();\n  }\n\n  serialize(serializer: Serializer): void {\n    this.proof.serialize(serializer);\n    serializer.serializeU64(this.expHorizonSecs);\n    serializer.serializeOptionStr(this.extraField);\n    serializer.serializeOptionStr(this.overrideAudVal);\n    serializer.serializeOption(this.trainingWheelsSignature);\n  }\n\n  static deserialize(deserializer: Deserializer): SignedGroth16Signature {\n    const proof = Groth16Zkp.deserialize(deserializer);\n    const expHorizonSecs = deserializer.deserializeU64();\n    const hasExtraField = deserializer.deserializeUleb128AsU32();\n    const extraField = hasExtraField ? deserializer.deserializeStr() : undefined;\n    const hasOverrideAudVal = deserializer.deserializeUleb128AsU32();\n    const overrideAudVal = hasOverrideAudVal ? deserializer.deserializeStr() : undefined;\n    const [trainingWheelsSignature] = deserializer.deserializeVector(EphemeralSignature);\n    return new SignedGroth16Signature({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });\n  }\n\n  static load(deserializer: Deserializer): SignedGroth16Signature {\n    const proof = Groth16Zkp.deserialize(deserializer);\n    const expHorizonSecs = deserializer.deserializeU64();\n    const hasExtraField = deserializer.deserializeUleb128AsU32();\n    const extraField = hasExtraField ? deserializer.deserializeStr() : undefined;\n    const hasOverrideAudVal = deserializer.deserializeUleb128AsU32();\n    const overrideAudVal = hasOverrideAudVal ? deserializer.deserializeStr() : undefined;\n    const [trainingWheelsSignature] = deserializer.deserializeVector(EphemeralSignature);\n    return new SignedGroth16Signature({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });\n  }\n\n  // static isSignature(signature: Signature): signature is OpenIdSignature {\n  //   return signature instanceof OpenIdSignature;\n  // }\n}\n\n/**\n * A OpenId signature which contains the private inputs to an OIDB proof.\n */\nexport class OpenIdSignature extends Signature {\n  readonly jwtSignature: string;\n\n  readonly jwtPayloadJson: string;\n\n  readonly uidKey: string;\n\n  readonly epkBlinder: Uint8Array;\n\n  readonly pepper: Uint8Array;\n\n  readonly overrideAudValue?: string;\n\n  /**\n   * Create a new Signature instance from a Uint8Array or String.\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   */\n  constructor(args: {\n    jwtSignature: string;\n    jwtPayloadJson: string;\n    uidKey?: string;\n    epkBlinder: Uint8Array;\n    pepper: Uint8Array;\n    overrideAudValue?: string;\n  }) {\n    super();\n    const { jwtSignature, uidKey, jwtPayloadJson, epkBlinder, pepper, overrideAudValue } = args;\n    this.jwtSignature = jwtSignature;\n    this.jwtPayloadJson = jwtPayloadJson;\n    this.uidKey = uidKey ?? \"sub\";\n    this.epkBlinder = epkBlinder;\n    this.pepper = pepper;\n    this.overrideAudValue = overrideAudValue;\n  }\n\n  /**\n   * Get the signature in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the signature\n   */\n  toUint8Array(): Uint8Array {\n    // const textEncoder = new TextEncoder();\n    // const jwtSigBytes = textEncoder.encode(this.jwtSignature);\n    // const jwtPayloadJsonBytes = textEncoder.encode(this.jwtPayloadJson);\n    // const uidKeyBytes = textEncoder.encode(this.jwtSignature);\n    // const uidKeyBytes = textEncoder.encode(this.jwtSignature);\n\n    return this.epkBlinder;\n  }\n\n  /**\n   * Get the signature as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the signature\n   */\n  toString(): string {\n    return this.toString();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.jwtSignature);\n    serializer.serializeStr(this.jwtPayloadJson);\n    serializer.serializeStr(this.uidKey);\n    serializer.serializeFixedBytes(this.epkBlinder);\n    serializer.serializeFixedBytes(this.pepper);\n    serializer.serializeOptionStr(this.overrideAudValue);\n  }\n\n  static deserialize(deserializer: Deserializer): OpenIdSignature {\n    const jwtSignature = deserializer.deserializeStr();\n    const jwtPayloadJson = deserializer.deserializeStr();\n    const uidKey = deserializer.deserializeStr();\n    const epkBlinder = deserializer.deserializeFixedBytes(31);\n    const pepper = deserializer.deserializeFixedBytes(31);\n    const hasOverrideAudValue = deserializer.deserializeUleb128AsU32();\n    const overrideAudValue = hasOverrideAudValue ? deserializer.deserializeStr() : undefined;\n    return new OpenIdSignature({ jwtSignature, jwtPayloadJson, uidKey, epkBlinder, pepper, overrideAudValue });\n  }\n\n  static load(deserializer: Deserializer): OpenIdSignature {\n    const jwtSignature = deserializer.deserializeStr();\n    const jwtPayloadJson = deserializer.deserializeStr();\n    const uidKey = deserializer.deserializeStr();\n    const epkBlinder = deserializer.deserializeFixedBytes(31);\n    const pepper = deserializer.deserializeFixedBytes(31);\n    const hasOverrideAudValue = deserializer.deserializeUleb128AsU32();\n    const overrideAudValue = hasOverrideAudValue ? deserializer.deserializeStr() : undefined;\n    return new OpenIdSignature({ jwtSignature, jwtPayloadJson, uidKey, epkBlinder, pepper, overrideAudValue });\n  }\n\n  static isSignature(signature: Signature): signature is OpenIdSignature {\n    return signature instanceof OpenIdSignature;\n  }\n}\n\n/**\n * A signature of a message signed via OIDC that uses proofs or the jwt token to authenticate.\n */\nexport class KeylessSignature extends Signature {\n  readonly openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;\n\n  readonly jwtHeader: string;\n\n  readonly expiryDateSecs: bigint;\n\n  readonly ephemeralPublicKey: EphemeralPublicKey;\n\n  readonly ephemeralSignature: EphemeralSignature;\n\n  /**\n   * Create a new Signature instance from a Uint8Array or String.\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   */\n  constructor(args: {\n    jwtHeader: string;\n    openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;\n    expiryDateSecs: bigint;\n    ephemeralPublicKey: EphemeralPublicKey;\n    ephemeralSignature: EphemeralSignature;\n  }) {\n    super();\n    const { jwtHeader, openIdSignatureOrZkProof, expiryDateSecs, ephemeralPublicKey, ephemeralSignature } = args;\n    this.jwtHeader = jwtHeader;\n    this.openIdSignatureOrZkProof = openIdSignatureOrZkProof;\n    this.expiryDateSecs = expiryDateSecs;\n    this.ephemeralPublicKey = ephemeralPublicKey;\n    this.ephemeralSignature = ephemeralSignature;\n  }\n\n  /**\n   * Get the signature in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the signature\n   */\n  toUint8Array(): Uint8Array {\n    return this.ephemeralSignature.toUint8Array();\n  }\n\n  /**\n   * Get the signature as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the signature\n   */\n  toString(): string {\n    return this.toString();\n  }\n\n  serialize(serializer: Serializer): void {\n    this.openIdSignatureOrZkProof.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 openIdSignatureOrZkProof = OpenIdSignatureOrZkProof.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,\n      openIdSignatureOrZkProof,\n      ephemeralPublicKey,\n      ephemeralSignature,\n    });\n  }\n\n  static load(deserializer: Deserializer): KeylessSignature {\n    const jwtHeader = deserializer.deserializeStr();\n    const expiryDateSecs = deserializer.deserializeU64();\n    const openIdSignatureOrZkProof = OpenIdSignatureOrZkProof.deserialize(deserializer);\n    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);\n    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);\n    return new KeylessSignature({\n      jwtHeader,\n      expiryDateSecs,\n      openIdSignatureOrZkProof,\n      ephemeralPublicKey,\n      ephemeralSignature,\n    });\n  }\n\n  static isSignature(signature: Signature): signature is KeylessSignature {\n    return signature instanceof KeylessSignature;\n  }\n}\n"],"mappings":"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","names":["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","addressSeed","addressSeedBytes","Hex","serializer","Serializer","AuthenticationKey","args","deserializer","publicKey","computeAddressSeed","KeylessPublicKey","uidKey","uidVal","aud","pepper","fields","bytesToBigIntLE","hashASCIIStrToField","bigIntToBytesLE","poseidonHash","OpenIdSignatureOrZkProof","_OpenIdSignatureOrZkProof","Signature","signature","OpenIdSignature","SignedGroth16Signature","index","Groth16Zkp","_Groth16Zkp","Serializable","a","b","c","_SignedGroth16Signature","proof","expHorizonSecs","trainingWheelsSignature","extraField","overrideAudVal","EphemeralSignature","_OpenIdSignature","jwtSignature","jwtPayloadJson","epkBlinder","overrideAudValue","KeylessSignature","_KeylessSignature","jwtHeader","openIdSignatureOrZkProof","expiryDateSecs","ephemeralPublicKey","ephemeralSignature","EphemeralPublicKey"]}