@aptos-labs/ts-sdk 1.29.0 → 1.30.0

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/staking.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/staking}. 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 */\n\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { AccountAddress, AccountAddressInput } from \"../core\";\nimport { GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, OrderByArg } from \"../types\";\nimport { GetDelegatedStakingActivitiesQuery, GetNumberOfDelegatorsQuery } from \"../types/generated/operations\";\nimport { GetDelegatedStakingActivities, GetNumberOfDelegators } from \"../types/generated/queries\";\nimport { queryIndexer } from \"./general\";\n\nexport async function getNumberOfDelegators(args: {\n  aptosConfig: AptosConfig;\n  poolAddress: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, poolAddress } = args;\n  const address = AccountAddress.from(poolAddress).toStringLong();\n  const query = {\n    query: GetNumberOfDelegators,\n    variables: { where_condition: { pool_address: { _eq: address } } },\n  };\n  const data = await queryIndexer<GetNumberOfDelegatorsQuery>({ aptosConfig, query });\n\n  // commonjs (aka cjs) doesnt handle Nullish Coalescing for some reason\n  // might be because of how ts infer the graphql generated scheme type\n  return data.num_active_delegator_per_pool[0] ? data.num_active_delegator_per_pool[0].num_active_delegator : 0;\n}\n\nexport async function getNumberOfDelegatorsForAllPools(args: {\n  aptosConfig: AptosConfig;\n  options?: OrderByArg<GetNumberOfDelegatorsResponse[0]>;\n}): Promise<GetNumberOfDelegatorsResponse> {\n  const { aptosConfig, options } = args;\n  const query = {\n    query: GetNumberOfDelegators,\n    variables: { order_by: options?.orderBy },\n  };\n  const data = await queryIndexer<GetNumberOfDelegatorsQuery>({\n    aptosConfig,\n    query,\n  });\n  return data.num_active_delegator_per_pool;\n}\n\nexport async function getDelegatedStakingActivities(args: {\n  aptosConfig: AptosConfig;\n  delegatorAddress: AccountAddressInput;\n  poolAddress: AccountAddressInput;\n}): Promise<GetDelegatedStakingActivitiesResponse> {\n  const { aptosConfig, delegatorAddress, poolAddress } = args;\n  const query = {\n    query: GetDelegatedStakingActivities,\n    variables: {\n      delegatorAddress: AccountAddress.from(delegatorAddress).toStringLong(),\n      poolAddress: AccountAddress.from(poolAddress).toStringLong(),\n    },\n  };\n  const data = await queryIndexer<GetDelegatedStakingActivitiesQuery>({ aptosConfig, query });\n  return data.delegated_staking_activities;\n}\n"],"mappings":"kIAiBA,eAAsBA,EAAsBC,EAGxB,CAClB,GAAM,CAAE,YAAAC,EAAa,YAAAC,CAAY,EAAIF,EAC/BG,EAAUC,EAAe,KAAKF,CAAW,EAAE,aAAa,EAKxDG,EAAO,MAAMC,EAAyC,CAAE,YAAAL,EAAa,MAJ7D,CACZ,MAAOM,EACP,UAAW,CAAE,gBAAiB,CAAE,aAAc,CAAE,IAAKJ,CAAQ,CAAE,CAAE,CACnE,CACiF,CAAC,EAIlF,OAAOE,EAAK,8BAA8B,CAAC,EAAIA,EAAK,8BAA8B,CAAC,EAAE,qBAAuB,CAC9G,CAEA,eAAsBG,EAAiCR,EAGZ,CACzC,GAAM,CAAE,YAAAC,EAAa,QAAAQ,CAAQ,EAAIT,EAC3BU,EAAQ,CACZ,MAAOH,EACP,UAAW,CAAE,SAAUE,GAAS,OAAQ,CAC1C,EAKA,OAJa,MAAMH,EAAyC,CAC1D,YAAAL,EACA,MAAAS,CACF,CAAC,GACW,6BACd,CAEA,eAAsBC,EAA8BX,EAID,CACjD,GAAM,CAAE,YAAAC,EAAa,iBAAAW,EAAkB,YAAAV,CAAY,EAAIF,EACjDU,EAAQ,CACZ,MAAOG,EACP,UAAW,CACT,iBAAkBT,EAAe,KAAKQ,CAAgB,EAAE,aAAa,EACrE,YAAaR,EAAe,KAAKF,CAAW,EAAE,aAAa,CAC7D,CACF,EAEA,OADa,MAAMI,EAAiD,CAAE,YAAAL,EAAa,MAAAS,CAAM,CAAC,GAC9E,4BACd","names":["getNumberOfDelegators","args","aptosConfig","poolAddress","address","AccountAddress","data","queryIndexer","GetNumberOfDelegators","getNumberOfDelegatorsForAllPools","options","query","getDelegatedStakingActivities","delegatorAddress","GetDelegatedStakingActivities"]}

package/dist/esm/chunk-OMV7445F.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/keyless}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * keyless namespace and without having a dependency cycle error.\n */\nimport { jwtDecode, JwtPayload } from \"jwt-decode\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { postAptosPepperService, postAptosProvingService } from \"../client\";\nimport {\n  AccountAddressInput,\n  EphemeralSignature,\n  Groth16Zkp,\n  Hex,\n  KeylessPublicKey,\n  ZeroKnowledgeSig,\n  ZkProof,\n  getKeylessConfig,\n} from \"../core\";\nimport { HexInput, ZkpVariant } from \"../types\";\nimport { Account, EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from \"../account\";\nimport { PepperFetchRequest, PepperFetchResponse, ProverRequest, ProverResponse } from \"../types/keyless\";\nimport { lookupOriginalAccountAddress } from \"./account\";\nimport { FederatedKeylessPublicKey } from \"../core/crypto/federatedKeyless\";\nimport { FederatedKeylessAccount } from \"../account/FederatedKeylessAccount\";\nimport { MoveVector } from \"../bcs\";\nimport { generateTransaction } from \"./transactionSubmission\";\nimport { SimpleTransaction } from \"../transactions\";\n\nexport async function getPepper(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  derivationPath?: string;\n}): Promise<Uint8Array> {\n  const { aptosConfig, jwt, ephemeralKeyPair, uidKey = \"sub\", derivationPath } = args;\n\n  const body = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),\n    exp_date_secs: ephemeralKeyPair.expiryDateSecs,\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    uid_key: uidKey,\n    derivation_path: derivationPath,\n  };\n  const { data } = await postAptosPepperService<PepperFetchRequest, PepperFetchResponse>({\n    aptosConfig,\n    path: \"fetch\",\n    body,\n    originMethod: \"getPepper\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n  return Hex.fromHexInput(data.pepper).toUint8Array();\n}\n\nexport async function getProof(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  pepper?: HexInput;\n  uidKey?: string;\n}): Promise<ZeroKnowledgeSig> {\n  const { aptosConfig, jwt, ephemeralKeyPair, pepper = await getPepper(args), uidKey = \"sub\" } = args;\n  if (Hex.fromHexInput(pepper).toUint8Array().length !== KeylessAccount.PEPPER_LENGTH) {\n    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);\n  }\n  const { maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });\n  const decodedJwt = jwtDecode<JwtPayload>(jwt);\n  if (typeof decodedJwt.iat !== \"number\") {\n    throw new Error(\"iat was not found\");\n  }\n  if (maxExpHorizonSecs < ephemeralKeyPair.expiryDateSecs - decodedJwt.iat) {\n    throw Error(`The EphemeralKeyPair is too long lived.  It's lifespan must be less than ${maxExpHorizonSecs}`);\n  }\n  const json = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    exp_date_secs: ephemeralKeyPair.expiryDateSecs,\n    exp_horizon_secs: maxExpHorizonSecs,\n    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),\n    uid_key: uidKey,\n  };\n\n  const { data } = await postAptosProvingService<ProverRequest, 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 groth16Zkp = new Groth16Zkp({\n    a: proofPoints.a,\n    b: proofPoints.b,\n    c: proofPoints.c,\n  });\n\n  const signedProof = new ZeroKnowledgeSig({\n    proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),\n    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),\n    expHorizonSecs: maxExpHorizonSecs,\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  proofFetchCallback?: ProofFetchCallback;\n}): Promise<KeylessAccount>;\n\nexport async function deriveKeylessAccount(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  jwkAddress: AccountAddressInput;\n  uidKey?: string;\n  pepper?: HexInput;\n  proofFetchCallback?: ProofFetchCallback;\n}): Promise<FederatedKeylessAccount>;\n\nexport async function deriveKeylessAccount(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  jwkAddress?: AccountAddressInput;\n  uidKey?: string;\n  pepper?: HexInput;\n  proofFetchCallback?: ProofFetchCallback;\n}): Promise<KeylessAccount | FederatedKeylessAccount> {\n  const { aptosConfig, jwt, jwkAddress, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;\n  const proofPromise = getProof({ ...args, pepper });\n  // If a callback is provided, pass in the proof as a promise to KeylessAccount.create.  This will make the proof be fetched in the\n  // background and the callback will handle the outcome of the fetch.  This allows the developer to not have to block on the proof fetch\n  // allowing for faster rendering of UX.\n  //\n  // If no callback is provided, the just await the proof fetch and continue syncronously.\n  const proof = proofFetchCallback ? proofPromise : await proofPromise;\n\n  // Look up the original address to handle key rotations and then instantiate the account.\n  if (jwkAddress !== undefined) {\n    const publicKey = FederatedKeylessPublicKey.fromJwtAndPepper({ jwt, pepper, jwkAddress, uidKey });\n    const address = await lookupOriginalAccountAddress({\n      aptosConfig,\n      authenticationKey: publicKey.authKey().derivedAddress(),\n    });\n\n    return FederatedKeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback, jwkAddress });\n  }\n\n  const publicKey = KeylessPublicKey.fromJwtAndPepper({ jwt, pepper, uidKey });\n  const address = await lookupOriginalAccountAddress({\n    aptosConfig,\n    authenticationKey: publicKey.authKey().derivedAddress(),\n  });\n  return KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback });\n}\n\ninterface JWK {\n  kty: string; // Key type\n  kid: string; // Key ID\n  alg: string; // Algorithm used with the key\n  n: string; // Modulus (for RSA keys)\n  e: string; // Exponent (for RSA keys)\n}\n\ninterface JWKS {\n  keys: JWK[];\n}\n\nexport async function updateFederatedKeylessJwkSetTransaction(args: {\n  aptosConfig: AptosConfig;\n  sender: Account;\n  iss: string;\n  jwksUrl?: string;\n}): Promise<SimpleTransaction> {\n  const { aptosConfig, sender, iss } = args;\n  const jwksUrl = args.jwksUrl ?? (iss.endsWith(\"/\") ? `${iss}.well-known/jwks.json` : `${iss}/.well-known/jwks.json`);\n  const response = await fetch(jwksUrl);\n  if (!response.ok) {\n    throw new Error(`Failed to fetch JWKS: ${response.status} ${response.statusText}`);\n  }\n  const jwks: JWKS = await response.json();\n  return generateTransaction({\n    aptosConfig,\n    sender: sender.accountAddress,\n    data: {\n      function: \"0x1::jwks::update_federated_jwk_set\",\n      functionArguments: [\n        iss,\n        MoveVector.MoveString(jwks.keys.map((key) => key.kid)),\n        MoveVector.MoveString(jwks.keys.map((key) => key.alg)),\n        MoveVector.MoveString(jwks.keys.map((key) => key.e)),\n        MoveVector.MoveString(jwks.keys.map((key) => key.n)),\n      ],\n    },\n  });\n}\n"],"mappings":"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","names":["jwtDecode","getPepper","args","aptosConfig","jwt","ephemeralKeyPair","uidKey","derivationPath","body","Hex","data","postAptosPepperService","getProof","pepper","KeylessAccount","maxExpHorizonSecs","getKeylessConfig","decodedJwt","jwtDecode","json","postAptosProvingService","proofPoints","groth16Zkp","Groth16Zkp","ZeroKnowledgeSig","ZkProof","EphemeralSignature","deriveKeylessAccount","jwkAddress","proofFetchCallback","proofPromise","proof","publicKey","FederatedKeylessPublicKey","address","lookupOriginalAccountAddress","FederatedKeylessAccount","KeylessPublicKey","updateFederatedKeylessJwkSetTransaction","sender","iss","jwksUrl","response","jwks","generateTransaction","MoveVector","key"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/transactionSubmission.ts"],"sourcesContent":["/**\n * This file contains the underlying implementations for exposed submission API surface in\n * the {@link api/transaction}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * transaction namespace and without having a dependency cycle error.\n */\n\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { MoveVector, U8 } from \"../bcs\";\nimport { postAptosFullNode } from \"../client\";\nimport { Account, AbstractKeylessAccount, MultiKeyAccount } from \"../account\";\nimport { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { PrivateKey } from \"../core/crypto\";\nimport { AccountAuthenticator } from \"../transactions/authenticator/account\";\nimport { RotationProofChallenge } from \"../transactions/instances/rotationProofChallenge\";\nimport {\n  buildTransaction,\n  generateTransactionPayload,\n  generateSignedTransactionForSimulation,\n  generateSignedTransaction,\n} from \"../transactions/transactionBuilder/transactionBuilder\";\nimport {\n  InputGenerateTransactionData,\n  AnyRawTransaction,\n  InputSimulateTransactionData,\n  InputGenerateTransactionOptions,\n  InputGenerateTransactionPayloadDataWithRemoteABI,\n  InputSubmitTransactionData,\n  InputGenerateMultiAgentRawTransactionData,\n  InputGenerateSingleSignerRawTransactionData,\n  AnyTransactionPayloadInstance,\n  EntryFunctionABI,\n} from \"../transactions/types\";\nimport { getInfo } from \"./account\";\nimport { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from \"../types\";\nimport { TypeTagU8, TypeTagVector, generateSigningMessageForTransaction } from \"../transactions\";\nimport { SimpleTransaction } from \"../transactions/instances/simpleTransaction\";\nimport { MultiAgentTransaction } from \"../transactions/instances/multiAgentTransaction\";\n\n/**\n * We are defining function signatures, each with its specific input and output.\n * These are the possible function signature for `generateTransaction` function.\n * When we call `generateTransaction` function with the relevant type properties,\n * Typescript can infer the return type based on the appropriate function overload.\n */\nexport async function generateTransaction(\n  args: { aptosConfig: AptosConfig } & InputGenerateSingleSignerRawTransactionData,\n): Promise<SimpleTransaction>;\nexport async function generateTransaction(\n  args: { aptosConfig: AptosConfig } & InputGenerateMultiAgentRawTransactionData,\n): Promise<MultiAgentTransaction>;\n/**\n * Generates any transaction by passing in the required arguments\n *\n * @param args.sender The transaction sender's account address as a AccountAddressInput\n * @param args.data EntryFunctionData | ScriptData | MultiSigData\n * @param args.feePayerAddress optional. For a fee payer (aka sponsored) transaction\n * @param args.secondarySignerAddresses optional. For a multi-agent or fee payer (aka sponsored) transactions\n * @param args.options optional. GenerateTransactionOptions type\n *\n * @example\n * For a single signer entry function\n * move function name, move function type arguments, move function arguments\n * `\n * data: {\n *  function:\"0x1::aptos_account::transfer\",\n *  typeArguments:[]\n *  functionArguments :[receiverAddress,10]\n * }\n * `\n *\n * @example\n * For a single signer script function\n * module bytecode, move function type arguments, move function arguments\n * ```\n * data: {\n *  bytecode:\"0x001234567\",\n *  typeArguments:[],\n *  functionArguments :[receiverAddress,10]\n * }\n * ```\n *\n * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses\n * ```\n * {\n *  rawTransaction: RawTransaction,\n *  secondarySignerAddresses? : Array<AccountAddress>,\n *  feePayerAddress?: AccountAddress\n * }\n * ```\n */\nexport async function generateTransaction(\n  args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,\n): Promise<AnyRawTransaction> {\n  const payload = await buildTransactionPayload(args);\n  return buildRawTransaction(args, payload);\n}\n\nexport async function buildTransactionPayload(\n  args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,\n): Promise<AnyTransactionPayloadInstance> {\n  const { aptosConfig, data } = args;\n  // Merge in aptosConfig for remote ABI on non-script payloads\n  let generateTransactionPayloadData: InputGenerateTransactionPayloadDataWithRemoteABI;\n  let payload: AnyTransactionPayloadInstance;\n\n  if (\"bytecode\" in data) {\n    // TODO: Add ABI checking later\n    payload = await generateTransactionPayload(data);\n  } else if (\"multisigAddress\" in data) {\n    generateTransactionPayloadData = {\n      aptosConfig,\n      multisigAddress: data.multisigAddress,\n      function: data.function,\n      functionArguments: data.functionArguments,\n      typeArguments: data.typeArguments,\n      abi: data.abi,\n    };\n    payload = await generateTransactionPayload(generateTransactionPayloadData);\n  } else {\n    generateTransactionPayloadData = {\n      aptosConfig,\n      function: data.function,\n      functionArguments: data.functionArguments,\n      typeArguments: data.typeArguments,\n      abi: data.abi,\n    };\n    payload = await generateTransactionPayload(generateTransactionPayloadData);\n  }\n  return payload;\n}\n\nexport async function buildRawTransaction(\n  args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,\n  payload: AnyTransactionPayloadInstance,\n): Promise<AnyRawTransaction> {\n  const { aptosConfig, sender, options } = args;\n\n  let feePayerAddress;\n  if (isFeePayerTransactionInput(args)) {\n    feePayerAddress = AccountAddress.ZERO.toString();\n  }\n\n  if (isMultiAgentTransactionInput(args)) {\n    const { secondarySignerAddresses } = args;\n    return buildTransaction({\n      aptosConfig,\n      sender,\n      payload,\n      options,\n      secondarySignerAddresses,\n      feePayerAddress,\n    });\n  }\n\n  return buildTransaction({\n    aptosConfig,\n    sender,\n    payload,\n    options,\n    feePayerAddress,\n  });\n}\n\nfunction isFeePayerTransactionInput(data: InputGenerateTransactionData): boolean {\n  return data.withFeePayer === true;\n}\n\nfunction isMultiAgentTransactionInput(\n  data: InputGenerateTransactionData,\n): data is InputGenerateMultiAgentRawTransactionData {\n  return \"secondarySignerAddresses\" in data;\n}\n\n/**\n * Builds a signing message that can be signed by external signers\n *\n * Note: Please prefer using `signTransaction` unless signing outside the SDK\n *\n * @param args.transaction AnyRawTransaction, as generated by `generateTransaction()`\n *\n * @return The message to be signed\n */\nexport function getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {\n  const { transaction } = args;\n  return generateSigningMessageForTransaction(transaction);\n}\n\n/**\n * Sign a transaction that can later be submitted to chain\n *\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 * {\n *  rawTransaction: RawTransaction,\n *  secondarySignerAddresses? : Array<AccountAddress>,\n *  feePayerAddress?: AccountAddress\n * }\n * ```\n *\n * @return The signer AccountAuthenticator\n */\nexport function signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n  const { signer, transaction } = args;\n  return signer.signTransactionWithAuthenticator(transaction);\n}\n\nexport function signAsFeePayer(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n  const { signer, transaction } = args;\n\n  // if transaction doesnt hold a \"feePayerAddress\" prop it means\n  // this is not a fee payer transaction\n  if (!transaction.feePayerAddress) {\n    throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);\n  }\n\n  // Set the feePayerAddress to the signer account address\n  transaction.feePayerAddress = signer.accountAddress;\n\n  return signTransaction({\n    signer,\n    transaction,\n  });\n}\n\n/**\n * Simulates a transaction before singing it.\n *\n * @param args.signerPublicKey The signer public key\n * @param args.transaction The raw transaction to simulate\n * @param args.secondarySignersPublicKeys optional. For when the transaction is a multi signers transaction\n * @param args.feePayerPublicKey optional. For when the transaction is a fee payer (aka sponsored) transaction\n * @param args.options optional. A config to simulate the transaction with\n */\nexport async function simulateTransaction(\n  args: { aptosConfig: AptosConfig } & InputSimulateTransactionData,\n): Promise<Array<UserTransactionResponse>> {\n  const { aptosConfig, transaction, signerPublicKey, secondarySignersPublicKeys, feePayerPublicKey, options } = args;\n\n  const signedTransaction = generateSignedTransactionForSimulation({\n    transaction,\n    signerPublicKey,\n    secondarySignersPublicKeys,\n    feePayerPublicKey,\n    options,\n  });\n\n  const { data } = await postAptosFullNode<Uint8Array, Array<UserTransactionResponse>>({\n    aptosConfig,\n    body: signedTransaction,\n    path: \"transactions/simulate\",\n    params: {\n      estimate_gas_unit_price: args.options?.estimateGasUnitPrice ?? false,\n      estimate_max_gas_amount: args.options?.estimateMaxGasAmount ?? false,\n      estimate_prioritized_gas_unit_price: args.options?.estimatePrioritizedGasUnitPrice ?? false,\n    },\n    originMethod: \"simulateTransaction\",\n    contentType: MimeType.BCS_SIGNED_TRANSACTION,\n  });\n  return data;\n}\n\n/**\n * Submit transaction to chain\n *\n * @param args.transaction A aptos transaction type\n * @param args.senderAuthenticator The account authenticator of the transaction sender\n * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction\n *\n * @return PendingTransactionResponse\n */\nexport async function submitTransaction(\n  args: {\n    aptosConfig: AptosConfig;\n  } & InputSubmitTransactionData,\n): Promise<PendingTransactionResponse> {\n  const { aptosConfig } = args;\n  const signedTransaction = generateSignedTransaction({ ...args });\n  const { data } = await postAptosFullNode<Uint8Array, PendingTransactionResponse>({\n    aptosConfig,\n    body: signedTransaction,\n    path: \"transactions\",\n    originMethod: \"submitTransaction\",\n    contentType: MimeType.BCS_SIGNED_TRANSACTION,\n  });\n  return data;\n}\nexport type FeePayerOrFeePayerAuthenticatorOrNeither =\n  | { feePayer: Account; feePayerAuthenticator?: never }\n  | { feePayer?: never; feePayerAuthenticator: AccountAuthenticator }\n  | { feePayer?: never; feePayerAuthenticator?: never };\n\nexport async function signAndSubmitTransaction(\n  args: FeePayerOrFeePayerAuthenticatorOrNeither & {\n    aptosConfig: AptosConfig;\n    signer: Account;\n    transaction: AnyRawTransaction;\n  },\n): Promise<PendingTransactionResponse> {\n  const { aptosConfig, signer, feePayer, transaction } = args;\n  // If the signer contains a KeylessAccount, await proof fetching in case the proof\n  // was fetched asyncronously.\n  if (signer instanceof AbstractKeylessAccount || signer instanceof MultiKeyAccount) {\n    await signer.waitForProofFetch();\n  }\n  if (feePayer instanceof AbstractKeylessAccount || feePayer instanceof MultiKeyAccount) {\n    await feePayer.waitForProofFetch();\n  }\n  const feePayerAuthenticator =\n    args.feePayerAuthenticator || (feePayer && signAsFeePayer({ signer: feePayer, transaction }));\n\n  const senderAuthenticator = signTransaction({ signer, transaction });\n  return submitTransaction({\n    aptosConfig,\n    transaction,\n    senderAuthenticator,\n    feePayerAuthenticator,\n  });\n}\n\nexport async function signAndSubmitAsFeePayer(args: {\n  aptosConfig: AptosConfig;\n  feePayer: Account;\n  senderAuthenticator: AccountAuthenticator;\n  transaction: AnyRawTransaction;\n}): Promise<PendingTransactionResponse> {\n  const { aptosConfig, senderAuthenticator, feePayer, transaction } = args;\n\n  if (feePayer instanceof AbstractKeylessAccount || feePayer instanceof MultiKeyAccount) {\n    await feePayer.waitForProofFetch();\n  }\n\n  const feePayerAuthenticator = signAsFeePayer({ signer: feePayer, transaction });\n\n  return submitTransaction({\n    aptosConfig,\n    transaction,\n    senderAuthenticator,\n    feePayerAuthenticator,\n  });\n}\n\nconst packagePublishAbi: EntryFunctionABI = {\n  typeParameters: [],\n  parameters: [TypeTagVector.u8(), new TypeTagVector(TypeTagVector.u8())],\n};\n\nexport async function publicPackageTransaction(args: {\n  aptosConfig: AptosConfig;\n  account: AccountAddressInput;\n  metadataBytes: HexInput;\n  moduleBytecode: Array<HexInput>;\n  options?: InputGenerateTransactionOptions;\n}): Promise<SimpleTransaction> {\n  const { aptosConfig, account, metadataBytes, moduleBytecode, options } = args;\n\n  const totalByteCode = moduleBytecode.map((bytecode) => MoveVector.U8(bytecode));\n\n  return generateTransaction({\n    aptosConfig,\n    sender: AccountAddress.from(account),\n    data: {\n      function: \"0x1::code::publish_package_txn\",\n      functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)],\n      abi: packagePublishAbi,\n    },\n    options,\n  });\n}\n\nconst rotateAuthKeyAbi: EntryFunctionABI = {\n  typeParameters: [],\n  parameters: [\n    new TypeTagU8(),\n    TypeTagVector.u8(),\n    new TypeTagU8(),\n    TypeTagVector.u8(),\n    TypeTagVector.u8(),\n    TypeTagVector.u8(),\n  ],\n};\n\n/**\n * TODO: Need to refactor and move this function out of transactionSubmission\n */\nexport async function rotateAuthKey(args: {\n  aptosConfig: AptosConfig;\n  fromAccount: Account;\n  toNewPrivateKey: PrivateKey;\n}): Promise<TransactionResponse> {\n  const { aptosConfig, fromAccount, toNewPrivateKey } = args;\n  const accountInfo = await getInfo({\n    aptosConfig,\n    accountAddress: fromAccount.accountAddress,\n  });\n\n  const newAccount = Account.fromPrivateKey({ privateKey: toNewPrivateKey, legacy: true });\n\n  const challenge = new RotationProofChallenge({\n    sequenceNumber: BigInt(accountInfo.sequence_number),\n    originator: fromAccount.accountAddress,\n    currentAuthKey: AccountAddress.from(accountInfo.authentication_key),\n    newPublicKey: newAccount.publicKey,\n  });\n\n  // Sign the challenge\n  const challengeHex = challenge.bcsToBytes();\n  const proofSignedByCurrentPrivateKey = fromAccount.sign(challengeHex);\n  const proofSignedByNewPrivateKey = newAccount.sign(challengeHex);\n\n  // Generate transaction\n  const rawTxn = await generateTransaction({\n    aptosConfig,\n    sender: fromAccount.accountAddress,\n    data: {\n      function: \"0x1::account::rotate_authentication_key\",\n      functionArguments: [\n        new U8(fromAccount.signingScheme), // from scheme\n        MoveVector.U8(fromAccount.publicKey.toUint8Array()),\n        new U8(newAccount.signingScheme), // to scheme\n        MoveVector.U8(newAccount.publicKey.toUint8Array()),\n        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),\n        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array()),\n      ],\n      abi: rotateAuthKeyAbi,\n    },\n  });\n  return signAndSubmitTransaction({\n    aptosConfig,\n    signer: fromAccount,\n    transaction: rawTxn,\n  });\n}\n"],"mappings":"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","names":["generateTransaction","args","payload","buildTransactionPayload","buildRawTransaction","aptosConfig","data","generateTransactionPayloadData","generateTransactionPayload","sender","options","feePayerAddress","isFeePayerTransactionInput","AccountAddress","isMultiAgentTransactionInput","secondarySignerAddresses","buildTransaction","getSigningMessage","transaction","generateSigningMessageForTransaction","signTransaction","signer","signAsFeePayer","simulateTransaction","signerPublicKey","secondarySignersPublicKeys","feePayerPublicKey","signedTransaction","generateSignedTransactionForSimulation","postAptosFullNode","submitTransaction","generateSignedTransaction","signAndSubmitTransaction","feePayer","AbstractKeylessAccount","MultiKeyAccount","feePayerAuthenticator","senderAuthenticator","signAndSubmitAsFeePayer","packagePublishAbi","TypeTagVector","publicPackageTransaction","account","metadataBytes","moduleBytecode","totalByteCode","bytecode","MoveVector","rotateAuthKeyAbi","TypeTagU8","rotateAuthKey","fromAccount","toNewPrivateKey","accountInfo","getInfo","newAccount","Account","challengeHex","RotationProofChallenge","proofSignedByCurrentPrivateKey","proofSignedByNewPrivateKey","rawTxn","U8"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/event.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  getAccountEventsByCreationNumber,\n  getAccountEventsByEventType,\n  getModuleEventsByEventType,\n  getEvents,\n} from \"../internal/event\";\nimport { AnyNumber, GetEventsResponse, MoveStructId, OrderByArg, PaginationArgs, WhereArg } from \"../types\";\nimport { EventsBoolExp } from \"../types/generated/types\";\nimport { AccountAddressInput } from \"../core\";\nimport { ProcessorType } from \"../utils/const\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { waitForIndexerOnVersion } from \"./utils\";\n\n/**\n * A class to query all `Event` Aptos related queries\n */\nexport class Event {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Get module events by event type\n   *\n   * @example\n   * const events = await aptos.getModuleEventsByEventType({eventType:\"0x1::transaction_fee::FeeStatement\"})\n   *\n   * @param args.eventType - The event type\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   *\n   * @returns Promise<GetEventsResponse>\n   */\n  async getModuleEventsByEventType(args: {\n    eventType: MoveStructId;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;\n  }): Promise<GetEventsResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.EVENTS_PROCESSOR,\n    });\n    return getModuleEventsByEventType({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Get events by creation number and an account address\n   *\n   * @example\n   * const events = await aptos.getAccountEventsByCreationNumber({accountAddress:\"0x123\",creationNumber: 0})\n   *\n   * @param args.accountAddress - The account address\n   * @param args.creationNumber - The event creation number\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   *\n   * @returns Promise<GetEventsResponse>\n   */\n  async getAccountEventsByCreationNumber(args: {\n    accountAddress: AccountAddressInput;\n    creationNumber: AnyNumber;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<GetEventsResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.EVENTS_PROCESSOR,\n    });\n    return getAccountEventsByCreationNumber({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Get events by event type and an account address\n   *\n   * @example\n   * const events = await aptos.getAccountEventsByEventType({accountAddress:\"0x123\",eventType: \"0x1::transaction_fee::FeeStatement\"})\n   *\n   * @param args.accountAddress - The account address\n   * @param args.eventType - The event type\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   *\n   * @returns Promise<GetEventsResponse>\n   */\n  async getAccountEventsByEventType(args: {\n    accountAddress: AccountAddressInput;\n    eventType: MoveStructId;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;\n  }): Promise<GetEventsResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.EVENTS_PROCESSOR,\n    });\n    return getAccountEventsByEventType({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Get all events\n   *\n   * An optional `where` can be passed in to filter out the response.\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @example\n   * const events = await aptos.getEvents()\n   * // with filtering\n   * const events = await aptos.getEvents({options: { where: { account_address: { _eq: \"0x123\" } } }});\n   *\n   * @returns GetEventsQuery response type\n   */\n  async getEvents(args?: {\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;\n  }): Promise<GetEventsResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorType: ProcessorType.EVENTS_PROCESSOR,\n    });\n    return getEvents({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"uGAmBO,IAAMA,EAAN,KAAY,CACjB,YAAqBC,EAAqB,CAArB,YAAAA,CAAsB,CAa3C,MAAM,2BAA2BC,EAIF,CAC7B,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,EAAK,qBAC3B,gCACF,CAAC,EACME,EAA2B,CAAE,YAAa,KAAK,OAAQ,GAAGF,CAAK,CAAC,CACzE,CAcA,MAAM,iCAAiCA,EAIR,CAC7B,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,EAAK,qBAC3B,gCACF,CAAC,EACMG,EAAiC,CAAE,YAAa,KAAK,OAAQ,GAAGH,CAAK,CAAC,CAC/E,CAcA,MAAM,4BAA4BA,EAKH,CAC7B,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,EAAK,qBAC3B,gCACF,CAAC,EACMI,EAA4B,CAAE,YAAa,KAAK,OAAQ,GAAGJ,CAAK,CAAC,CAC1E,CAcA,MAAM,UAAUA,EAGe,CAC7B,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,GAAM,qBAC5B,gCACF,CAAC,EACMK,EAAU,CAAE,YAAa,KAAK,OAAQ,GAAGL,CAAK,CAAC,CACxD,CACF","names":["Event","config","args","waitForIndexerOnVersion","getModuleEventsByEventType","getAccountEventsByCreationNumber","getAccountEventsByEventType","getEvents"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/bcs/serializable/entryFunctionBytes.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Serializer, Serializable } from \"../serializer\";\nimport { Deserializer } from \"../deserializer\";\nimport { FixedBytes } from \"./fixedBytes\";\nimport { EntryFunctionArgument } from \"../../transactions/instances/transactionArgument\";\nimport { HexInput } from \"../../types\";\n\n/**\n * This class exists solely to represent a sequence of fixed bytes as a serialized entry function, because\n * serializing an entry function appends a prefix that's *only* used for entry function arguments.\n *\n * NOTE: Attempting to use this class for a serialized script function will result in erroneous\n * and unexpected behavior.\n *\n * If you wish to convert this class back to a TransactionArgument, you must know the type\n * of the argument beforehand, and use the appropriate class to deserialize the bytes within\n * an instance of this class.\n */\nexport class EntryFunctionBytes extends Serializable implements EntryFunctionArgument {\n  public readonly value: FixedBytes;\n\n  private constructor(value: HexInput) {\n    super();\n    this.value = new FixedBytes(value);\n  }\n\n  // Note that to see the Move, BCS-serialized representation of the underlying fixed byte vector,\n  // we must not serialize the length prefix.\n  //\n  // In other words, this class is only used to represent a sequence of bytes that are already\n  // BCS-serialized as a type. To represent those bytes accurately, the BCS-serialized form is the same exact\n  // representation.\n  serialize(serializer: Serializer): void {\n    serializer.serialize(this.value);\n  }\n\n  // When we serialize these bytes as an entry function argument, we need to\n  // serialize the length prefix. This essentially converts the underlying fixed byte vector to a type-agnostic\n  // byte vector to an `any` type.\n  // NOTE: This, and the lack of a `serializeForScriptFunction`, is the only meaningful difference between this\n  // class and FixedBytes.\n  serializeForEntryFunction(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(this.value.value.length);\n    serializer.serialize(this);\n  }\n\n  /**\n   * The only way to create an instance of this class is to use this static method.\n   *\n   * This function should only be used when deserializing a sequence of EntryFunctionPayload arguments.\n   * @param deserializer the deserializer instance with the buffered bytes\n   * @param length the length of the bytes to deserialize\n   * @returns an instance of this class, which will now only be usable as an EntryFunctionArgument\n   */\n  static deserialize(deserializer: Deserializer, length: number): EntryFunctionBytes {\n    const fixedBytes = FixedBytes.deserialize(deserializer, length);\n    return new EntryFunctionBytes(fixedBytes.value);\n  }\n}\n"],"mappings":"kFAoBO,IAAMA,EAAN,MAAMC,UAA2BC,CAA8C,CAG5E,YAAYC,EAAiB,CACnC,MAAM,EACN,KAAK,MAAQ,IAAIC,EAAWD,CAAK,CACnC,CAQA,UAAUE,EAA8B,CACtCA,EAAW,UAAU,KAAK,KAAK,CACjC,CAOA,0BAA0BA,EAA8B,CACtDA,EAAW,sBAAsB,KAAK,MAAM,MAAM,MAAM,EACxDA,EAAW,UAAU,IAAI,CAC3B,CAUA,OAAO,YAAYC,EAA4BC,EAAoC,CACjF,IAAMC,EAAaJ,EAAW,YAAYE,EAAcC,CAAM,EAC9D,OAAO,IAAIN,EAAmBO,EAAW,KAAK,CAChD,CACF","names":["EntryFunctionBytes","_EntryFunctionBytes","Serializable","value","FixedBytes","serializer","deserializer","length","fixedBytes"]}

package/dist/esm/chunk-Q3TAEOH5.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 { AccountAddressInput } from \"../../core\";\nimport { generateTransaction } from \"../../internal/transactionSubmission\";\nimport { InputGenerateTransactionPayloadData, InputGenerateTransactionOptions } from \"../../transactions\";\nimport { MultiAgentTransaction } from \"../../transactions/instances/multiAgentTransaction\";\nimport { SimpleTransaction } from \"../../transactions/instances/simpleTransaction\";\nimport { AptosConfig } from \"../aptosConfig\";\n\n/**\n * A class to handle all `Build` transaction operations\n */\nexport class Build {\n  readonly config: AptosConfig;\n\n  constructor(config: AptosConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Build a simple transaction\n   *\n   * @param args.sender The sender account address\n   * @param args.data The transaction data\n   * @param args.options optional. Optional transaction configurations\n   * @param args.withFeePayer optional. Whether there is a fee payer for the transaction\n   *\n   * @returns SimpleTransaction\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 multi agent transaction\n   *\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. Optional transaction configurations\n   * @param args.withFeePayer optional. Whether there is a fee payer for the transaction\n   *\n   * @returns MultiAgentTransaction\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":"yCAaO,IAAMA,EAAN,KAAY,CAGjB,YAAYC,EAAqB,CAC/B,KAAK,OAASA,CAChB,CAYA,MAAM,OAAOC,EAKkB,CAC7B,OAAOC,EAAoB,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CAClE,CAaA,MAAM,WAAWA,EAMkB,CACjC,OAAOC,EAAoB,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CAClE,CACF","names":["Build","config","args","generateTransaction"]}

package/dist/esm/chunk-Q4XR6QOZ.mjs

@@ -1,2 +0,0 @@
-import{b as t}from"./chunk-BCUSI3N6.mjs";var o=n=>typeof n=="string"?t.isValid(n).valid?n:new TextEncoder().encode(n):n;export{o as a};
-//# sourceMappingURL=chunk-Q4XR6QOZ.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/instances/rawTransaction.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 { ChainId } from \"./chainId\";\nimport { AccountAddress } from \"../../core\";\nimport { TransactionPayload } from \"./transactionPayload\";\nimport { TransactionVariants } from \"../../types\";\n\n/**\n * Representation of a Raw Transaction that can serialized and deserialized\n */\nexport class RawTransaction extends Serializable {\n  public readonly sender: AccountAddress;\n\n  public readonly sequence_number: bigint;\n\n  public readonly payload: TransactionPayload;\n\n  public readonly max_gas_amount: bigint;\n\n  public readonly gas_unit_price: bigint;\n\n  public readonly expiration_timestamp_secs: bigint;\n\n  public readonly chain_id: ChainId;\n\n  /**\n   * RawTransactions contain the metadata and payloads that can be submitted to Aptos chain for execution.\n   * RawTransactions must be signed before Aptos chain can execute them.\n   *\n   * @param sender The sender Account Address\n   * @param sequence_number Sequence number of this transaction. This must match the sequence number stored in\n   *   the sender's account at the time the transaction executes.\n   * @param payload Instructions for the Aptos Blockchain, including publishing a module,\n   *   execute an entry function or execute a script payload.\n   * @param max_gas_amount Maximum total gas to spend for this transaction. The account must have more\n   *   than this gas or the transaction will be discarded during validation.\n   * @param gas_unit_price Price to be paid per gas unit.\n   * @param expiration_timestamp_secs The blockchain timestamp at which the blockchain would discard this transaction.\n   * @param chain_id The chain ID of the blockchain that this transaction is intended to be run on.\n   */\n  constructor(\n    sender: AccountAddress,\n    sequence_number: bigint,\n    payload: TransactionPayload,\n    max_gas_amount: bigint,\n    gas_unit_price: bigint,\n    expiration_timestamp_secs: bigint,\n    chain_id: ChainId,\n  ) {\n    super();\n    this.sender = sender;\n    this.sequence_number = sequence_number;\n    this.payload = payload;\n    this.max_gas_amount = max_gas_amount;\n    this.gas_unit_price = gas_unit_price;\n    this.expiration_timestamp_secs = expiration_timestamp_secs;\n    this.chain_id = chain_id;\n  }\n\n  serialize(serializer: Serializer): void {\n    this.sender.serialize(serializer);\n    serializer.serializeU64(this.sequence_number);\n    this.payload.serialize(serializer);\n    serializer.serializeU64(this.max_gas_amount);\n    serializer.serializeU64(this.gas_unit_price);\n    serializer.serializeU64(this.expiration_timestamp_secs);\n    this.chain_id.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): RawTransaction {\n    const sender = AccountAddress.deserialize(deserializer);\n    const sequence_number = deserializer.deserializeU64();\n    const payload = TransactionPayload.deserialize(deserializer);\n    const max_gas_amount = deserializer.deserializeU64();\n    const gas_unit_price = deserializer.deserializeU64();\n    const expiration_timestamp_secs = deserializer.deserializeU64();\n    const chain_id = ChainId.deserialize(deserializer);\n    return new RawTransaction(\n      sender,\n      sequence_number,\n      payload,\n      max_gas_amount,\n      gas_unit_price,\n      expiration_timestamp_secs,\n      chain_id,\n    );\n  }\n}\n\n/**\n * Representation of a Raw Transaction With Data that can serialized and deserialized\n */\nexport abstract class RawTransactionWithData extends Serializable {\n  /**\n   * Serialize a Raw Transaction With Data\n   */\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Deserialize a Raw Transaction With Data\n   */\n  static deserialize(deserializer: Deserializer): RawTransactionWithData {\n    // index enum variant\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case TransactionVariants.MultiAgentTransaction:\n        return MultiAgentRawTransaction.load(deserializer);\n      case TransactionVariants.FeePayerTransaction:\n        return FeePayerRawTransaction.load(deserializer);\n      default:\n        throw new Error(`Unknown variant index for RawTransactionWithData: ${index}`);\n    }\n  }\n}\n\n/**\n * Representation of a Multi Agent Transaction that can serialized and deserialized\n */\nexport class MultiAgentRawTransaction extends RawTransactionWithData {\n  /**\n   * The raw transaction\n   */\n  public readonly raw_txn: RawTransaction;\n\n  /**\n   * The secondary signers on this transaction\n   */\n  public readonly secondary_signer_addresses: Array<AccountAddress>;\n\n  constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>) {\n    super();\n    this.raw_txn = raw_txn;\n    this.secondary_signer_addresses = secondary_signer_addresses;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionVariants.MultiAgentTransaction);\n    this.raw_txn.serialize(serializer);\n    serializer.serializeVector(this.secondary_signer_addresses);\n  }\n\n  static load(deserializer: Deserializer): MultiAgentRawTransaction {\n    const rawTxn = RawTransaction.deserialize(deserializer);\n    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);\n\n    return new MultiAgentRawTransaction(rawTxn, secondarySignerAddresses);\n  }\n}\n\n/**\n * Representation of a Fee Payer Transaction that can serialized and deserialized\n */\nexport class FeePayerRawTransaction extends RawTransactionWithData {\n  /**\n   * The raw transaction\n   */\n  public readonly raw_txn: RawTransaction;\n\n  /**\n   * The secondary signers on this transaction - optional and can be empty\n   */\n  public readonly secondary_signer_addresses: Array<AccountAddress>;\n\n  /**\n   * The fee payer account address\n   */\n  public readonly fee_payer_address: AccountAddress;\n\n  constructor(\n    raw_txn: RawTransaction,\n    secondary_signer_addresses: Array<AccountAddress>,\n    fee_payer_address: AccountAddress,\n  ) {\n    super();\n    this.raw_txn = raw_txn;\n    this.secondary_signer_addresses = secondary_signer_addresses;\n    this.fee_payer_address = fee_payer_address;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionVariants.FeePayerTransaction);\n    this.raw_txn.serialize(serializer);\n    serializer.serializeVector(this.secondary_signer_addresses);\n    this.fee_payer_address.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): FeePayerRawTransaction {\n    const rawTxn = RawTransaction.deserialize(deserializer);\n    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);\n    const feePayerAddress = AccountAddress.deserialize(deserializer);\n\n    return new FeePayerRawTransaction(rawTxn, secondarySignerAddresses, feePayerAddress);\n  }\n}\n"],"mappings":"oKAeO,IAAMA,EAAN,MAAMC,UAAuBC,CAAa,CA8B/C,YACEC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACA,CACA,MAAM,EACN,KAAK,OAASN,EACd,KAAK,gBAAkBC,EACvB,KAAK,QAAUC,EACf,KAAK,eAAiBC,EACtB,KAAK,eAAiBC,EACtB,KAAK,0BAA4BC,EACjC,KAAK,SAAWC,CAClB,CAEA,UAAUC,EAA8B,CACtC,KAAK,OAAO,UAAUA,CAAU,EAChCA,EAAW,aAAa,KAAK,eAAe,EAC5C,KAAK,QAAQ,UAAUA,CAAU,EACjCA,EAAW,aAAa,KAAK,cAAc,EAC3CA,EAAW,aAAa,KAAK,cAAc,EAC3CA,EAAW,aAAa,KAAK,yBAAyB,EACtD,KAAK,SAAS,UAAUA,CAAU,CACpC,CAEA,OAAO,YAAYC,EAA4C,CAC7D,IAAMR,EAASS,EAAe,YAAYD,CAAY,EAChDP,EAAkBO,EAAa,eAAe,EAC9CN,EAAUQ,EAAmB,YAAYF,CAAY,EACrDL,EAAiBK,EAAa,eAAe,EAC7CJ,EAAiBI,EAAa,eAAe,EAC7CH,EAA4BG,EAAa,eAAe,EACxDF,EAAWK,EAAQ,YAAYH,CAAY,EACjD,OAAO,IAAIV,EACTE,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,CACF,CACF,CACF,EAKsBM,EAAf,cAA8Cb,CAAa,CAShE,OAAO,YAAYS,EAAoD,CAErE,IAAMK,EAAQL,EAAa,wBAAwB,EACnD,OAAQK,EAAO,CACb,OACE,OAAOC,EAAyB,KAAKN,CAAY,EACnD,OACE,OAAOO,EAAuB,KAAKP,CAAY,EACjD,QACE,MAAM,IAAI,MAAM,qDAAqDK,CAAK,EAAE,CAChF,CACF,CACF,EAKaC,EAAN,MAAME,UAAiCJ,CAAuB,CAWnE,YAAYK,EAAyBC,EAAmD,CACtF,MAAM,EACN,KAAK,QAAUD,EACf,KAAK,2BAA6BC,CACpC,CAEA,UAAUX,EAA8B,CACtCA,EAAW,uBAA+D,EAC1E,KAAK,QAAQ,UAAUA,CAAU,EACjCA,EAAW,gBAAgB,KAAK,0BAA0B,CAC5D,CAEA,OAAO,KAAKC,EAAsD,CAChE,IAAMW,EAAStB,EAAe,YAAYW,CAAY,EAChDY,EAA2BZ,EAAa,kBAAkBC,CAAc,EAE9E,OAAO,IAAIO,EAAyBG,EAAQC,CAAwB,CACtE,CACF,EAKaL,EAAN,MAAMM,UAA+BT,CAAuB,CAgBjE,YACEK,EACAC,EACAI,EACA,CACA,MAAM,EACN,KAAK,QAAUL,EACf,KAAK,2BAA6BC,EAClC,KAAK,kBAAoBI,CAC3B,CAEA,UAAUf,EAA8B,CACtCA,EAAW,uBAA6D,EACxE,KAAK,QAAQ,UAAUA,CAAU,EACjCA,EAAW,gBAAgB,KAAK,0BAA0B,EAC1D,KAAK,kBAAkB,UAAUA,CAAU,CAC7C,CAEA,OAAO,KAAKC,EAAoD,CAC9D,IAAMW,EAAStB,EAAe,YAAYW,CAAY,EAChDY,EAA2BZ,EAAa,kBAAkBC,CAAc,EACxEc,EAAkBd,EAAe,YAAYD,CAAY,EAE/D,OAAO,IAAIa,EAAuBF,EAAQC,EAA0BG,CAAe,CACrF,CACF","names":["RawTransaction","_RawTransaction","Serializable","sender","sequence_number","payload","max_gas_amount","gas_unit_price","expiration_timestamp_secs","chain_id","serializer","deserializer","AccountAddress","TransactionPayload","ChainId","RawTransactionWithData","index","MultiAgentRawTransaction","FeePayerRawTransaction","_MultiAgentRawTransaction","raw_txn","secondary_signer_addresses","rawTxn","secondarySignerAddresses","_FeePayerRawTransaction","fee_payer_address","feePayerAddress"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/Account.ts"],"sourcesContent":["import type { AccountAuthenticator } from \"../transactions/authenticator/account\";\nimport { HexInput, SigningScheme, SigningSchemeInput } from \"../types\";\nimport type { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { AuthenticationKey } from \"../core/authenticationKey\";\nimport { AccountPublicKey, Ed25519PrivateKey, PrivateKey, Signature, VerifySignatureArgs } from \"../core/crypto\";\nimport { Ed25519Account } from \"./Ed25519Account\";\nimport { SingleKeyAccount } from \"./SingleKeyAccount\";\nimport { AnyRawTransaction } from \"../transactions/types\";\n\n/**\n * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.\n * This is the default input type when passing an `Ed25519PrivateKey`.\n * In order to use the SingleKey authentication scheme, `legacy` needs to be explicitly set to false.\n */\nexport interface CreateEd25519AccountFromPrivateKeyArgs {\n  privateKey: Ed25519PrivateKey;\n  address?: AccountAddressInput;\n  legacy?: true;\n}\n\n/**\n * Arguments for creating an `SingleKeyAccount` from an `Ed25519PrivateKey`.\n * The `legacy` argument needs to be explicitly set to false in order to\n * use the `SingleKey` authentication scheme.\n */\nexport interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {\n  privateKey: Ed25519PrivateKey;\n  address?: AccountAddressInput;\n  legacy: false;\n}\n\n/**\n * Arguments for creating an `SingleKeyAccount` from any supported private key\n * that is not an `Ed25519PrivateKey`.\n * The `legacy` argument defaults to false and cannot be explicitly set to true.\n */\nexport interface CreateSingleKeyAccountFromPrivateKeyArgs {\n  privateKey: Exclude<PrivateKey, Ed25519PrivateKey>;\n  address?: AccountAddressInput;\n  legacy?: false;\n}\n\n/**\n * Arguments for creating an opaque `Account` from any supported private key.\n * This is used when the private key type is not known at compilation time.\n */\nexport interface CreateAccountFromPrivateKeyArgs {\n  privateKey: PrivateKey;\n  address?: AccountAddressInput;\n  legacy?: boolean;\n}\n\n/**\n * Arguments for generating an `Ed25519Account`.\n * This is the input type used by default.\n */\nexport interface GenerateEd25519AccountArgs {\n  scheme?: SigningSchemeInput.Ed25519;\n  legacy?: true;\n}\n\n/**\n * Arguments for generating an `SingleKeyAccount` with ah underlying `Ed25519PrivateKey`.\n * The `legacy` argument needs to be explicitly set to false,\n * otherwise an `Ed25519Account` will be returned instead.\n */\nexport interface GenerateEd25519SingleKeyAccountArgs {\n  scheme?: SigningSchemeInput.Ed25519;\n  legacy: false;\n}\n\n/**\n * Arguments for generating an `SingleKeyAccount` with any supported private key\n * that is not an `Ed25519PrivateKey`.\n * The `legacy` argument defaults to false and cannot be explicitly set to true.\n */\nexport interface GenerateSingleKeyAccountArgs {\n  scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;\n  legacy?: false;\n}\n\n/**\n * Arguments for generating an opaque `Account`.\n * This is used when the input signature scheme is not known at compilation time.\n */\nexport interface GenerateAccountArgs {\n  scheme?: SigningSchemeInput;\n  legacy?: boolean;\n}\n\n/**\n * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.\n */\nexport interface PrivateKeyFromDerivationPathArgs {\n  path: string;\n  mnemonic: string;\n}\n\n/**\n * Interface for a generic Aptos account.\n *\n * The interface is defined as abstract class to provide a single entrypoint for account generation,\n * either through `Account.generate()` or `Account.fromDerivationPath`.\n * Despite this being an abstract class, it should be treated as an interface and enforced using\n * the `implements` keyword.\n *\n * Note: Generating an account instance does not create the account on-chain.\n */\nexport abstract class Account {\n  /**\n   * Public key associated with the account\n   */\n  abstract readonly publicKey: AccountPublicKey;\n\n  /**\n   * Account address associated with the account\n   */\n  abstract readonly accountAddress: AccountAddress;\n\n  /**\n   * Signing scheme used to sign transactions\n   */\n  abstract signingScheme: SigningScheme;\n\n  /**\n   * Derives an account from a randomly generated private key.\n   * @param args.scheme The signature scheme to use, to generate the private key\n   * @param args.legacy Whether to use a legacy authentication scheme, when applicable\n   * @returns An account compatible with the provided signature scheme\n   */\n  static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;\n  static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;\n  static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;\n  static generate(args: GenerateAccountArgs): Account;\n  static generate(args: GenerateAccountArgs = {}) {\n    const { scheme = SigningSchemeInput.Ed25519, legacy = true } = args;\n    if (scheme === SigningSchemeInput.Ed25519 && legacy) {\n      return Ed25519Account.generate();\n    }\n    return SingleKeyAccount.generate({ scheme });\n  }\n\n  /**\n   * Creates an account from the provided private key.\n   *\n   * @param args.privateKey a valid private key\n   * @param args.address the account's address. If not provided, it will be derived from the public key.\n   * @param args.legacy Whether to use a legacy authentication scheme, when applicable\n   */\n  static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;\n  static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;\n  static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;\n  static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Account;\n  static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs) {\n    const { privateKey, address, legacy = true } = args;\n    if (privateKey instanceof Ed25519PrivateKey && legacy) {\n      return new Ed25519Account({\n        privateKey,\n        address,\n      });\n    }\n    return new SingleKeyAccount({ privateKey, address });\n  }\n\n  /**\n   * @deprecated use `fromPrivateKey` instead.\n   * Instantiates an account given a private key and a specified account address.\n   * This is primarily used to instantiate an `Account` that has had its authentication key rotated.\n   *\n   * @param args.privateKey PrivateKey - the underlying private key for the account\n   * @param args.address AccountAddress - The account address the `Account` will sign for\n   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults\n   * to generating a Legacy Ed25519 keypair\n   *\n   * @returns Account\n   */\n  static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs) {\n    return this.fromPrivateKey(args);\n  }\n\n  /**\n   * Derives an account with bip44 path and mnemonics\n   *\n   * @param args.scheme The signature scheme to derive the private key with\n   * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,\n   * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1\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   */\n  static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;\n  static fromDerivationPath(\n    args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs,\n  ): SingleKeyAccount;\n  static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;\n  static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account;\n  static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs) {\n    const { scheme = SigningSchemeInput.Ed25519, mnemonic, path, legacy = true } = args;\n    if (scheme === SigningSchemeInput.Ed25519 && legacy) {\n      return Ed25519Account.fromDerivationPath({ mnemonic, path });\n    }\n    return SingleKeyAccount.fromDerivationPath({ scheme, mnemonic, path });\n  }\n\n  /**\n   * @deprecated use `publicKey.authKey()` instead.\n   * This key enables account owners to rotate their private key(s)\n   * associated with the account without changing the address that hosts their account.\n   * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}\n   *\n   * @param args.publicKey PublicKey - public key of the account\n   * @returns The authentication key for the associated account\n   */\n  static authKey(args: { publicKey: AccountPublicKey }): AuthenticationKey {\n    const { publicKey } = args;\n    return publicKey.authKey();\n  }\n\n  /**\n   * Sign a message using the available signing capabilities.\n   * @param message the signing message, as binary input\n   * @return the AccountAuthenticator containing the signature, together with the account's public key\n   */\n  abstract signWithAuthenticator(message: HexInput): AccountAuthenticator;\n\n  /**\n   * Sign a transaction using the available signing capabilities.\n   * @param transaction the raw transaction\n   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key\n   */\n  abstract signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;\n\n  /**\n   * Sign the given message using the available signing capabilities.\n   * @param message in HexInput format\n   * @returns Signature\n   */\n  abstract sign(message: HexInput): Signature;\n\n  /**\n   * Sign the given transaction using the available signing capabilities.\n   * @param transaction the transaction to be signed\n   * @returns Signature\n   */\n  abstract signTransaction(transaction: AnyRawTransaction): Signature;\n\n  /**\n   * Verify the given message and signature with the public key.\n   * @param args.message raw message data in HexInput format\n   * @param args.signature signed message Signature\n   * @returns\n   */\n  verifySignature(args: VerifySignatureArgs): boolean {\n    return this.publicKey.verifySignature(args);\n  }\n}\n"],"mappings":"2HA4GO,IAAeA,EAAf,KAAuB,CA0B5B,OAAO,SAASC,EAA4B,CAAC,EAAG,CAC9C,GAAM,CAAE,OAAAC,IAAqC,OAAAC,EAAS,EAAK,EAAIF,EAC/D,OAAIC,IAAW,GAA8BC,EACpCC,EAAe,SAAS,EAE1BC,EAAiB,SAAS,CAAE,OAAAH,CAAO,CAAC,CAC7C,CAaA,OAAO,eAAeD,EAAuC,CAC3D,GAAM,CAAE,WAAAK,EAAY,QAAAC,EAAS,OAAAJ,EAAS,EAAK,EAAIF,EAC/C,OAAIK,aAAsBE,GAAqBL,EACtC,IAAIC,EAAe,CACxB,WAAAE,EACA,QAAAC,CACF,CAAC,EAEI,IAAIF,EAAiB,CAAE,WAAAC,EAAY,QAAAC,CAAQ,CAAC,CACrD,CAcA,OAAO,yBAAyBN,EAAuC,CACrE,OAAO,KAAK,eAAeA,CAAI,CACjC,CAiBA,OAAO,mBAAmBA,EAA8D,CACtF,GAAM,CAAE,OAAAC,IAAqC,SAAAO,EAAU,KAAAC,EAAM,OAAAP,EAAS,EAAK,EAAIF,EAC/E,OAAIC,IAAW,GAA8BC,EACpCC,EAAe,mBAAmB,CAAE,SAAAK,EAAU,KAAAC,CAAK,CAAC,EAEtDL,EAAiB,mBAAmB,CAAE,OAAAH,EAAQ,SAAAO,EAAU,KAAAC,CAAK,CAAC,CACvE,CAWA,OAAO,QAAQT,EAA0D,CACvE,GAAM,CAAE,UAAAU,CAAU,EAAIV,EACtB,OAAOU,EAAU,QAAQ,CAC3B,CAoCA,gBAAgBV,EAAoC,CAClD,OAAO,KAAK,UAAU,gBAAgBA,CAAI,CAC5C,CACF","names":["Account","args","scheme","legacy","Ed25519Account","SingleKeyAccount","privateKey","address","Ed25519PrivateKey","mnemonic","path","publicKey"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/general.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosConfig } from \"./aptosConfig\";\nimport {\n  getChainTopUserTransactions,\n  getIndexerLastSuccessVersion,\n  getLedgerInfo,\n  getProcessorStatus,\n  queryIndexer,\n} from \"../internal/general\";\nimport { getBlockByHeight, getBlockByVersion } from \"../internal/transaction\";\nimport { view, viewJson } from \"../internal/view\";\nimport {\n  AnyNumber,\n  Block,\n  GetChainTopUserTransactionsResponse,\n  GetProcessorStatusResponse,\n  GraphqlQuery,\n  LedgerInfo,\n  LedgerVersionArg,\n  MoveValue,\n} from \"../types\";\nimport { ProcessorType } from \"../utils/const\";\nimport { InputViewFunctionData, InputViewFunctionJsonData } from \"../transactions\";\n\n/**\n * A class to query all `General` Aptos related queries\n */\nexport class General {\n  readonly config: AptosConfig;\n\n  constructor(config: AptosConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Queries for the Aptos ledger info\n   *\n   * @returns Aptos Ledger Info\n   *\n   * @example\n   * const ledgerInfo = await aptos.getLedgerInfo()\n   * // an example of the returned data\n   * ```\n   * {\n   * \"chain_id\": 4,\n   * \"epoch\": \"8\",\n   * \"ledger_version\": \"714\",\n   * \"oldest_ledger_version\": \"0\",\n   * \"ledger_timestamp\": \"1694695496521775\",\n   * \"node_role\": \"validator\",\n   * \"oldest_block_height\": \"0\",\n   * \"block_height\": \"359\",\n   * \"git_hash\": \"c82193f36f4e185fed9f68c4ad21f6c6dd390c6e\"\n   * }\n   * ```\n   */\n  async getLedgerInfo(): Promise<LedgerInfo> {\n    return getLedgerInfo({ aptosConfig: this.config });\n  }\n\n  /**\n   * Queries for the chain id\n   *\n   * @example\n   * const chainId = await aptos.getChainId()\n   *\n   * @returns The chain id\n   */\n  async getChainId(): Promise<number> {\n    const result = await this.getLedgerInfo();\n    return result.chain_id;\n  }\n\n  /**\n   * Queries for block by transaction version\n   *\n   * @example\n   * const block = await aptos.getBlockByVersion({ledgerVersion:5})\n   *\n   * @param args.ledgerVersion Ledger version to lookup block information for\n   * @param args.options.withTransactions If set to true, include all transactions in the block\n   *\n   * @returns Block information with optional transactions\n   */\n  async getBlockByVersion(args: {\n    ledgerVersion: AnyNumber;\n    options?: { withTransactions?: boolean };\n  }): Promise<Block> {\n    return getBlockByVersion({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Get block by block height\n   *\n   * @example\n   * const block = await aptos.getBlockByVersion({blockHeight:5})\n   *\n   * @param args.blockHeight Block height to lookup.  Starts at 0\n   * @param args.options.withTransactions If set to true, include all transactions in the block\n   *\n   * @returns Block with optional transactions\n   */\n  async getBlockByHeight(args: { blockHeight: AnyNumber; options?: { withTransactions?: boolean } }): Promise<Block> {\n    return getBlockByHeight({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for a Move view function\n   * @param args.payload Payload for the view function\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @example\n   * const data = await aptos.view({\n   *  payload: {\n   *   function: \"0x1::coin::balance\",\n   *   typeArguments: [\"0x1::aptos_coin::AptosCoin\"],\n   *   functionArguments: [accountAddress],\n   *  }\n   * })\n   *\n   * @returns an array of Move values\n   */\n  async view<T extends Array<MoveValue>>(args: {\n    payload: InputViewFunctionData;\n    options?: LedgerVersionArg;\n  }): Promise<T> {\n    return view<T>({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for a Move view function with JSON, this provides compatability with the old `aptos` package\n   * @param args.payload Payload for the view function\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @example\n   * const data = await aptos.view({\n   *  payload: {\n   *   function: \"0x1::coin::balance\",\n   *   typeArguments: [\"0x1::aptos_coin::AptosCoin\"],\n   *   functionArguments: [accountAddress.toString()],\n   *  }\n   * })\n   *\n   * @returns an array of Move values\n   */\n  async viewJson<T extends Array<MoveValue>>(args: {\n    payload: InputViewFunctionJsonData;\n    options?: LedgerVersionArg;\n  }): Promise<T> {\n    return viewJson<T>({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries top user transactions\n   *\n   * @example\n   * const topUserTransactions = await aptos.getChainTopUserTransactions({limit:5})\n   *\n   * @param args.limit The number of transactions to return\n   * @returns GetChainTopUserTransactionsResponse\n   */\n  async getChainTopUserTransactions(args: { limit: number }): Promise<GetChainTopUserTransactionsResponse> {\n    return getChainTopUserTransactions({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * A generic function for retrieving data from Aptos Indexer.\n   * For more detailed queries specification see\n   * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://api.mainnet.aptoslabs.com/v1/graphql}\n   *\n   * @example\n   * const topUserTransactions = await aptos.queryIndexer({\n   *  query: `query MyQuery {\n   *   ledger_infos {\n   *     chain_id\n   *   }}`;\n   * })\n   *\n   * @param args.query.query A GraphQL query\n   * @param args.query.variables The variables for the query\n   *\n   * @return The provided T type\n   */\n  async queryIndexer<T extends {}>(args: { query: GraphqlQuery }): Promise<T> {\n    return queryIndexer<T>({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries for the last successful indexer version\n   *\n   * This is useful to tell what ledger version the indexer is updated to, as it can be behind the full nodes.\n   *\n   * @example\n   * const version = await aptos.getIndexerLastSuccessVersion()\n   */\n  async getIndexerLastSuccessVersion(): Promise<bigint> {\n    return getIndexerLastSuccessVersion({ aptosConfig: this.config });\n  }\n\n  /**\n   * Query the processor status for a specific processor type.\n   *\n   * @example\n   * const status = await aptos.getProcessorStatus({processorType:\"account_transactions_processor\"})\n   *\n   * @param processorType The processor type to query\n   * @returns\n   */\n  async getProcessorStatus(processorType: ProcessorType): Promise<GetProcessorStatusResponse[0]> {\n    return getProcessorStatus({ aptosConfig: this.config, processorType });\n  }\n}\n"],"mappings":"qKA6BO,IAAMA,EAAN,KAAc,CAGnB,YAAYC,EAAqB,CAC/B,KAAK,OAASA,CAChB,CAwBA,MAAM,eAAqC,CACzC,OAAOC,EAAc,CAAE,YAAa,KAAK,MAAO,CAAC,CACnD,CAUA,MAAM,YAA8B,CAElC,OADe,MAAM,KAAK,cAAc,GAC1B,QAChB,CAaA,MAAM,kBAAkBC,EAGL,CACjB,OAAOC,EAAkB,CACvB,YAAa,KAAK,OAClB,GAAGD,CACL,CAAC,CACH,CAaA,MAAM,iBAAiBA,EAA4F,CACjH,OAAOE,EAAiB,CAAE,YAAa,KAAK,OAAQ,GAAGF,CAAK,CAAC,CAC/D,CAkBA,MAAM,KAAiCA,EAGxB,CACb,OAAOG,EAAQ,CAAE,YAAa,KAAK,OAAQ,GAAGH,CAAK,CAAC,CACtD,CAkBA,MAAM,SAAqCA,EAG5B,CACb,OAAOI,EAAY,CAAE,YAAa,KAAK,OAAQ,GAAGJ,CAAK,CAAC,CAC1D,CAWA,MAAM,4BAA4BA,EAAuE,CACvG,OAAOK,EAA4B,CACjC,YAAa,KAAK,OAClB,GAAGL,CACL,CAAC,CACH,CAoBA,MAAM,aAA2BA,EAA2C,CAC1E,OAAOM,EAAgB,CACrB,YAAa,KAAK,OAClB,GAAGN,CACL,CAAC,CACH,CAUA,MAAM,8BAAgD,CACpD,OAAOO,EAA6B,CAAE,YAAa,KAAK,MAAO,CAAC,CAClE,CAWA,MAAM,mBAAmBC,EAAsE,CAC7F,OAAOC,EAAmB,CAAE,YAAa,KAAK,OAAQ,cAAAD,CAAc,CAAC,CACvE,CACF","names":["General","config","getLedgerInfo","args","getBlockByVersion","getBlockByHeight","view","viewJson","getChainTopUserTransactions","queryIndexer","getIndexerLastSuccessVersion","processorType","getProcessorStatus"]}

package/dist/esm/chunk-RXE6NNOL.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 { 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 } from \"./AbstractKeylessAccount\";\n\nexport interface VerifyMultiKeySignatureArgs {\n  message: HexInput;\n  signature: MultiKeySignature;\n}\n\n/**\n * Signer implementation for the MultiKey authentication scheme.\n *\n * This accounts to use a M of N signing scheme. M and N are specified in the {@link MultiKey}\n * It signs messages via the array of M number of Accounts that individually correspond to a public key in the {@link MultiKey}.\n *\n * Note: Generating a signer instance does not create the account on-chain.\n */\nexport class MultiKeyAccount implements Account {\n  /**\n   * Public key associated with the account\n   */\n  readonly publicKey: MultiKey;\n\n  /**\n   * Account address associated with the account\n   */\n  readonly accountAddress: AccountAddress;\n\n  /**\n   * Signing scheme used to sign transactions\n   */\n  readonly signingScheme: SigningScheme;\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 or greater\n   * than this.publicKey.signaturesRequired\n   */\n  readonly signers: Account[];\n\n  /**\n   * An array of indicies 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   */\n  readonly signerIndicies: number[];\n\n  readonly signaturesBitmap: Uint8Array;\n\n  /**\n   * constructor for MultiKeyAccount\n   *\n   * @param args.multiKey the multikey of the account which consists of N public keys and a number M which is\n   * the number of required signatures.\n   * @param args.signers an array of M signers that will be used to sign the transaction\n   * @returns MultiKeyAccount\n   */\n  constructor(args: { multiKey: MultiKey; signers: Account[]; address?: AccountAddressInput }) {\n    const { multiKey, signers, address } = args;\n\n    this.publicKey = multiKey;\n    this.signingScheme = SigningScheme.MultiKey;\n\n    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();\n\n    // Get the index of each respective signer in the bitmap\n    const bitPositions: number[] = [];\n    for (const signer of signers) {\n      bitPositions.push(this.publicKey.getIndex(signer.publicKey));\n    }\n    // Zip signers and bit positions and sort signers by bit positions in order\n    // to ensure the signature is signed in ascending order according to the bitmap.\n    // Authentication on chain will fail otherwise.\n    const signersAndBitPosition: [Account, number][] = signers.map((signer, index) => [signer, bitPositions[index]]);\n    signersAndBitPosition.sort((a, b) => a[1] - b[1]);\n    this.signers = signersAndBitPosition.map((value) => value[0]);\n    this.signerIndicies = signersAndBitPosition.map((value) => value[1]);\n    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });\n  }\n\n  /**\n   * Static constructor for MultiKeyAccount\n   *\n   * @param args.publicKeys the N public keys of the MultiKeyAccount\n   * @param args.signaturesRequired the number of signatures required\n   * @param args.signers an array of M signers that will be used to sign the transaction\n   * @returns MultiKeyAccount\n   */\n  static fromPublicKeysAndSigners(args: {\n    publicKeys: PublicKey[];\n    signaturesRequired: number;\n    signers: Account[];\n  }): MultiKeyAccount {\n    const { publicKeys, signaturesRequired, signers } = args;\n    const multiKey = new MultiKey({ publicKeys, signaturesRequired });\n    return new MultiKeyAccount({ multiKey, signers });\n  }\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.\n   * @param message the signing message, as binary input\n   * @return the AccountAuthenticator containing the signature, together with the account's public key\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.\n   * @param transaction the raw transaction\n   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key\n   */\n  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey {\n    return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));\n  }\n\n  /**\n   * Waits for any proofs on any KeylessAccount signers to be fetched. If the proof is fetched a syncronously, call this\n   * to ensure signing with the KeylessAccount does not fail as the proof must be ready.\n   * @return\n   */\n  async waitForProofFetch() {\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   * Sign the given message using the MultiKeyAccount's signers\n   * @param message in HexInput format\n   * @returns MultiKeySignature\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   * @param transaction the transaction to be signed\n   * @returns MultiKeySignature\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 key.\n   *\n   * @param args.message raw message data in HexInput format\n   * @param args.signatures signed message MultiKeySignature\n   * @returns boolean\n   */\n  verifySignature(args: VerifyMultiKeySignatureArgs): boolean {\n    const { message, signature } = args;\n    const isSignerIndiciesSorted = this.signerIndicies.every(\n      (value, i) => i === 0 || value >= this.signerIndicies[i - 1],\n    );\n    if (!isSignerIndiciesSorted) {\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":"2KAwBO,IAAMA,EAAN,MAAMC,CAAmC,CAuC9C,YAAYC,EAAiF,CAC3F,GAAM,CAAE,SAAAC,EAAU,QAAAC,EAAS,QAAAC,CAAQ,EAAIH,EAEvC,KAAK,UAAYC,EACjB,KAAK,cAAgB,EAErB,KAAK,eAAiBE,EAAUC,EAAe,KAAKD,CAAO,EAAI,KAAK,UAAU,QAAQ,EAAE,eAAe,EAGvG,IAAME,EAAyB,CAAC,EAChC,QAAWC,KAAUJ,EACnBG,EAAa,KAAK,KAAK,UAAU,SAASC,EAAO,SAAS,CAAC,EAK7D,IAAMC,EAA6CL,EAAQ,IAAI,CAACI,EAAQE,IAAU,CAACF,EAAQD,EAAaG,CAAK,CAAC,CAAC,EAC/GD,EAAsB,KAAK,CAACE,EAAGC,IAAMD,EAAE,CAAC,EAAIC,EAAE,CAAC,CAAC,EAChD,KAAK,QAAUH,EAAsB,IAAKI,GAAUA,EAAM,CAAC,CAAC,EAC5D,KAAK,eAAiBJ,EAAsB,IAAKI,GAAUA,EAAM,CAAC,CAAC,EACnE,KAAK,iBAAmB,KAAK,UAAU,aAAa,CAAE,KAAMN,CAAa,CAAC,CAC5E,CAUA,OAAO,yBAAyBL,EAIZ,CAClB,GAAM,CAAE,WAAAY,EAAY,mBAAAC,EAAoB,QAAAX,CAAQ,EAAIF,EAC9CC,EAAW,IAAIa,EAAS,CAAE,WAAAF,EAAY,mBAAAC,CAAmB,CAAC,EAChE,OAAO,IAAId,EAAgB,CAAE,SAAAE,EAAU,QAAAC,CAAQ,CAAC,CAClD,CAEA,OAAO,iBAAiBa,EAA8C,CACpE,OAAOA,aAAmBhB,CAC5B,CAOA,sBAAsBiB,EAAiD,CACrE,OAAO,IAAIC,EAA6B,KAAK,UAAW,KAAK,KAAKD,CAAO,CAAC,CAC5E,CAOA,iCAAiCE,EAA8D,CAC7F,OAAO,IAAID,EAA6B,KAAK,UAAW,KAAK,gBAAgBC,CAAW,CAAC,CAC3F,CAOA,MAAM,mBAAoB,CAIxB,IAAMC,EAHiB,KAAK,QAAQ,OACjCb,GAAWA,aAAkBc,CAChC,EACgC,IAAI,MAAOd,GAAWA,EAAO,kBAAkB,CAAC,EAChF,MAAM,QAAQ,IAAIa,CAAQ,CAC5B,CAOA,KAAKE,EAAmC,CACtC,IAAMC,EAAa,CAAC,EACpB,QAAWhB,KAAU,KAAK,QACxBgB,EAAW,KAAKhB,EAAO,KAAKe,CAAI,CAAC,EAEnC,OAAO,IAAIE,EAAkB,CAAE,WAAAD,EAAY,OAAQ,KAAK,gBAAiB,CAAC,CAC5E,CAOA,gBAAgBJ,EAAmD,CACjE,IAAMI,EAAa,CAAC,EACpB,QAAWhB,KAAU,KAAK,QACxBgB,EAAW,KAAKhB,EAAO,gBAAgBY,CAAW,CAAC,EAErD,OAAO,IAAIK,EAAkB,CAAE,WAAAD,EAAY,OAAQ,KAAK,gBAAiB,CAAC,CAC5E,CASA,gBAAgBtB,EAA4C,CAC1D,GAAM,CAAE,QAAAgB,EAAS,UAAAQ,CAAU,EAAIxB,EAI/B,GAAI,CAH2B,KAAK,eAAe,MACjD,CAACW,EAAOc,IAAMA,IAAM,GAAKd,GAAS,KAAK,eAAec,EAAI,CAAC,CAC7D,EAEE,MAAO,GAET,QAASA,EAAI,EAAGA,EAAID,EAAU,WAAW,OAAQC,GAAK,EAAG,CACvD,IAAMC,EAAkBF,EAAU,WAAWC,CAAC,EAE9C,GAAI,CADc,KAAK,UAAU,WAAW,KAAK,eAAeA,CAAC,CAAC,EACnD,gBAAgB,CAAE,QAAAT,EAAS,UAAWU,CAAgB,CAAC,EACpE,MAAO,EAEX,CACA,MAAO,EACT,CACF","names":["MultiKeyAccount","_MultiKeyAccount","args","multiKey","signers","address","AccountAddress","bitPositions","signer","signersAndBitPosition","index","a","b","value","publicKeys","signaturesRequired","MultiKey","account","message","AccountAuthenticatorMultiKey","transaction","promises","AbstractKeylessAccount","data","signatures","MultiKeySignature","signature","i","singleSignature"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/event.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/event}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * event namespace and without having a dependency cycle error.\n */\n\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { AccountAddress, AccountAddressInput } from \"../core\";\nimport { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructId, OrderByArg, WhereArg } from \"../types\";\nimport { GetEventsQuery } from \"../types/generated/operations\";\nimport { GetEvents } from \"../types/generated/queries\";\nimport { EventsBoolExp, InputMaybe } from \"../types/generated/types\";\nimport { queryIndexer } from \"./general\";\n\nconst MAX_EVENT_TYPE_LENGTH = 300;\nconst checkEventTypeLength = (eventType?: InputMaybe<string>) => {\n  if (eventType && eventType.length > MAX_EVENT_TYPE_LENGTH) {\n    throw new Error(`Event type length exceeds the maximum length of ${MAX_EVENT_TYPE_LENGTH}`);\n  }\n};\n\nexport async function getModuleEventsByEventType(args: {\n  aptosConfig: AptosConfig;\n  eventType: MoveStructId;\n  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;\n}): Promise<GetEventsResponse> {\n  const { aptosConfig, eventType, options } = args;\n\n  const whereCondition: EventsBoolExp = {\n    _or: [\n      // EventHandle events\n      { account_address: { _eq: eventType.split(\"::\")[0] } },\n      // Module events\n      {\n        account_address: { _eq: \"0x0000000000000000000000000000000000000000000000000000000000000000\" },\n        sequence_number: { _eq: 0 },\n        creation_number: { _eq: 0 },\n      },\n    ],\n    indexed_type: { _eq: eventType },\n  };\n\n  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });\n}\n\nexport async function getAccountEventsByCreationNumber(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  creationNumber: AnyNumber;\n  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;\n}): Promise<GetEventsResponse> {\n  const { accountAddress, aptosConfig, creationNumber, options } = args;\n  const address = AccountAddress.from(accountAddress);\n\n  const whereCondition: EventsBoolExp = {\n    account_address: { _eq: address.toStringLong() },\n    creation_number: { _eq: creationNumber },\n  };\n\n  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });\n}\n\nexport async function getAccountEventsByEventType(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  eventType: MoveStructId;\n  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;\n}): Promise<GetEventsResponse> {\n  const { accountAddress, aptosConfig, eventType, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: EventsBoolExp = {\n    account_address: { _eq: address },\n    indexed_type: { _eq: eventType },\n  };\n\n  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });\n}\n\nexport async function getEvents(args: {\n  aptosConfig: AptosConfig;\n  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;\n}): Promise<GetEventsResponse> {\n  const { aptosConfig, options } = args;\n  // eslint-disable-next-line no-underscore-dangle\n  checkEventTypeLength(options?.where?.indexed_type?._eq);\n\n  const graphqlQuery = {\n    query: GetEvents,\n    variables: {\n      where_condition: options?.where,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetEventsQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getEvents\",\n  });\n\n  return data.events;\n}\n"],"mappings":"2HAkBA,IAAMA,EAAwB,IACxBC,EAAwBC,GAAmC,CAC/D,GAAIA,GAAaA,EAAU,OAASF,EAClC,MAAM,IAAI,MAAM,mDAAmDA,CAAqB,EAAE,CAE9F,EAEA,eAAsBG,EAA2BC,EAIlB,CAC7B,GAAM,CAAE,YAAAC,EAAa,UAAAH,EAAW,QAAAI,CAAQ,EAAIF,EAEtCG,EAAgC,CACpC,IAAK,CAEH,CAAE,gBAAiB,CAAE,IAAKL,EAAU,MAAM,IAAI,EAAE,CAAC,CAAE,CAAE,EAErD,CACE,gBAAiB,CAAE,IAAK,oEAAqE,EAC7F,gBAAiB,CAAE,IAAK,CAAE,EAC1B,gBAAiB,CAAE,IAAK,CAAE,CAC5B,CACF,EACA,aAAc,CAAE,IAAKA,CAAU,CACjC,EAEA,OAAOM,EAAU,CAAE,YAAAH,EAAa,QAAS,CAAE,GAAGC,EAAS,MAAOC,CAAe,CAAE,CAAC,CAClF,CAEA,eAAsBE,EAAiCL,EAKxB,CAC7B,GAAM,CAAE,eAAAM,EAAgB,YAAAL,EAAa,eAAAM,EAAgB,QAAAL,CAAQ,EAAIF,EAG3DG,EAAgC,CACpC,gBAAiB,CAAE,IAHLK,EAAe,KAAKF,CAAc,EAGhB,aAAa,CAAE,EAC/C,gBAAiB,CAAE,IAAKC,CAAe,CACzC,EAEA,OAAOH,EAAU,CAAE,YAAAH,EAAa,QAAS,CAAE,GAAGC,EAAS,MAAOC,CAAe,CAAE,CAAC,CAClF,CAEA,eAAsBM,EAA4BT,EAKnB,CAC7B,GAAM,CAAE,eAAAM,EAAgB,YAAAL,EAAa,UAAAH,EAAW,QAAAI,CAAQ,EAAIF,EAGtDG,EAAgC,CACpC,gBAAiB,CAAE,IAHLK,EAAe,KAAKF,CAAc,EAAE,aAAa,CAG/B,EAChC,aAAc,CAAE,IAAKR,CAAU,CACjC,EAEA,OAAOM,EAAU,CAAE,YAAAH,EAAa,QAAS,CAAE,GAAGC,EAAS,MAAOC,CAAe,CAAE,CAAC,CAClF,CAEA,eAAsBC,EAAUJ,EAGD,CAC7B,GAAM,CAAE,YAAAC,EAAa,QAAAC,CAAQ,EAAIF,EAEjCH,EAAqBK,GAAS,OAAO,cAAc,GAAG,EAEtD,IAAMQ,EAAe,CACnB,MAAOC,EACP,UAAW,CACT,gBAAiBT,GAAS,MAC1B,OAAQA,GAAS,OACjB,MAAOA,GAAS,MAChB,SAAUA,GAAS,OACrB,CACF,EAQA,OANa,MAAMU,EAA6B,CAC9C,YAAAX,EACA,MAAOS,EACP,aAAc,WAChB,CAAC,GAEW,MACd","names":["MAX_EVENT_TYPE_LENGTH","checkEventTypeLength","eventType","getModuleEventsByEventType","args","aptosConfig","options","whereCondition","getEvents","getAccountEventsByCreationNumber","accountAddress","creationNumber","AccountAddress","getAccountEventsByEventType","graphqlQuery","GetEvents","queryIndexer"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/ans.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Account } from \"../account\";\nimport { AccountAddress, AccountAddressInput } from \"../core\";\nimport {\n  RegisterNameParameters,\n  getExpiration,\n  getOwnerAddress,\n  registerName,\n  getPrimaryName,\n  setPrimaryName,\n  getTargetAddress,\n  setTargetAddress,\n  renewDomain,\n  getName,\n  getAccountDomains,\n  GetAccountDomainsArgs,\n  GetAccountSubdomainsArgs,\n  getAccountSubdomains,\n  getAccountNames,\n  GetAccountNamesArgs,\n  getDomainSubdomains,\n  GetDomainSubdomainsArgs,\n} from \"../internal/ans\";\nimport { GetANSNameResponse } from \"../types\";\nimport { InputGenerateTransactionOptions } from \"../transactions/types\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { SimpleTransaction } from \"../transactions/instances/simpleTransaction\";\n\n/**\n * A class to handle all `ANS` operations\n */\nexport class ANS {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Retrieve the owner address of a domain name or subdomain name from the contract.\n   *\n   * @example\n   * // Will return the owner address of \"test.aptos.apt\" or undefined\n   * const owner = await aptos.getOwnerAddress({name: \"test.aptos\"})\n   * // owner = 0x123...\n   *\n   * @param args.name - A string of the name to retrieve\n   *\n   * @returns AccountAddress if the name is owned, undefined otherwise\n   */\n  async getOwnerAddress(args: { name: string }): Promise<AccountAddress | undefined> {\n    return getOwnerAddress({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Retrieve the expiration time of a domain name or subdomain name from the contract.\n   *\n   * @example\n   * // Will return the expiration of \"test.aptos.apt\" or undefined\n   * const exp = await aptos.getExpiration({name: \"test.aptos\"})\n   * // new Date(exp) would give you the date in question: 2021-01-01T00:00:00.000Z\n   *\n   * @param args.name - A string of the name to retrieve\n   *\n   * @returns number as a unix timestamp in milliseconds.\n   */\n  async getExpiration(args: { name: string }): Promise<number | undefined> {\n    return getExpiration({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Retrieve the target address of a domain or subdomain name. This is the\n   * address the name points to for use on chain. Note, the target address can\n   * point to addresses that are not the owner of the name\n   *\n   * @example\n   * const targetAddr = await aptos.getTargetAddress({name: \"test.aptos\"})\n   * // targetAddr = 0x123...\n   *\n   * @param args.name - A string of the name: primary, primary.apt, secondary.primary, secondary.primary.apt, etc.\n   *\n   * @returns AccountAddress if the name has a target, undefined otherwise\n   */\n  async getTargetAddress(args: { name: string }): Promise<AccountAddress | undefined> {\n    return getTargetAddress({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Sets the target address of a domain or subdomain name. This is the\n   * address the name points to for use on chain. Note, the target address can\n   * point to addresses that are not the owner of the name\n   *\n   * @example\n   * await aptos.setTargetAddress({sender: alice, name: \"test.aptos\", address: bob.accountAddress})\n   * const address = await aptos.getTargetAddress({name: \"test.aptos\"})\n   * // address = bob.accountAddress\n   *\n   * @param args.name - A string of the name: test.aptos.apt, test.apt, test, test.aptos, etc.\n   * @param args.address - A AccountAddressInput of the address to set the domain or subdomain to\n   *\n   * @returns SimpleTransaction\n   */\n  async setTargetAddress(args: {\n    sender: Account;\n    name: string;\n    address: AccountAddressInput;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SimpleTransaction> {\n    return setTargetAddress({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Retrieve the primary name for an account. An account can have\n   * multiple names that target it, but only a single name that is primary. An\n   * account also may not have a primary name.\n   *\n   * @example\n   * const name = await aptos.getPrimaryName({address: alice.accountAddress})\n   * // name = test.aptos\n   *\n   * @param args.address - A AccountAddressInput (address) of the account\n   *\n   * @returns a string if the account has a primary name, undefined otherwise\n   */\n  async getPrimaryName(args: { address: AccountAddressInput }): Promise<string | undefined> {\n    return getPrimaryName({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Sets the primary name for the sender. An account can have\n   * multiple names that target it, but only a single name that is primary. An\n   * account also may not have a primary name.\n   *\n   * @example\n   * await aptos.setPrimaryName({sender: alice, name: \"test.aptos\"})\n   * const primaryName = await aptos.getPrimaryName({address: alice.accountAddress})\n   * // primaryName = test.aptos\n   *\n   * @param args.sender - The sender account\n   * @param args.name - A string of the name: test, test.apt, test.aptos, test.aptos.apt, etc.\n   *\n   * @returns SimpleTransaction\n   */\n  async setPrimaryName(args: {\n    sender: Account;\n    name?: string;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SimpleTransaction> {\n    return setPrimaryName({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Registers a new name\n   *\n   * @example\n   * // An example of registering a subdomain name assuming def.apt is already registered\n   * // and belongs to the sender alice.\n   *  const txn = aptos.registerName({\n   *    sender: alice,\n   *    name: \"test.aptos.apt\",\n   *    expiration: {\n   *      policy: \"subdomain:independent\",\n   *      expirationDate: Date.now() + 30 * 24 * 60 * 60 * 1000,\n   *    },\n   *  });\n   *\n   * @param args.sender - The sender account\n   * @param args.name - A string of the name to register. This can be inclusive or exclusive of the .apt suffix.\n   * Examples include: \"test\", \"test.apt\", \"test.aptos.apt\", etc.\n   * @param args.expiration  - An object with the expiration policy of the name.\n   * @param args.expiration.policy - 'domain' | 'subdomain:follow-domain' | 'subdomain:independent'\n   * - domain: Years is required and the name will expire after the given number of years.\n   * - subdomain:follow-domain: The name will expire at the same time as the domain name.\n   * - subdomain:independent: The name will expire at the given date.\n   * @param args.expiration.expirationDate - An epoch number in milliseconds of\n   * the date when the subdomain will expire. Only applicable when the policy is\n   * set to 'subdomain:independent'.\n   * @param args.transferable  - Determines if the subdomain being minted is soul-bound. Applicable only to subdomains.\n   * @param args.targetAddress optional - The address the domain name will resolve to. If not provided,\n   * the sender's address will be used.\n   * @param args.toAddress optional - The address to send the domain name to. If not provided,\n   * the transaction will be sent to the router.\n   *\n   * @returns SimpleTransaction\n   */\n  async registerName(args: Omit<RegisterNameParameters, \"aptosConfig\">): Promise<SimpleTransaction> {\n    return registerName({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Renews a domain name\n   *\n   * Note: If a domain name was minted with V1 of the contract, it will automatically be upgraded to V2 via this transaction.\n   *\n   * @example\n   * await aptos.renewDomain({sender: alice, name: \"test\"})\n   * // test.apt will be renewed for one year\n   *\n   * @param args.sender - The sender account\n   * @param args.name - A string of the domain the subdomain will be under. The signer must be the domain owner.\n   * Subdomains cannot be renewed.\n   * @param args.years - The number of years to renew the name. Currently only one year is permitted.\n   *\n   * @returns SimpleTransaction\n   */\n  async renewDomain(args: {\n    sender: Account;\n    name: string;\n    years?: 1;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SimpleTransaction> {\n    return renewDomain({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Fetches a single name from the indexer\n   * @param args.name - A string of the name to retrieve, e.g. \"test.aptos.apt\"\n   * or \"test.apt\" or \"test\". Can be inclusive or exclusive of the .apt suffix.\n   * Can be a subdomain.\n   *\n   * @returns A promise of an ANSName or undefined\n   */\n  async getName(args: { name: string }): Promise<GetANSNameResponse[0] | undefined> {\n    return getName({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Fetches all  names for an account (both top level domains and subdomains)\n   *\n   * @param args\n   * @param args.accountAddress - A AccountAddressInput of the address to retrieve names for.\n   * @param args.options.offset - Optional, the offset to start from when fetching names\n   * @param args.options.limit - Optional, A number of the names to fetch per request\n   * @param args.options.orderBy - The order to sort the names by\n   * @param args.options.where - Additional filters to apply to the query\n   *\n   * @returns a promise of an array of ANSName\n   */\n  async getAccountNames(args: GetAccountNamesArgs): Promise<GetANSNameResponse> {\n    return getAccountNames({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Fetches all top level domain names for an account\n   *\n   * @param args\n   * @param args.accountAddress - A AccountAddressInput of the address to retrieve domain names for.\n   * @param args.options.offset - Optional, the offset to start from when fetching names\n   * @param args.options.limit - Optional, A number of the names to fetch per request\n   * @param args.options.orderBy - The order to sort the names by\n   * @param args.options.where - Additional filters to apply to the query\n   *\n   * @returns a promise of an array of ANSName\n   */\n  async getAccountDomains(args: GetAccountDomainsArgs): Promise<GetANSNameResponse> {\n    return getAccountDomains({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Fetches all subdomains names for an account\n   *\n   * @param args\n   * @param args.accountAddress - A AccountAddressInput of the address to retrieve subdomains names for.\n   * @param args.options.offset - Optional, the offset to start from when fetching names\n   * @param args.options.limit - Optional, A number of the names to fetch per request\n   * @param args.options.orderBy - The order to sort the names by\n   * @param args.options.where - Additional filters to apply to the query\n   *\n   * @returns a promise of an array of ANSName\n   */\n  async getAccountSubdomains(args: GetAccountSubdomainsArgs): Promise<GetANSNameResponse> {\n    return getAccountSubdomains({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Fetches all subdomains names for a given domain. Note, this will not return the domain itself.\n   *\n   * @param args\n   * @param args.domain - A string of the domain name: eg. \"test.apt\" or \"test\" (without the suffix of .apt)\n   * @param args.options.offset - Optional, the offset to start from when fetching names\n   * @param args.options.limit - Optional, A number of the names to fetch per request\n   * @param args.options.orderBy - The order to sort the names by\n   * @param args.options.where - Additional filters to apply to the query\n   *\n   * @returns a promise of an array of ANSName\n   */\n  async getDomainSubdomains(args: GetDomainSubdomainsArgs): Promise<GetANSNameResponse> {\n    return getDomainSubdomains({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"6HAiCO,IAAMA,EAAN,KAAU,CACf,YAAqBC,EAAqB,CAArB,YAAAA,CAAsB,CAc3C,MAAM,gBAAgBC,EAA6D,CACjF,OAAOC,EAAgB,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CAC9D,CAcA,MAAM,cAAcA,EAAqD,CACvE,OAAOE,EAAc,CAAE,YAAa,KAAK,OAAQ,GAAGF,CAAK,CAAC,CAC5D,CAeA,MAAM,iBAAiBA,EAA6D,CAClF,OAAOG,EAAiB,CAAE,YAAa,KAAK,OAAQ,GAAGH,CAAK,CAAC,CAC/D,CAiBA,MAAM,iBAAiBA,EAKQ,CAC7B,OAAOI,EAAiB,CAAE,YAAa,KAAK,OAAQ,GAAGJ,CAAK,CAAC,CAC/D,CAeA,MAAM,eAAeA,EAAqE,CACxF,OAAOK,EAAe,CAAE,YAAa,KAAK,OAAQ,GAAGL,CAAK,CAAC,CAC7D,CAiBA,MAAM,eAAeA,EAIU,CAC7B,OAAOM,EAAe,CAAE,YAAa,KAAK,OAAQ,GAAGN,CAAK,CAAC,CAC7D,CAoCA,MAAM,aAAaA,EAA+E,CAChG,OAAOO,EAAa,CAAE,YAAa,KAAK,OAAQ,GAAGP,CAAK,CAAC,CAC3D,CAkBA,MAAM,YAAYA,EAKa,CAC7B,OAAOQ,EAAY,CAAE,YAAa,KAAK,OAAQ,GAAGR,CAAK,CAAC,CAC1D,CAUA,MAAM,QAAQA,EAAoE,CAChF,OAAOS,EAAQ,CAAE,YAAa,KAAK,OAAQ,GAAGT,CAAK,CAAC,CACtD,CAcA,MAAM,gBAAgBA,EAAwD,CAC5E,OAAOU,EAAgB,CAAE,YAAa,KAAK,OAAQ,GAAGV,CAAK,CAAC,CAC9D,CAcA,MAAM,kBAAkBA,EAA0D,CAChF,OAAOW,EAAkB,CAAE,YAAa,KAAK,OAAQ,GAAGX,CAAK,CAAC,CAChE,CAcA,MAAM,qBAAqBA,EAA6D,CACtF,OAAOY,EAAqB,CAAE,YAAa,KAAK,OAAQ,GAAGZ,CAAK,CAAC,CACnE,CAcA,MAAM,oBAAoBA,EAA4D,CACpF,OAAOa,EAAoB,CAAE,YAAa,KAAK,OAAQ,GAAGb,CAAK,CAAC,CAClE,CACF","names":["ANS","config","args","getOwnerAddress","getExpiration","getTargetAddress","setTargetAddress","getPrimaryName","setPrimaryName","registerName","renewDomain","getName","getAccountNames","getAccountDomains","getAccountSubdomains","getDomainSubdomains"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/utils.ts"],"sourcesContent":["import { waitForIndexer } from \"../internal/transaction\";\nimport { ProcessorType } from \"../utils\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { AnyNumber } from \"../types\";\n\n/**\n * Utility function to handle optional waiting on indexer for APIs\n *\n * This is purposely placed here to not expose this internal function.\n * @param args\n */\nexport async function waitForIndexerOnVersion(args: {\n  config: AptosConfig;\n  minimumLedgerVersion?: AnyNumber;\n  processorType: ProcessorType;\n}) {\n  if (args.minimumLedgerVersion !== undefined) {\n    await waitForIndexer({\n      aptosConfig: args.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: args.processorType,\n    });\n  }\n}\n"],"mappings":"yCAWA,eAAsBA,EAAwBC,EAI3C,CACGA,EAAK,uBAAyB,QAChC,MAAMC,EAAe,CACnB,YAAaD,EAAK,OAClB,qBAAsBA,EAAK,qBAC3B,cAAeA,EAAK,aACtB,CAAC,CAEL","names":["waitForIndexerOnVersion","args","waitForIndexer"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/poseidon.ts"],"sourcesContent":["/* eslint-disable no-bitwise */\nimport {\n  poseidon1,\n  poseidon2,\n  poseidon3,\n  poseidon4,\n  poseidon5,\n  poseidon6,\n  poseidon7,\n  poseidon8,\n  poseidon9,\n  poseidon10,\n  poseidon11,\n  poseidon12,\n  poseidon13,\n  poseidon14,\n  poseidon15,\n  poseidon16,\n} from \"poseidon-lite\";\n\nconst numInputsToPoseidonFunc = [\n  poseidon1,\n  poseidon2,\n  poseidon3,\n  poseidon4,\n  poseidon5,\n  poseidon6,\n  poseidon7,\n  poseidon8,\n  poseidon9,\n  poseidon10,\n  poseidon11,\n  poseidon12,\n  poseidon13,\n  poseidon14,\n  poseidon15,\n  poseidon16,\n];\n\nconst BYTES_PACKED_PER_SCALAR = 31;\nconst MAX_NUM_INPUT_SCALARS = 16;\nconst MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;\n\n/**\n * Hashes a string to a field element via poseidon\n *\n * @returns bigint result of the hash\n */\nexport function hashStrToField(str: string, maxSizeBytes: number): bigint {\n  const textEncoder = new TextEncoder();\n  const strBytes = textEncoder.encode(str);\n  return hashBytesWithLen(strBytes, maxSizeBytes);\n}\n\nfunction hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint {\n  if (bytes.length > maxSizeBytes) {\n    throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);\n  }\n  const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);\n  return poseidonHash(packed);\n}\n\nfunction padAndPackBytesNoLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {\n  if (bytes.length > maxSizeBytes) {\n    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);\n  }\n  const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);\n  return packBytes(paddedStrBytes);\n}\n\nexport function padAndPackBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {\n  if (bytes.length > maxSizeBytes) {\n    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);\n  }\n  return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);\n}\n\nfunction packBytes(bytes: Uint8Array): bigint[] {\n  if (bytes.length > MAX_NUM_INPUT_BYTES) {\n    throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);\n  }\n  return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));\n}\n\nfunction chunkUint8Array(array: Uint8Array, chunkSize: number): Uint8Array[] {\n  const result: Uint8Array[] = [];\n  for (let i = 0; i < array.length; i += chunkSize) {\n    result.push(array.subarray(i, i + chunkSize));\n  }\n  return result;\n}\n\nexport function bytesToBigIntLE(bytes: Uint8Array): bigint {\n  let result = BigInt(0);\n  for (let i = bytes.length - 1; i >= 0; i -= 1) {\n    result = (result << BigInt(8)) | BigInt(bytes[i]);\n  }\n  return result;\n}\n\nexport function bigIntToBytesLE(value: bigint | number, length: number): Uint8Array {\n  let val = BigInt(value);\n  const bytes = new Uint8Array(length);\n  for (let i = 0; i < length; i += 1) {\n    bytes[i] = Number(val & BigInt(0xff));\n    val >>= BigInt(8);\n  }\n  return bytes;\n}\n\nfunction padUint8ArrayWithZeros(inputArray: Uint8Array, paddedSize: number): Uint8Array {\n  if (paddedSize < inputArray.length) {\n    throw new Error(\"Padded size must be greater than or equal to the input array size.\");\n  }\n\n  // Create a new Uint8Array with the padded size\n  const paddedArray = new Uint8Array(paddedSize);\n\n  // Copy the content of the input array to the new array\n  paddedArray.set(inputArray);\n\n  // Fill the remaining space with zeros\n  for (let i = inputArray.length; i < paddedSize; i += 1) {\n    paddedArray[i] = 0;\n  }\n\n  return paddedArray;\n}\n\n/**\n * Hashes up to 16 scalar elements via the poseidon hashing algorithm.\n *\n * Each element must be scalar fields of the BN254 elliptic curve group.\n *\n * @returns bigint result of the hash\n */\nexport function poseidonHash(inputs: (number | bigint | string)[]): bigint {\n  if (inputs.length > numInputsToPoseidonFunc.length) {\n    throw new Error(\n      `Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`,\n    );\n  }\n  return numInputsToPoseidonFunc[inputs.length - 1](inputs);\n}\n"],"mappings":"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","names":["poseidon1","poseidon2","poseidon3","poseidon4","poseidon5","poseidon6","poseidon7","poseidon8","poseidon9","poseidon10","poseidon11","poseidon12","poseidon13","poseidon14","poseidon15","poseidon16","numInputsToPoseidonFunc","BYTES_PACKED_PER_SCALAR","MAX_NUM_INPUT_SCALARS","MAX_NUM_INPUT_BYTES","hashStrToField","str","maxSizeBytes","strBytes","hashBytesWithLen","bytes","packed","padAndPackBytesWithLen","poseidonHash","padAndPackBytesNoLen","paddedStrBytes","padUint8ArrayWithZeros","packBytes","chunkUint8Array","chunk","bytesToBigIntLE","array","chunkSize","result","i","bigIntToBytesLE","value","length","val","inputArray","paddedSize","paddedArray","inputs"]}

package/dist/esm/chunk-STUXKQVZ.mjs

@@ -1,2 +0,0 @@
-import{a as P}from"./chunk-D3Q4BC3I.mjs";import{c as d}from"./chunk-2BTTX2KO.mjs";import{d as h,e as w,f as k,g as T,i as b,j as q,k as v,u as O}from"./chunk-VHNX2NUR.mjs";import{a as f}from"./chunk-QPB6EJVM.mjs";import{a as C}from"./chunk-GMBSQDPO.mjs";import{b as y}from"./chunk-GDO6Q2FI.mjs";import{c as l}from"./chunk-GWSDIX6C.mjs";import{a as g}from"./chunk-G5MGSV7Y.mjs";import{b as a}from"./chunk-OHRL766V.mjs";import{a as _}from"./chunk-AH44UPM4.mjs";import{b as A,d as p}from"./chunk-YU3IYJRL.mjs";import{a as m}from"./chunk-TDGQGILY.mjs";async function S(e){let{aptosConfig:n,accountAddress:t}=e,{data:o}=await A({aptosConfig:n,originMethod:"getInfo",path:`accounts/${a.from(t).toString()}`});return o}async function z(e){let{aptosConfig:n,accountAddress:t,options:o}=e;return p({aptosConfig:n,originMethod:"getModules",path:`accounts/${a.from(t).toString()}/modules`,params:{ledger_version:o?.ledgerVersion,start:o?.offset,limit:o?.limit??1e3}})}async function H(e){return e.options?.ledgerVersion!==void 0?G(e):_(async()=>G(e),`module-${e.accountAddress}-${e.moduleName}`,1e3*60*5)()}async function G(e){let{aptosConfig:n,accountAddress:t,moduleName:o,options:s}=e,{data:r}=await A({aptosConfig:n,originMethod:"getModule",path:`accounts/${a.from(t).toString()}/module/${o}`,params:{ledger_version:s?.ledgerVersion}});return r}async function J(e){let{aptosConfig:n,accountAddress:t,options:o}=e;return p({aptosConfig:n,originMethod:"getTransactions",path:`accounts/${a.from(t).toString()}/transactions`,params:{start:o?.offset,limit:o?.limit}})}async function U(e){let{aptosConfig:n,accountAddress:t,options:o}=e;return p({aptosConfig:n,originMethod:"getResources",path:`accounts/${a.from(t).toString()}/resources`,params:{ledger_version:o?.ledgerVersion,start:o?.offset,limit:o?.limit??999}})}async function K(e){let{aptosConfig:n,accountAddress:t,resourceType:o,options:s}=e,{data:r}=await A({aptosConfig:n,originMethod:"getResource",path:`accounts/${a.from(t).toString()}/resource/${o}`,params:{ledger_version:s?.ledgerVersion}});return r.data}async function Q(e){let{aptosConfig:n,authenticationKey:t,options:o}=e,s=await K({aptosConfig:n,accountAddress:"0x1",resourceType:"0x1::account::OriginatingAddress",options:o}),{address_map:{handle:r}}=s,c=a.from(t);try{let i=await P({aptosConfig:n,handle:r,data:{key:c.toString(),key_type:"address",value_type:"address"},options:o});return a.from(i)}catch(i){if(i instanceof m&&i.data.error_code==="table_item_not_found")return c;throw i}}async function X(e){let{aptosConfig:n,accountAddress:t}=e,s={owner_address:{_eq:a.from(t).toStringLong()},amount:{_gt:0}},c=await d({aptosConfig:n,query:{query:q,variables:{where_condition:s}},originMethod:"getAccountTokensCount"});return c.current_token_ownerships_v2_aggregate.aggregate?c.current_token_ownerships_v2_aggregate.aggregate.count:0}async function Y(e){let{aptosConfig:n,accountAddress:t,options:o}=e,r={owner_address:{_eq:a.from(t).toStringLong()},amount:{_gt:0}};o?.tokenStandard&&(r.token_standard={_eq:o?.tokenStandard});let c={query:T,variables:{where_condition:r,offset:o?.offset,limit:o?.limit,order_by:o?.orderBy}};return(await d({aptosConfig:n,query:c,originMethod:"getAccountOwnedTokens"})).current_token_ownerships_v2}async function Z(e){let{aptosConfig:n,accountAddress:t,collectionAddress:o,options:s}=e,r=a.from(t).toStringLong(),c=a.from(o).toStringLong(),i={owner_address:{_eq:r},current_token_data:{collection_id:{_eq:c}},amount:{_gt:0}};s?.tokenStandard&&(i.token_standard={_eq:s?.tokenStandard});let u={query:b,variables:{where_condition:i,offset:s?.offset,limit:s?.limit,order_by:s?.orderBy}};return(await d({aptosConfig:n,query:u,originMethod:"getAccountOwnedTokensFromCollectionAddress"})).current_token_ownerships_v2}async function oo(e){let{aptosConfig:n,accountAddress:t,options:o}=e,r={owner_address:{_eq:a.from(t).toStringLong()}};o?.tokenStandard&&(r.current_collection={token_standard:{_eq:o?.tokenStandard}});let c={query:k,variables:{where_condition:r,offset:o?.offset,limit:o?.limit,order_by:o?.orderBy}};return(await d({aptosConfig:n,query:c,originMethod:"getAccountCollectionsWithOwnedTokens"})).current_collection_ownership_v2_view}async function eo(e){let{aptosConfig:n,accountAddress:t}=e,o=a.from(t).toStringLong(),r=await d({aptosConfig:n,query:{query:v,variables:{address:o}},originMethod:"getAccountTransactionsCount"});return r.account_transactions_aggregate.aggregate?r.account_transactions_aggregate.aggregate.count:0}async function to(e){let{aptosConfig:n,accountAddress:t,options:o}=e,s=a.from(t).toStringLong(),r={...o?.where,owner_address:{_eq:s}},c={query:w,variables:{where_condition:r,offset:o?.offset,limit:o?.limit,order_by:o?.orderBy}};return(await d({aptosConfig:n,query:c,originMethod:"getAccountCoinsData"})).current_fungible_asset_balances}async function no(e){let{aptosConfig:n,accountAddress:t}=e,o=a.from(t).toStringLong(),r=await d({aptosConfig:n,query:{query:h,variables:{address:o}},originMethod:"getAccountCoinsCount"});if(!r.current_fungible_asset_balances_aggregate.aggregate)throw Error("Failed to get the count of account coins");return r.current_fungible_asset_balances_aggregate.aggregate.count}async function ro(e){let{aptosConfig:n,accountAddress:t,options:o}=e,r={owner_address:{_eq:a.from(t).toStringLong()}},c={query:O,variables:{where_condition:r,offset:o?.offset,limit:o?.limit,order_by:o?.orderBy}};return(await d({aptosConfig:n,query:c,originMethod:"getAccountOwnedObjects"})).current_objects}async function so(e){let{aptosConfig:n,privateKey:t}=e,o=new C(t.publicKey());if(t instanceof y){let r=g.fromPublicKey({publicKey:o}).derivedAddress();return f.fromPrivateKey({privateKey:t,address:r})}if(t instanceof l){let s=g.fromPublicKey({publicKey:o});if(await M({authKey:s,aptosConfig:n})){let u=s.derivedAddress();return f.fromPrivateKey({privateKey:t,address:u,legacy:!1})}let c=g.fromPublicKey({publicKey:o.publicKey});if(await M({authKey:c,aptosConfig:n})){let u=c.derivedAddress();return f.fromPrivateKey({privateKey:t,address:u,legacy:!0})}}throw new Error(`Can't derive account from private key ${t}`)}async function M(e){let{aptosConfig:n,authKey:t}=e,o=await Q({aptosConfig:n,authenticationKey:t.derivedAddress()});try{return await S({aptosConfig:n,accountAddress:o}),!0}catch(s){if(s.status===404)return!1;throw new Error(`Error while looking for an account info ${o.toString()}`)}}export{S as a,z as b,H as c,J as d,U as e,K as f,Q as g,X as h,Y as i,Z as j,oo as k,eo as l,to as m,no as n,ro as o,so as p,M as q};
-//# sourceMappingURL=chunk-STUXKQVZ.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/account.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/account}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * account namespace and without having a dependency cycle error.\n */\n\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { AptosApiError, getAptosFullNode, paginateWithCursor } from \"../client\";\nimport { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { Account } from \"../account\";\nimport { AnyPublicKey, Ed25519PublicKey, PrivateKey } from \"../core/crypto\";\nimport { queryIndexer } from \"./general\";\nimport {\n  AccountData,\n  GetAccountCoinsDataResponse,\n  GetAccountCollectionsWithOwnedTokenResponse,\n  GetAccountOwnedTokensFromCollectionResponse,\n  GetAccountOwnedTokensQueryResponse,\n  GetObjectDataQueryResponse,\n  LedgerVersionArg,\n  MoveModuleBytecode,\n  MoveResource,\n  MoveStructId,\n  OrderByArg,\n  PaginationArgs,\n  TokenStandardArg,\n  TransactionResponse,\n  WhereArg,\n} from \"../types\";\nimport {\n  GetAccountCoinsCountQuery,\n  GetAccountCoinsDataQuery,\n  GetAccountCollectionsWithOwnedTokensQuery,\n  GetObjectDataQuery,\n  GetAccountOwnedTokensFromCollectionQuery,\n  GetAccountOwnedTokensQuery,\n  GetAccountTokensCountQuery,\n  GetAccountTransactionsCountQuery,\n} from \"../types/generated/operations\";\nimport {\n  GetAccountCoinsCount,\n  GetAccountCoinsData,\n  GetAccountCollectionsWithOwnedTokens,\n  GetObjectData,\n  GetAccountOwnedTokens,\n  GetAccountOwnedTokensFromCollection,\n  GetAccountTokensCount,\n  GetAccountTransactionsCount,\n} from \"../types/generated/queries\";\nimport { memoizeAsync } from \"../utils/memoize\";\nimport { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey } from \"../core\";\nimport { CurrentFungibleAssetBalancesBoolExp } from \"../types/generated/types\";\nimport { getTableItem } from \"./table\";\n\nexport async function getInfo(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<AccountData> {\n  const { aptosConfig, accountAddress } = args;\n  const { data } = await getAptosFullNode<{}, AccountData>({\n    aptosConfig,\n    originMethod: \"getInfo\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}`,\n  });\n  return data;\n}\n\nexport async function getModules(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs & LedgerVersionArg;\n}): Promise<MoveModuleBytecode[]> {\n  const { aptosConfig, accountAddress, options } = args;\n  return paginateWithCursor<{}, MoveModuleBytecode[]>({\n    aptosConfig,\n    originMethod: \"getModules\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,\n    params: {\n      ledger_version: options?.ledgerVersion,\n      start: options?.offset,\n      limit: options?.limit ?? 1000,\n    },\n  });\n}\n\n/**\n * Queries for a move module given account address and module name\n *\n * @param args.accountAddress Hex-encoded 32 byte Aptos account address\n * @param args.moduleName The name of the module\n * @param args.query.ledgerVersion Specifies ledger version of transactions. By default, latest version will be used\n * @returns The move module.\n */\nexport async function getModule(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  moduleName: string;\n  options?: LedgerVersionArg;\n}): Promise<MoveModuleBytecode> {\n  // We don't memoize the account module by ledger version, as it's not a common use case, this would be handled\n  // by the developer directly\n  if (args.options?.ledgerVersion !== undefined) {\n    return getModuleInner(args);\n  }\n\n  return memoizeAsync(\n    async () => getModuleInner(args),\n    `module-${args.accountAddress}-${args.moduleName}`,\n    1000 * 60 * 5, // 5 minutes\n  )();\n}\n\nasync function getModuleInner(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  moduleName: string;\n  options?: LedgerVersionArg;\n}): Promise<MoveModuleBytecode> {\n  const { aptosConfig, accountAddress, moduleName, options } = args;\n\n  const { data } = await getAptosFullNode<{}, MoveModuleBytecode>({\n    aptosConfig,\n    originMethod: \"getModule\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,\n    params: { ledger_version: options?.ledgerVersion },\n  });\n  return data;\n}\n\nexport async function getTransactions(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs;\n}): Promise<TransactionResponse[]> {\n  const { aptosConfig, accountAddress, options } = args;\n  return paginateWithCursor<{}, TransactionResponse[]>({\n    aptosConfig,\n    originMethod: \"getTransactions\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/transactions`,\n    params: { start: options?.offset, limit: options?.limit },\n  });\n}\n\nexport async function getResources(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs & LedgerVersionArg;\n}): Promise<MoveResource[]> {\n  const { aptosConfig, accountAddress, options } = args;\n  return paginateWithCursor<{}, MoveResource[]>({\n    aptosConfig,\n    originMethod: \"getResources\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resources`,\n    params: {\n      ledger_version: options?.ledgerVersion,\n      start: options?.offset,\n      limit: options?.limit ?? 999,\n    },\n  });\n}\n\nexport async function getResource<T extends {}>(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  resourceType: MoveStructId;\n  options?: LedgerVersionArg;\n}): Promise<T> {\n  const { aptosConfig, accountAddress, resourceType, options } = args;\n  const { data } = await getAptosFullNode<{}, MoveResource>({\n    aptosConfig,\n    originMethod: \"getResource\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resource/${resourceType}`,\n    params: { ledger_version: options?.ledgerVersion },\n  });\n  return data.data as T;\n}\n\nexport async function lookupOriginalAccountAddress(args: {\n  aptosConfig: AptosConfig;\n  authenticationKey: AccountAddressInput;\n  options?: LedgerVersionArg;\n}): Promise<AccountAddress> {\n  const { aptosConfig, authenticationKey, options } = args;\n  type OriginatingAddress = {\n    address_map: { handle: string };\n  };\n  const resource = await getResource<OriginatingAddress>({\n    aptosConfig,\n    accountAddress: \"0x1\",\n    resourceType: \"0x1::account::OriginatingAddress\",\n    options,\n  });\n\n  const {\n    address_map: { handle },\n  } = resource;\n\n  const authKeyAddress = AccountAddress.from(authenticationKey);\n\n  // If the address is not found in the address map, which means its not rotated\n  // then return the address as is\n  try {\n    const originalAddress = await getTableItem<string>({\n      aptosConfig,\n      handle,\n      data: {\n        key: authKeyAddress.toString(),\n        key_type: \"address\",\n        value_type: \"address\",\n      },\n      options,\n    });\n\n    return AccountAddress.from(originalAddress);\n  } catch (err) {\n    if (err instanceof AptosApiError && err.data.error_code === \"table_item_not_found\") {\n      return authKeyAddress;\n    }\n\n    throw err;\n  }\n}\n\nexport async function getAccountTokensCount(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, accountAddress } = args;\n\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: { owner_address: { _eq: string }; amount: { _gt: number } } = {\n    owner_address: { _eq: address },\n    amount: { _gt: 0 },\n  };\n\n  const graphqlQuery = {\n    query: GetAccountTokensCount,\n    variables: { where_condition: whereCondition },\n  };\n\n  const data = await queryIndexer<GetAccountTokensCountQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountTokensCount\",\n  });\n\n  // commonjs (aka cjs) doesnt handle Nullish Coalescing for some reason\n  // might be because of how ts infer the graphql generated scheme type\n  return data.current_token_ownerships_v2_aggregate.aggregate\n    ? data.current_token_ownerships_v2_aggregate.aggregate.count\n    : 0;\n}\n\nexport async function getAccountOwnedTokens(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;\n}): Promise<GetAccountOwnedTokensQueryResponse> {\n  const { aptosConfig, accountAddress, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: { owner_address: { _eq: string }; amount: { _gt: number }; token_standard?: { _eq: string } } =\n    {\n      owner_address: { _eq: address },\n      amount: { _gt: 0 },\n    };\n\n  if (options?.tokenStandard) {\n    whereCondition.token_standard = { _eq: options?.tokenStandard };\n  }\n\n  const graphqlQuery = {\n    query: GetAccountOwnedTokens,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetAccountOwnedTokensQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountOwnedTokens\",\n  });\n\n  return data.current_token_ownerships_v2;\n}\n\nexport async function getAccountOwnedTokensFromCollectionAddress(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  collectionAddress: AccountAddressInput;\n  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;\n}): Promise<GetAccountOwnedTokensFromCollectionResponse> {\n  const { aptosConfig, accountAddress, collectionAddress, options } = args;\n  const ownerAddress = AccountAddress.from(accountAddress).toStringLong();\n  const collAddress = AccountAddress.from(collectionAddress).toStringLong();\n\n  const whereCondition: {\n    owner_address: { _eq: string };\n    current_token_data: { collection_id: { _eq: string } };\n    amount: { _gt: number };\n    token_standard?: { _eq: string };\n  } = {\n    owner_address: { _eq: ownerAddress },\n    current_token_data: { collection_id: { _eq: collAddress } },\n    amount: { _gt: 0 },\n  };\n\n  if (options?.tokenStandard) {\n    whereCondition.token_standard = { _eq: options?.tokenStandard };\n  }\n\n  const graphqlQuery = {\n    query: GetAccountOwnedTokensFromCollection,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetAccountOwnedTokensFromCollectionQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountOwnedTokensFromCollectionAddress\",\n  });\n\n  return data.current_token_ownerships_v2;\n}\n\nexport async function getAccountCollectionsWithOwnedTokens(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;\n}): Promise<GetAccountCollectionsWithOwnedTokenResponse> {\n  const { aptosConfig, accountAddress, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: {\n    owner_address: { _eq: string };\n    current_collection?: { token_standard: { _eq: string } };\n  } = {\n    owner_address: { _eq: address },\n  };\n\n  if (options?.tokenStandard) {\n    whereCondition.current_collection = {\n      token_standard: { _eq: options?.tokenStandard },\n    };\n  }\n\n  const graphqlQuery = {\n    query: GetAccountCollectionsWithOwnedTokens,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetAccountCollectionsWithOwnedTokensQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountCollectionsWithOwnedTokens\",\n  });\n\n  return data.current_collection_ownership_v2_view;\n}\n\nexport async function getAccountTransactionsCount(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, accountAddress } = args;\n\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const graphqlQuery = {\n    query: GetAccountTransactionsCount,\n    variables: { address },\n  };\n\n  const data = await queryIndexer<GetAccountTransactionsCountQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountTransactionsCount\",\n  });\n\n  // commonjs (aka cjs) doesnt handle Nullish Coalescing for some reason\n  // might be because of how ts infer the graphql generated scheme type\n  return data.account_transactions_aggregate.aggregate ? data.account_transactions_aggregate.aggregate.count : 0;\n}\n\nexport async function getAccountCoinsData(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;\n}): Promise<GetAccountCoinsDataResponse> {\n  const { aptosConfig, accountAddress, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: { owner_address: { _eq: string } } = {\n    ...options?.where,\n    owner_address: { _eq: address },\n  };\n\n  const graphqlQuery = {\n    query: GetAccountCoinsData,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetAccountCoinsDataQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountCoinsData\",\n  });\n\n  return data.current_fungible_asset_balances;\n}\n\nexport async function getAccountCoinsCount(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, accountAddress } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const graphqlQuery = {\n    query: GetAccountCoinsCount,\n    variables: { address },\n  };\n\n  const data = await queryIndexer<GetAccountCoinsCountQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountCoinsCount\",\n  });\n\n  if (!data.current_fungible_asset_balances_aggregate.aggregate) {\n    throw Error(\"Failed to get the count of account coins\");\n  }\n\n  return data.current_fungible_asset_balances_aggregate.aggregate.count;\n}\n\nexport async function getAccountOwnedObjects(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;\n}): Promise<GetObjectDataQueryResponse> {\n  const { aptosConfig, accountAddress, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: { owner_address: { _eq: string } } = {\n    owner_address: { _eq: address },\n  };\n  const graphqlQuery = {\n    query: GetObjectData,\n    variables: {\n      where_condition: whereCondition,\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: \"getAccountOwnedObjects\",\n  });\n\n  return data.current_objects;\n}\n\n/**\n * NOTE: There is a potential issue once unified single signer scheme will be adopted\n * by the community.\n *\n * Becuase on could create 2 accounts with the same private key with this new authenticator type,\n * we’ll need to determine the order in which we lookup the accounts. First unified\n * scheme and then legacy scheme vs first legacy scheme and then unified scheme.\n *\n */\nexport async function deriveAccountFromPrivateKey(args: {\n  aptosConfig: AptosConfig;\n  privateKey: PrivateKey;\n}): Promise<Account> {\n  const { aptosConfig, privateKey } = args;\n  const publicKey = new AnyPublicKey(privateKey.publicKey());\n\n  if (privateKey instanceof Secp256k1PrivateKey) {\n    // private key is secp256k1, therefore we know it for sure uses a single signer key\n    const authKey = AuthenticationKey.fromPublicKey({ publicKey });\n    const address = authKey.derivedAddress();\n    return Account.fromPrivateKey({ privateKey, address });\n  }\n\n  if (privateKey instanceof Ed25519PrivateKey) {\n    // lookup single sender ed25519\n    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKey({\n      publicKey,\n    });\n    const isSingleSenderTransactionAuthenticator = await isAccountExist({\n      authKey: singleSenderTransactionAuthenticatorAuthKey,\n      aptosConfig,\n    });\n    if (isSingleSenderTransactionAuthenticator) {\n      const address = singleSenderTransactionAuthenticatorAuthKey.derivedAddress();\n      return Account.fromPrivateKey({ privateKey, address, legacy: false });\n    }\n    // lookup legacy ed25519\n    const legacyAuthKey = AuthenticationKey.fromPublicKey({\n      publicKey: publicKey.publicKey as Ed25519PublicKey,\n    });\n    const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });\n    if (isLegacyEd25519) {\n      const address = legacyAuthKey.derivedAddress();\n      return Account.fromPrivateKey({ privateKey, address, legacy: true });\n    }\n  }\n  // if we are here, it means we couldn't find an address with an\n  // auth key that matches the provided private key\n  throw new Error(`Can't derive account from private key ${privateKey}`);\n}\n\nexport async function isAccountExist(args: { aptosConfig: AptosConfig; authKey: AuthenticationKey }): Promise<boolean> {\n  const { aptosConfig, authKey } = args;\n  const accountAddress = await lookupOriginalAccountAddress({\n    aptosConfig,\n    authenticationKey: authKey.derivedAddress(),\n  });\n\n  try {\n    await getInfo({\n      aptosConfig,\n      accountAddress,\n    });\n    return true;\n  } catch (error: any) {\n    // account not found\n    if (error.status === 404) {\n      return false;\n    }\n    throw new Error(`Error while looking for an account info ${accountAddress.toString()}`);\n  }\n}\n"],"mappings":"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","names":["getInfo","args","aptosConfig","accountAddress","data","getAptosFullNode","AccountAddress","getModules","options","paginateWithCursor","getModule","getModuleInner","memoizeAsync","moduleName","getTransactions","getResources","getResource","resourceType","lookupOriginalAccountAddress","authenticationKey","resource","handle","authKeyAddress","originalAddress","getTableItem","err","AptosApiError","getAccountTokensCount","whereCondition","queryIndexer","GetAccountTokensCount","getAccountOwnedTokens","graphqlQuery","GetAccountOwnedTokens","getAccountOwnedTokensFromCollectionAddress","collectionAddress","ownerAddress","collAddress","GetAccountOwnedTokensFromCollection","getAccountCollectionsWithOwnedTokens","GetAccountCollectionsWithOwnedTokens","getAccountTransactionsCount","address","GetAccountTransactionsCount","getAccountCoinsData","GetAccountCoinsData","getAccountCoinsCount","GetAccountCoinsCount","getAccountOwnedObjects","GetObjectData","deriveAccountFromPrivateKey","privateKey","publicKey","AnyPublicKey","Secp256k1PrivateKey","AuthenticationKey","Account","Ed25519PrivateKey","singleSenderTransactionAuthenticatorAuthKey","isAccountExist","legacyAuthKey","authKey","error"]}

package/dist/esm/chunk-SUJLWCRN.mjs

@@ -1,2 +0,0 @@
-import{a as n}from"./chunk-YUNDX5I7.mjs";import{b as a}from"./chunk-OHRL766V.mjs";import{a as v}from"./chunk-A63SMUOU.mjs";var t=class extends v{static deserialize(e){let r=e.deserializeUleb128AsU32();switch(r){case 0:return c.load(e);case 1:return u.load(e);case 2:return p.load(e);case 3:return z.load(e);case 4:return S.load(e);case 5:return U.load(e);case 6:return y.load(e);case 7:return b.load(e);case 8:return d.load(e);case 9:return g.load(e);case 10:return T.load(e);case 255:return h.load(e);default:throw new Error(`Unknown variant index for TypeTag: ${r}`)}}isBool(){return this instanceof c}isAddress(){return this instanceof S}isGeneric(){return this instanceof h}isSigner(){return this instanceof U}isVector(){return this instanceof y}isStruct(){return this instanceof b}isU8(){return this instanceof u}isU16(){return this instanceof d}isU32(){return this instanceof g}isU64(){return this instanceof p}isU128(){return this instanceof z}isU256(){return this instanceof T}},c=class i extends t{toString(){return"bool"}serialize(e){e.serializeU32AsUleb128(0)}static load(e){return new i}},u=class i extends t{toString(){return"u8"}serialize(e){e.serializeU32AsUleb128(1)}static load(e){return new i}},d=class i extends t{toString(){return"u16"}serialize(e){e.serializeU32AsUleb128(8)}static load(e){return new i}},g=class i extends t{toString(){return"u32"}serialize(e){e.serializeU32AsUleb128(9)}static load(e){return new i}},p=class i extends t{toString(){return"u64"}serialize(e){e.serializeU32AsUleb128(2)}static load(e){return new i}},z=class i extends t{toString(){return"u128"}serialize(e){e.serializeU32AsUleb128(3)}static load(e){return new i}},T=class i extends t{toString(){return"u256"}serialize(e){e.serializeU32AsUleb128(10)}static load(e){return new i}},S=class i extends t{toString(){return"address"}serialize(e){e.serializeU32AsUleb128(4)}static load(e){return new i}},U=class i extends t{toString(){return"signer"}serialize(e){e.serializeU32AsUleb128(5)}static load(e){return new i}},x=class i extends t{constructor(r){super();this.value=r}toString(){return`&${this.value.toString()}`}serialize(r){r.serializeU32AsUleb128(254)}static load(r){let s=t.deserialize(r);return new i(s)}},h=class i extends t{constructor(r){super();this.value=r;if(r<0)throw new Error("Generic type parameter index cannot be negative")}toString(){return`T${this.value}`}serialize(r){r.serializeU32AsUleb128(255),r.serializeU32(this.value)}static load(r){let s=r.deserializeU32();return new i(s)}},y=class i extends t{constructor(r){super();this.value=r}toString(){return`vector<${this.value.toString()}>`}static u8(){return new i(new u)}serialize(r){r.serializeU32AsUleb128(6),this.value.serialize(r)}static load(r){let s=t.deserialize(r);return new i(s)}},b=class i extends t{constructor(r){super();this.value=r}toString(){let r="";return this.value.typeArgs.length>0&&(r=`<${this.value.typeArgs.map(s=>s.toString()).join(", ")}>`),`${this.value.address.toString()}::${this.value.moduleName.identifier}::${this.value.name.identifier}${r}`}serialize(r){r.serializeU32AsUleb128(7),this.value.serialize(r)}static load(r){let s=o.deserialize(r);return new i(s)}isTypeTag(r,s,l){return this.value.moduleName.identifier===s&&this.value.name.identifier===l&&this.value.address.equals(r)}isString(){return this.isTypeTag(a.ONE,"string","String")}isOption(){return this.isTypeTag(a.ONE,"option","Option")}isObject(){return this.isTypeTag(a.ONE,"object","Object")}},o=class i extends v{constructor(e,r,s,l){super(),this.address=e,this.moduleName=r,this.name=s,this.typeArgs=l}serialize(e){e.serialize(this.address),e.serialize(this.moduleName),e.serialize(this.name),e.serializeVector(this.typeArgs)}static deserialize(e){let r=a.deserialize(e),s=n.deserialize(e),l=n.deserialize(e),f=e.deserializeVector(t);return new i(r,s,l,f)}};function O(){return new o(a.ONE,new n("aptos_coin"),new n("AptosCoin"),[])}function E(){return new o(a.ONE,new n("string"),new n("String"),[])}function V(i){return new o(a.ONE,new n("option"),new n("Option"),[i])}function j(i){return new o(a.ONE,new n("object"),new n("Object"),[i])}export{t as a,c as b,u as c,d,g as e,p as f,z as g,T as h,S as i,U as j,x as k,h as l,y as m,b as n,o,O as p,E as q,V as r,j as s};
-//# sourceMappingURL=chunk-SUJLWCRN.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/typeTag/index.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable class-methods-use-this */\n/* eslint-disable max-classes-per-file */\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"../instances/identifier\";\nimport { TypeTagVariants } from \"../../types\";\n\nexport abstract class TypeTag extends Serializable {\n  abstract serialize(serializer: Serializer): void;\n\n  static deserialize(deserializer: Deserializer): TypeTag {\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case TypeTagVariants.Bool:\n        return TypeTagBool.load(deserializer);\n      case TypeTagVariants.U8:\n        return TypeTagU8.load(deserializer);\n      case TypeTagVariants.U64:\n        return TypeTagU64.load(deserializer);\n      case TypeTagVariants.U128:\n        return TypeTagU128.load(deserializer);\n      case TypeTagVariants.Address:\n        return TypeTagAddress.load(deserializer);\n      case TypeTagVariants.Signer:\n        return TypeTagSigner.load(deserializer);\n      case TypeTagVariants.Vector:\n        return TypeTagVector.load(deserializer);\n      case TypeTagVariants.Struct:\n        return TypeTagStruct.load(deserializer);\n      case TypeTagVariants.U16:\n        return TypeTagU16.load(deserializer);\n      case TypeTagVariants.U32:\n        return TypeTagU32.load(deserializer);\n      case TypeTagVariants.U256:\n        return TypeTagU256.load(deserializer);\n      case TypeTagVariants.Generic:\n        // This is only used for ABI representation, and cannot actually be used as a type.\n        return TypeTagGeneric.load(deserializer);\n      default:\n        throw new Error(`Unknown variant index for TypeTag: ${index}`);\n    }\n  }\n\n  abstract toString(): string;\n\n  isBool(): this is TypeTagBool {\n    return this instanceof TypeTagBool;\n  }\n\n  isAddress(): this is TypeTagAddress {\n    return this instanceof TypeTagAddress;\n  }\n\n  isGeneric(): this is TypeTagGeneric {\n    return this instanceof TypeTagGeneric;\n  }\n\n  isSigner(): this is TypeTagSigner {\n    return this instanceof TypeTagSigner;\n  }\n\n  isVector(): this is TypeTagVector {\n    return this instanceof TypeTagVector;\n  }\n\n  isStruct(): this is TypeTagStruct {\n    return this instanceof TypeTagStruct;\n  }\n\n  isU8(): this is TypeTagU8 {\n    return this instanceof TypeTagU8;\n  }\n\n  isU16(): this is TypeTagU16 {\n    return this instanceof TypeTagU16;\n  }\n\n  isU32(): this is TypeTagU32 {\n    return this instanceof TypeTagU32;\n  }\n\n  isU64(): this is TypeTagU64 {\n    return this instanceof TypeTagU64;\n  }\n\n  isU128(): this is TypeTagU128 {\n    return this instanceof TypeTagU128;\n  }\n\n  isU256(): this is TypeTagU256 {\n    return this instanceof TypeTagU256;\n  }\n}\n\nexport class TypeTagBool extends TypeTag {\n  toString(): string {\n    return \"bool\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Bool);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagBool {\n    return new TypeTagBool();\n  }\n}\n\nexport class TypeTagU8 extends TypeTag {\n  toString(): string {\n    return \"u8\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U8);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU8 {\n    return new TypeTagU8();\n  }\n}\n\nexport class TypeTagU16 extends TypeTag {\n  toString(): string {\n    return \"u16\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U16);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU16 {\n    return new TypeTagU16();\n  }\n}\n\nexport class TypeTagU32 extends TypeTag {\n  toString(): string {\n    return \"u32\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U32);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU32 {\n    return new TypeTagU32();\n  }\n}\n\nexport class TypeTagU64 extends TypeTag {\n  toString(): string {\n    return \"u64\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U64);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU64 {\n    return new TypeTagU64();\n  }\n}\n\nexport class TypeTagU128 extends TypeTag {\n  toString(): string {\n    return \"u128\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U128);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU128 {\n    return new TypeTagU128();\n  }\n}\n\nexport class TypeTagU256 extends TypeTag {\n  toString(): string {\n    return \"u256\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U256);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU256 {\n    return new TypeTagU256();\n  }\n}\n\nexport class TypeTagAddress extends TypeTag {\n  toString(): string {\n    return \"address\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Address);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagAddress {\n    return new TypeTagAddress();\n  }\n}\n\nexport class TypeTagSigner extends TypeTag {\n  toString(): string {\n    return \"signer\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Signer);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagSigner {\n    return new TypeTagSigner();\n  }\n}\n\nexport class TypeTagReference extends TypeTag {\n  toString(): `&${string}` {\n    return `&${this.value.toString()}`;\n  }\n\n  constructor(public readonly value: TypeTag) {\n    super();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Reference);\n  }\n\n  static load(deserializer: Deserializer): TypeTagReference {\n    const value = TypeTag.deserialize(deserializer);\n    return new TypeTagReference(value);\n  }\n}\n\n/**\n * Generics are used for type parameters in entry functions.  However,\n * they are not actually serialized into a real type, so they cannot be\n * used as a type directly.\n */\nexport class TypeTagGeneric extends TypeTag {\n  toString(): `T${number}` {\n    return `T${this.value}`;\n  }\n\n  constructor(public readonly value: number) {\n    super();\n    if (value < 0) throw new Error(\"Generic type parameter index cannot be negative\");\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Generic);\n    serializer.serializeU32(this.value);\n  }\n\n  static load(deserializer: Deserializer): TypeTagGeneric {\n    const value = deserializer.deserializeU32();\n    return new TypeTagGeneric(value);\n  }\n}\n\nexport class TypeTagVector extends TypeTag {\n  toString(): `vector<${string}>` {\n    return `vector<${this.value.toString()}>`;\n  }\n\n  constructor(public readonly value: TypeTag) {\n    super();\n  }\n\n  static u8(): TypeTagVector {\n    return new TypeTagVector(new TypeTagU8());\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Vector);\n    this.value.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TypeTagVector {\n    const value = TypeTag.deserialize(deserializer);\n    return new TypeTagVector(value);\n  }\n}\n\nexport class TypeTagStruct extends TypeTag {\n  toString(): `0x${string}::${string}::${string}` {\n    // Collect type args and add it if there are any\n    let typePredicate = \"\";\n    if (this.value.typeArgs.length > 0) {\n      typePredicate = `<${this.value.typeArgs.map((typeArg) => typeArg.toString()).join(\", \")}>`;\n    }\n\n    return `${this.value.address.toString()}::${this.value.moduleName.identifier}::${\n      this.value.name.identifier\n    }${typePredicate}`;\n  }\n\n  constructor(public readonly value: StructTag) {\n    super();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Struct);\n    this.value.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TypeTagStruct {\n    const value = StructTag.deserialize(deserializer);\n    return new TypeTagStruct(value);\n  }\n\n  isTypeTag(address: AccountAddress, moduleName: string, structName: string): boolean {\n    return (\n      this.value.moduleName.identifier === moduleName &&\n      this.value.name.identifier === structName &&\n      this.value.address.equals(address)\n    );\n  }\n\n  isString(): boolean {\n    return this.isTypeTag(AccountAddress.ONE, \"string\", \"String\");\n  }\n\n  isOption(): boolean {\n    return this.isTypeTag(AccountAddress.ONE, \"option\", \"Option\");\n  }\n\n  isObject(): boolean {\n    return this.isTypeTag(AccountAddress.ONE, \"object\", \"Object\");\n  }\n}\n\nexport class StructTag extends Serializable {\n  public readonly address: AccountAddress;\n\n  public readonly moduleName: Identifier;\n\n  public readonly name: Identifier;\n\n  public readonly typeArgs: Array<TypeTag>;\n\n  constructor(address: AccountAddress, module_name: Identifier, name: Identifier, type_args: Array<TypeTag>) {\n    super();\n    this.address = address;\n    this.moduleName = module_name;\n    this.name = name;\n    this.typeArgs = type_args;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serialize(this.address);\n    serializer.serialize(this.moduleName);\n    serializer.serialize(this.name);\n    serializer.serializeVector(this.typeArgs);\n  }\n\n  static deserialize(deserializer: Deserializer): StructTag {\n    const address = AccountAddress.deserialize(deserializer);\n    const moduleName = Identifier.deserialize(deserializer);\n    const name = Identifier.deserialize(deserializer);\n    const typeArgs = deserializer.deserializeVector(TypeTag);\n    return new StructTag(address, moduleName, name, typeArgs);\n  }\n}\n\nexport function aptosCoinStructTag(): StructTag {\n  return new StructTag(AccountAddress.ONE, new Identifier(\"aptos_coin\"), new Identifier(\"AptosCoin\"), []);\n}\n\nexport function stringStructTag(): StructTag {\n  return new StructTag(AccountAddress.ONE, new Identifier(\"string\"), new Identifier(\"String\"), []);\n}\n\nexport function optionStructTag(typeArg: TypeTag): StructTag {\n  return new StructTag(AccountAddress.ONE, new Identifier(\"option\"), new Identifier(\"Option\"), [typeArg]);\n}\n\nexport function objectStructTag(typeArg: TypeTag): StructTag {\n  return new StructTag(AccountAddress.ONE, new Identifier(\"object\"), new Identifier(\"Object\"), [typeArg]);\n}\n"],"mappings":"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","names":["TypeTag","Serializable","deserializer","index","TypeTagBool","TypeTagU8","TypeTagU64","TypeTagU128","TypeTagAddress","TypeTagSigner","TypeTagVector","TypeTagStruct","TypeTagU16","TypeTagU32","TypeTagU256","TypeTagGeneric","_TypeTagBool","serializer","_deserializer","_TypeTagU8","_TypeTagU16","_TypeTagU32","_TypeTagU64","_TypeTagU128","_TypeTagU256","_TypeTagAddress","_TypeTagSigner","TypeTagReference","_TypeTagReference","value","_TypeTagGeneric","_TypeTagVector","_TypeTagStruct","typePredicate","typeArg","StructTag","address","moduleName","structName","AccountAddress","_StructTag","module_name","name","type_args","Identifier","typeArgs","aptosCoinStructTag","stringStructTag","optionStructTag","objectStructTag"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/instances/rotationProofChallenge.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Serializer, Serializable } from \"../../bcs/serializer\";\nimport { AccountAddress } from \"../../core/accountAddress\";\nimport { AnyNumber } from \"../../types\";\nimport { PublicKey } from \"../../core/crypto\";\nimport { MoveString, MoveVector, U64, U8 } from \"../../bcs\";\n\n/**\n * Representation of the challenge which is needed to sign by owner of the account\n * to rotate the authentication key.\n */\nexport class RotationProofChallenge extends Serializable {\n  // Resource account address\n  public readonly accountAddress: AccountAddress = AccountAddress.ONE;\n\n  // Module name, i.e: 0x1::account\n  public readonly moduleName: MoveString = new MoveString(\"account\");\n\n  // The rotation proof challenge struct name that live under the module\n  public readonly structName: MoveString = new MoveString(\"RotationProofChallenge\");\n\n  // Signer's address\n  public readonly originator: AccountAddress;\n\n  // Signer's current authentication key\n  public readonly currentAuthKey: AccountAddress;\n\n  // New public key to rotate to\n  public readonly newPublicKey: MoveVector<U8>;\n\n  // Sequence number of the account\n  public readonly sequenceNumber: U64;\n\n  constructor(args: {\n    sequenceNumber: AnyNumber;\n    originator: AccountAddress;\n    currentAuthKey: AccountAddress;\n    newPublicKey: PublicKey;\n  }) {\n    super();\n    this.sequenceNumber = new U64(args.sequenceNumber);\n    this.originator = args.originator;\n    this.currentAuthKey = args.currentAuthKey;\n    this.newPublicKey = MoveVector.U8(args.newPublicKey.toUint8Array());\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serialize(this.accountAddress);\n    serializer.serialize(this.moduleName);\n    serializer.serialize(this.structName);\n    serializer.serialize(this.sequenceNumber);\n    serializer.serialize(this.originator);\n    serializer.serialize(this.currentAuthKey);\n    serializer.serialize(this.newPublicKey);\n  }\n}\n"],"mappings":"2KAaO,IAAMA,EAAN,cAAqCC,CAAa,CAsBvD,YAAYC,EAKT,CACD,MAAM,EA1BR,KAAgB,eAAiCC,EAAe,IAGhE,KAAgB,WAAyB,IAAIC,EAAW,SAAS,EAGjE,KAAgB,WAAyB,IAAIA,EAAW,wBAAwB,EAqB9E,KAAK,eAAiB,IAAIC,EAAIH,EAAK,cAAc,EACjD,KAAK,WAAaA,EAAK,WACvB,KAAK,eAAiBA,EAAK,eAC3B,KAAK,aAAeI,EAAW,GAAGJ,EAAK,aAAa,aAAa,CAAC,CACpE,CAEA,UAAUK,EAA8B,CACtCA,EAAW,UAAU,KAAK,cAAc,EACxCA,EAAW,UAAU,KAAK,UAAU,EACpCA,EAAW,UAAU,KAAK,UAAU,EACpCA,EAAW,UAAU,KAAK,cAAc,EACxCA,EAAW,UAAU,KAAK,UAAU,EACpCA,EAAW,UAAU,KAAK,cAAc,EACxCA,EAAW,UAAU,KAAK,YAAY,CACxC,CACF","names":["RotationProofChallenge","Serializable","args","AccountAddress","MoveString","U64","MoveVector","serializer"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/client/types.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosRequest } from \"../types\";\nimport { AptosApiType } from \"../utils/const.js\";\n\n/**\n * The API response type\n *\n * @param status - the response status. i.e. 200\n * @param statusText - the response message\n * @param data the response data\n * @param url the url the request was made to\n * @param headers the response headers\n * @param config (optional) - the request object\n * @param request (optional) - the request object\n */\nexport interface AptosResponse<Req, Res> {\n  status: number;\n  statusText: string;\n  data: Res;\n  url: string;\n  headers: any;\n  config?: any;\n  request?: Req;\n}\n\ntype AptosApiErrorOpts = {\n  apiType: AptosApiType;\n  aptosRequest: AptosRequest;\n  aptosResponse: AptosResponse<any, any>;\n};\n\n/**\n * The type returned from an API error\n *\n * @param name - the error name \"AptosApiError\"\n * @param url the url the request was made to\n * @param status - the response status. i.e. 400\n * @param statusText - the response message\n * @param data the response data\n * @param request - the AptosRequest\n */\nexport class AptosApiError extends Error {\n  readonly url: string;\n\n  readonly status: number;\n\n  readonly statusText: string;\n\n  readonly data: any;\n\n  readonly request: AptosRequest;\n\n  /** @internal this constructor is for sdk internal use - do not instantiate outside of the SDK codebase */\n  constructor({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts) {\n    super(deriveErrorMessage({ apiType, aptosRequest, aptosResponse }));\n\n    this.name = \"AptosApiError\";\n    this.url = aptosResponse.url;\n    this.status = aptosResponse.status;\n    this.statusText = aptosResponse.statusText;\n    this.data = aptosResponse.data;\n    this.request = aptosRequest;\n  }\n}\n\nfunction deriveErrorMessage({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts): string {\n  // extract the W3C trace_id from the response headers if it exists. Some services set this in the response and it's useful for debugging.\n  // See https://www.w3.org/TR/trace-context/#relationship-between-the-headers .\n  const traceId = aptosResponse.headers?.traceparent?.split(\"-\")[1];\n  const traceIdString = traceId ? `(trace_id:${traceId}) ` : \"\";\n\n  const errorPrelude: string = `Request to [${apiType}]: ${aptosRequest.method} ${\n    aptosResponse.url ?? aptosRequest.url\n  } ${traceIdString}failed with`;\n\n  // handle graphql responses from indexer api and extract the error message of the first error\n  if (apiType === AptosApiType.INDEXER && aptosResponse.data?.errors?.[0]?.message != null) {\n    return `${errorPrelude}: ${aptosResponse.data.errors[0].message}`;\n  }\n\n  // Received well-known structured error response body - simply serialize and return it.\n  // We don't need http status codes etc. in this case.\n  if (aptosResponse.data?.message != null && aptosResponse.data?.error_code != null) {\n    return `${errorPrelude}: ${JSON.stringify(aptosResponse.data)}`;\n  }\n\n  // This is the generic/catch-all case. We received some response from the API but it doesn't appear to be a well-known structure.\n  // We print http status codes and the response body (after some trimming),\n  // in the hope that this gives enough context what went wrong without printing overly huge messages.\n  return `${errorPrelude} status: ${aptosResponse.statusText}(code:${\n    aptosResponse.status\n  }) and response body: ${serializeAnyPayloadForErrorMessage(aptosResponse.data)}`;\n}\n\nconst SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH = 400;\n\n// this function accepts a payload of any type (probably an object) and serializes it to a string\n// Since we don't know the type or size of the payload and we don't want to add a huge object in full to the error message\n// we limit the to the first 200 and last 200 characters of the serialized payload and put a \"...\" in the middle.\nfunction serializeAnyPayloadForErrorMessage(payload: any): string {\n  const serializedPayload = JSON.stringify(payload);\n  if (serializedPayload.length <= SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH) {\n    return serializedPayload;\n  }\n  return `truncated(original_size:${serializedPayload.length}): ${serializedPayload.slice(\n    0,\n    SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH / 2,\n  )}...${serializedPayload.slice(-SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH / 2)}`;\n}\n"],"mappings":"AA2CO,IAAMA,EAAN,cAA4B,KAAM,CAYvC,YAAY,CAAE,QAAAC,EAAS,aAAAC,EAAc,cAAAC,CAAc,EAAsB,CACvE,MAAMC,EAAmB,CAAE,QAAAH,EAAS,aAAAC,EAAc,cAAAC,CAAc,CAAC,CAAC,EAElE,KAAK,KAAO,gBACZ,KAAK,IAAMA,EAAc,IACzB,KAAK,OAASA,EAAc,OAC5B,KAAK,WAAaA,EAAc,WAChC,KAAK,KAAOA,EAAc,KAC1B,KAAK,QAAUD,CACjB,CACF,EAEA,SAASE,EAAmB,CAAE,QAAAH,EAAS,aAAAC,EAAc,cAAAC,CAAc,EAA8B,CAG/F,IAAME,EAAUF,EAAc,SAAS,aAAa,MAAM,GAAG,EAAE,CAAC,EAC1DG,EAAgBD,EAAU,aAAaA,CAAO,KAAO,GAErDE,EAAuB,eAAeN,CAAO,MAAMC,EAAa,MAAM,IAC1EC,EAAc,KAAOD,EAAa,GACpC,IAAII,CAAa,cAGjB,OAAIL,eAAoCE,EAAc,MAAM,SAAS,CAAC,GAAG,SAAW,KAC3E,GAAGI,CAAY,KAAKJ,EAAc,KAAK,OAAO,CAAC,EAAE,OAAO,GAK7DA,EAAc,MAAM,SAAW,MAAQA,EAAc,MAAM,YAAc,KACpE,GAAGI,CAAY,KAAK,KAAK,UAAUJ,EAAc,IAAI,CAAC,GAMxD,GAAGI,CAAY,YAAYJ,EAAc,UAAU,SACxDA,EAAc,MAChB,wBAAwBK,EAAmCL,EAAc,IAAI,CAAC,EAChF,CAEA,IAAMM,EAAwC,IAK9C,SAASD,EAAmCE,EAAsB,CAChE,IAAMC,EAAoB,KAAK,UAAUD,CAAO,EAChD,OAAIC,EAAkB,QAAUF,EACvBE,EAEF,2BAA2BA,EAAkB,MAAM,MAAMA,EAAkB,MAChF,EACAF,EAAwC,CAC1C,CAAC,MAAME,EAAkB,MAAM,CAACF,EAAwC,CAAC,CAAC,EAC5E","names":["AptosApiError","apiType","aptosRequest","aptosResponse","deriveErrorMessage","traceId","traceIdString","errorPrelude","serializeAnyPayloadForErrorMessage","SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH","payload","serializedPayload"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/transactionBuilder/remoteAbi.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { parseTypeTag } from \"../typeTag/parser\";\nimport {\n  TypeTag,\n  TypeTagAddress,\n  TypeTagBool,\n  TypeTagStruct,\n  TypeTagU128,\n  TypeTagU16,\n  TypeTagU256,\n  TypeTagU32,\n  TypeTagU64,\n  TypeTagU8,\n} from \"../typeTag\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport {\n  EntryFunctionArgumentTypes,\n  SimpleEntryFunctionArgumentTypes,\n  EntryFunctionABI,\n  ViewFunctionABI,\n  FunctionABI,\n  TypeArgument,\n} from \"../types\";\nimport { Bool, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from \"../../bcs\";\nimport { AccountAddress } from \"../../core\";\nimport { getModule } from \"../../internal/account\";\nimport {\n  findFirstNonSignerArg,\n  isBcsAddress,\n  isBcsBool,\n  isBcsString,\n  isBcsU128,\n  isBcsU16,\n  isBcsU256,\n  isBcsU32,\n  isBcsU64,\n  isBcsU8,\n  isBool,\n  isEncodedEntryFunctionArgument,\n  isLargeNumber,\n  isEmptyOption,\n  isString,\n  throwTypeMismatch,\n  convertNumber,\n} from \"./helpers\";\nimport { MoveFunction } from \"../../types\";\n\nconst TEXT_ENCODER = new TextEncoder();\n\n/**\n * Convert type arguments to only type tags, allowing for string representations of type tags\n */\nexport function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<TypeTag> {\n  return (\n    typeArguments?.map((typeArg: TypeArgument): TypeTag => {\n      // Convert to TypeTag if it's a string representation\n      if (isString(typeArg)) {\n        return parseTypeTag(typeArg);\n      }\n      return typeArg;\n    }) ?? []\n  );\n}\n\n/**\n * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.\n * @param moduleAddress\n * @param moduleName\n * @param functionName\n * @param aptosConfig\n */\nexport async function fetchFunctionAbi(\n  moduleAddress: string,\n  moduleName: string,\n  functionName: string,\n  aptosConfig: AptosConfig,\n): Promise<MoveFunction | undefined> {\n  // This fetch from the API is currently cached\n  const module = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });\n\n  if (module.abi) {\n    return module.abi.exposed_functions.find((func) => func.name === functionName);\n  }\n\n  return undefined;\n}\n\n/**\n * Fetches the ABI for an entry function from the module\n *\n * @param moduleAddress\n * @param moduleName\n * @param functionName\n * @param aptosConfig\n */\nexport async function fetchEntryFunctionAbi(\n  moduleAddress: string,\n  moduleName: string,\n  functionName: string,\n  aptosConfig: AptosConfig,\n): Promise<EntryFunctionABI> {\n  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);\n\n  // If there's no ABI, then the function is invalid\n  if (!functionAbi) {\n    throw new Error(`Could not find entry function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);\n  }\n\n  // Non-entry functions also can't be used\n  if (!functionAbi.is_entry) {\n    throw new Error(`'${moduleAddress}::${moduleName}::${functionName}' is not an entry function`);\n  }\n\n  // Remove the signer arguments\n  const numSigners = findFirstNonSignerArg(functionAbi);\n  const params: TypeTag[] = [];\n  for (let i = numSigners; i < functionAbi.params.length; i += 1) {\n    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));\n  }\n\n  return {\n    signers: numSigners,\n    typeParameters: functionAbi.generic_type_params,\n    parameters: params,\n  };\n}\n\n/**\n * Fetches the ABI for a view function from the module\n *\n * @param moduleAddress\n * @param moduleName\n * @param functionName\n * @param aptosConfig\n */\nexport async function fetchViewFunctionAbi(\n  moduleAddress: string,\n  moduleName: string,\n  functionName: string,\n  aptosConfig: AptosConfig,\n): Promise<ViewFunctionABI> {\n  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);\n\n  // If there's no ABI, then the function is invalid\n  if (!functionAbi) {\n    throw new Error(`Could not find view function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);\n  }\n\n  // Non-view functions can't be used\n  if (!functionAbi.is_view) {\n    throw new Error(`'${moduleAddress}::${moduleName}::${functionName}' is not an view function`);\n  }\n\n  // Type tag parameters for the function\n  const params: TypeTag[] = [];\n  for (let i = 0; i < functionAbi.params.length; i += 1) {\n    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));\n  }\n\n  // The return types of the view function\n  const returnTypes: TypeTag[] = [];\n  for (let i = 0; i < functionAbi.return.length; i += 1) {\n    returnTypes.push(parseTypeTag(functionAbi.return[i], { allowGenerics: true }));\n  }\n\n  return {\n    typeParameters: functionAbi.generic_type_params,\n    parameters: params,\n    returnTypes,\n  };\n}\n\n/**\n * Converts a non-BCS encoded argument into BCS encoded, if necessary\n * @param functionName\n * @param functionAbi\n * @param arg\n * @param position\n * @param genericTypeParams\n */\nexport function convertArgument(\n  functionName: string,\n  functionAbi: FunctionABI,\n  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n  position: number,\n  genericTypeParams: Array<TypeTag>,\n) {\n  // Ensure not too many arguments\n  if (position >= functionAbi.parameters.length) {\n    throw new Error(`Too many arguments for '${functionName}', expected ${functionAbi.parameters.length}`);\n  }\n\n  const param = functionAbi.parameters[position];\n  return checkOrConvertArgument(arg, param, position, genericTypeParams);\n}\n\nexport function checkOrConvertArgument(\n  arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes,\n  param: TypeTag,\n  position: number,\n  genericTypeParams: Array<TypeTag>,\n) {\n  // If the argument is bcs encoded, we can just use it directly\n  if (isEncodedEntryFunctionArgument(arg)) {\n    // Ensure the type matches the ABI\n    checkType(param, arg, position);\n    return arg;\n  }\n\n  // If it is not BCS encoded, we will need to convert it with the ABI\n  return parseArg(arg, param, position, genericTypeParams);\n}\n\n/**\n * Parses a non-BCS encoded argument into a BCS encoded argument recursively\n * @param arg\n * @param param\n * @param position\n * @param genericTypeParams\n */\nfunction parseArg(\n  arg: SimpleEntryFunctionArgumentTypes,\n  param: TypeTag,\n  position: number,\n  genericTypeParams: Array<TypeTag>,\n): EntryFunctionArgumentTypes {\n  if (param.isBool()) {\n    if (isBool(arg)) {\n      return new Bool(arg);\n    }\n    if (isString(arg)) {\n      if (arg === \"true\") return new Bool(true);\n      if (arg === \"false\") return new Bool(false);\n    }\n    throwTypeMismatch(\"boolean\", position);\n  }\n  // TODO: support uint8array?\n  if (param.isAddress()) {\n    if (isString(arg)) {\n      return AccountAddress.fromString(arg);\n    }\n    throwTypeMismatch(\"string | AccountAddress\", position);\n  }\n  if (param.isU8()) {\n    const num = convertNumber(arg);\n    if (num !== undefined) {\n      return new U8(num);\n    }\n    throwTypeMismatch(\"number | string\", position);\n  }\n  if (param.isU16()) {\n    const num = convertNumber(arg);\n    if (num !== undefined) {\n      return new U16(num);\n    }\n    throwTypeMismatch(\"number | string\", position);\n  }\n  if (param.isU32()) {\n    const num = convertNumber(arg);\n    if (num !== undefined) {\n      return new U32(num);\n    }\n    throwTypeMismatch(\"number | string\", position);\n  }\n  if (param.isU64()) {\n    if (isLargeNumber(arg)) {\n      return new U64(BigInt(arg));\n    }\n    throwTypeMismatch(\"bigint | number | string\", position);\n  }\n  if (param.isU128()) {\n    if (isLargeNumber(arg)) {\n      return new U128(BigInt(arg));\n    }\n    throwTypeMismatch(\"bigint | number | string\", position);\n  }\n  if (param.isU256()) {\n    if (isLargeNumber(arg)) {\n      return new U256(BigInt(arg));\n    }\n    throwTypeMismatch(\"bigint | number | string\", position);\n  }\n\n  // Generic needs to use the sub-type\n  if (param.isGeneric()) {\n    const genericIndex = param.value;\n    if (genericIndex < 0 || genericIndex >= genericTypeParams.length) {\n      throw new Error(`Generic argument ${param.toString()} is invalid for argument ${position}`);\n    }\n\n    return checkOrConvertArgument(arg, genericTypeParams[genericIndex], position, genericTypeParams);\n  }\n\n  // We have to special case some vectors for Vector<u8>\n  if (param.isVector()) {\n    // Check special case for Vector<u8>\n    if (param.value.isU8()) {\n      // We don't allow vector<u8>, but we convert strings to UTF8 uint8array\n      // This is legacy behavior from the original SDK\n      if (isString(arg)) {\n        return MoveVector.U8(TEXT_ENCODER.encode(arg));\n      }\n      if (arg instanceof Uint8Array) {\n        return MoveVector.U8(arg);\n      }\n      if (arg instanceof ArrayBuffer) {\n        return MoveVector.U8(new Uint8Array(arg));\n      }\n    }\n\n    // TODO: Support Uint16Array, Uint32Array, BigUint64Array?\n\n    if (Array.isArray(arg)) {\n      return new MoveVector(arg.map((item) => checkOrConvertArgument(item, param.value, position, genericTypeParams)));\n    }\n\n    throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);\n  }\n\n  // Handle structs as they're more complex\n  if (param.isStruct()) {\n    if (param.isString()) {\n      if (isString(arg)) {\n        return new MoveString(arg);\n      }\n      throwTypeMismatch(\"string\", position);\n    }\n    if (param.isObject()) {\n      // The inner type of Object doesn't matter, since it's just syntactic sugar\n      if (isString(arg)) {\n        return AccountAddress.fromString(arg);\n      }\n      throwTypeMismatch(\"string | AccountAddress\", position);\n    }\n\n    if (param.isOption()) {\n      if (isEmptyOption(arg)) {\n        // Here we attempt to reconstruct the underlying type\n        // Note, for some reason the `isBool` etc. does not work with the compiler\n        const innerParam = param.value.typeArgs[0];\n        if (innerParam instanceof TypeTagBool) {\n          return new MoveOption<Bool>(null);\n        }\n        if (innerParam instanceof TypeTagAddress) {\n          return new MoveOption<AccountAddress>(null);\n        }\n        if (innerParam instanceof TypeTagU8) {\n          return new MoveOption<U8>(null);\n        }\n        if (innerParam instanceof TypeTagU16) {\n          return new MoveOption<U16>(null);\n        }\n        if (innerParam instanceof TypeTagU32) {\n          return new MoveOption<U32>(null);\n        }\n        if (innerParam instanceof TypeTagU64) {\n          return new MoveOption<U64>(null);\n        }\n        if (innerParam instanceof TypeTagU128) {\n          return new MoveOption<U128>(null);\n        }\n        if (innerParam instanceof TypeTagU256) {\n          return new MoveOption<U256>(null);\n        }\n\n        // In all other cases, we will use a placeholder, it doesn't actually matter what the type is, but it will be obvious\n        // Note: This is a placeholder U8 type, and does not match the actual type, as that can't be dynamically grabbed\n        return new MoveOption<MoveString>(null);\n      }\n\n      return new MoveOption(checkOrConvertArgument(arg, param.value.typeArgs[0], position, genericTypeParams));\n    }\n\n    throw new Error(`Unsupported struct input type for argument ${position}, type '${param.toString()}'`);\n  }\n\n  throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);\n}\n\n/**\n * Checks that the type of an already BCS encoded argument matches the ABI\n * @param param\n * @param arg\n * @param position\n */\nfunction checkType(param: TypeTag, arg: EntryFunctionArgumentTypes, position: number) {\n  if (param.isBool()) {\n    if (isBcsBool(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"Bool\", position);\n  }\n  if (param.isAddress()) {\n    if (isBcsAddress(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"AccountAddress\", position);\n  }\n  if (param.isU8()) {\n    if (isBcsU8(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U8\", position);\n  }\n  if (param.isU16()) {\n    if (isBcsU16(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U16\", position);\n  }\n  if (param.isU32()) {\n    if (isBcsU32(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U32\", position);\n  }\n  if (param.isU64()) {\n    if (isBcsU64(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U64\", position);\n  }\n  if (param.isU128()) {\n    if (isBcsU128(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U128\", position);\n  }\n  if (param.isU256()) {\n    if (isBcsU256(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U256\", position);\n  }\n  if (param.isVector()) {\n    if (arg instanceof MoveVector) {\n      // If there's anything in it, check that the inner types match\n      // Note that since it's typed, the first item should be the same as the rest\n      if (arg.values.length > 0) {\n        checkType(param.value, arg.values[0], position);\n      }\n\n      return;\n    }\n    throwTypeMismatch(\"MoveVector\", position);\n  }\n\n  // Handle structs as they're more complex\n  if (param instanceof TypeTagStruct) {\n    if (param.isString()) {\n      if (isBcsString(arg)) {\n        return;\n      }\n      throwTypeMismatch(\"MoveString\", position);\n    }\n    if (param.isObject()) {\n      if (isBcsAddress(arg)) {\n        return;\n      }\n      throwTypeMismatch(\"AccountAddress\", position);\n    }\n    if (param.isOption()) {\n      if (arg instanceof MoveOption) {\n        // If there's a value, we can check the inner type (otherwise it doesn't really matter)\n        if (arg.value !== undefined) {\n          checkType(param.value.typeArgs[0], arg.value, position);\n        }\n        return;\n      }\n      throwTypeMismatch(\"MoveOption\", position);\n    }\n  }\n\n  throw new Error(`Type mismatch for argument ${position}, expected '${param.toString()}'`);\n}\n"],"mappings":"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","names":["TEXT_ENCODER","standardizeTypeTags","typeArguments","typeArg","isString","parseTypeTag","fetchFunctionAbi","moduleAddress","moduleName","functionName","aptosConfig","module","getModule","func","fetchEntryFunctionAbi","functionAbi","numSigners","findFirstNonSignerArg","params","i","fetchViewFunctionAbi","returnTypes","convertArgument","arg","position","genericTypeParams","param","checkOrConvertArgument","isEncodedEntryFunctionArgument","checkType","parseArg","isBool","Bool","throwTypeMismatch","AccountAddress","num","convertNumber","U8","U16","U32","isLargeNumber","U64","U128","U256","genericIndex","MoveVector","item","MoveString","isEmptyOption","innerParam","TypeTagBool","MoveOption","TypeTagAddress","TypeTagU8","TypeTagU16","TypeTagU32","TypeTagU64","TypeTagU128","TypeTagU256","isBcsBool","isBcsAddress","isBcsU8","isBcsU16","isBcsU32","isBcsU64","isBcsU128","isBcsU256","TypeTagStruct","isBcsString"]}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/management/asyncQueue.ts"],"sourcesContent":["/**\n * The AsyncQueue class is an async-aware data structure that provides a queue-like\n * behavior for managing asynchronous tasks or operations.\n * It allows to enqueue items and dequeue them asynchronously.\n * This is not thread-safe but it is async concurrency safe and\n * it does not guarantee ordering for those that call into and await on enqueue.\n */\n\ninterface PendingDequeue<T> {\n  resolve: (value: T) => void;\n  reject: (reason?: AsyncQueueCancelledError) => void;\n}\n\nexport class AsyncQueue<T> {\n  readonly queue: T[] = [];\n\n  // The pendingDequeue is used to handle the resolution of promises when items are enqueued and dequeued.\n  private pendingDequeue: PendingDequeue<T>[] = [];\n\n  private cancelled: boolean = false;\n\n  /**\n   * The enqueue method adds an item to the queue. If there are pending dequeued promises,\n   * in the pendingDequeue, it resolves the oldest promise with the enqueued item immediately.\n   * Otherwise, it adds the item to the queue.\n   *\n   * @param item T\n   */\n  enqueue(item: T): void {\n    this.cancelled = false;\n\n    if (this.pendingDequeue.length > 0) {\n      const promise = this.pendingDequeue.shift();\n\n      promise?.resolve(item);\n\n      return;\n    }\n\n    this.queue.push(item);\n  }\n\n  /**\n   * The dequeue method returns a promise that resolves to the next item in the queue.\n   * If the queue is not empty, it resolves the promise immediately with the next item.\n   * Otherwise, it creates a new promise. The promise's resolve function is stored\n   * in the pendingDequeue with a unique counter value as the key.\n   * The newly created promise is then returned, and it will be resolved later when an item is enqueued.\n   *\n   * @returns Promise<T>\n   */\n  async dequeue(): Promise<T> {\n    if (this.queue.length > 0) {\n      return Promise.resolve(this.queue.shift()!);\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      this.pendingDequeue.push({ resolve, reject });\n    });\n  }\n\n  /**\n   * The isEmpty method returns whether the queue is empty or not.\n   *\n   * @returns boolean\n   */\n  isEmpty(): boolean {\n    return this.queue.length === 0;\n  }\n\n  /**\n   * The cancel method cancels all pending promises in the queue.\n   * It rejects the promises with a AsyncQueueCancelledError error,\n   * ensuring that any awaiting code can handle the cancellation appropriately.\n   */\n  cancel(): void {\n    this.cancelled = true;\n\n    this.pendingDequeue.forEach(async ({ reject }) => {\n      reject(new AsyncQueueCancelledError(\"Task cancelled\"));\n    });\n\n    this.pendingDequeue = [];\n\n    this.queue.length = 0;\n  }\n\n  /**\n   * The isCancelled method returns whether the queue is cancelled or not.\n   *\n   * @returns boolean\n   */\n  isCancelled(): boolean {\n    return this.cancelled;\n  }\n\n  /**\n   * The pendingDequeueLength method returns the length of the pendingDequeue.\n   *\n   * @returns number\n   */\n  pendingDequeueLength(): number {\n    return this.pendingDequeue.length;\n  }\n}\n\nexport class AsyncQueueCancelledError extends Error {}\n"],"mappings":"AAaO,IAAMA,EAAN,KAAoB,CAApB,cACL,KAAS,MAAa,CAAC,EAGvB,KAAQ,eAAsC,CAAC,EAE/C,KAAQ,UAAqB,GAS7B,QAAQC,EAAe,CAGrB,GAFA,KAAK,UAAY,GAEb,KAAK,eAAe,OAAS,EAAG,CAClB,KAAK,eAAe,MAAM,GAEjC,QAAQA,CAAI,EAErB,MACF,CAEA,KAAK,MAAM,KAAKA,CAAI,CACtB,CAWA,MAAM,SAAsB,CAC1B,OAAI,KAAK,MAAM,OAAS,EACf,QAAQ,QAAQ,KAAK,MAAM,MAAM,CAAE,EAGrC,IAAI,QAAW,CAACC,EAASC,IAAW,CACzC,KAAK,eAAe,KAAK,CAAE,QAAAD,EAAS,OAAAC,CAAO,CAAC,CAC9C,CAAC,CACH,CAOA,SAAmB,CACjB,OAAO,KAAK,MAAM,SAAW,CAC/B,CAOA,QAAe,CACb,KAAK,UAAY,GAEjB,KAAK,eAAe,QAAQ,MAAO,CAAE,OAAAA,CAAO,IAAM,CAChDA,EAAO,IAAIC,EAAyB,gBAAgB,CAAC,CACvD,CAAC,EAED,KAAK,eAAiB,CAAC,EAEvB,KAAK,MAAM,OAAS,CACtB,CAOA,aAAuB,CACrB,OAAO,KAAK,SACd,CAOA,sBAA+B,CAC7B,OAAO,KAAK,eAAe,MAC7B,CACF,EAEaA,EAAN,cAAuC,KAAM,CAAC","names":["AsyncQueue","item","resolve","reject","AsyncQueueCancelledError"]}

package/dist/esm/chunk-UAEODDZS.mjs

@@ -1,2 +0,0 @@
-var o="1.29.0";export{o as a};
-//# sourceMappingURL=chunk-UAEODDZS.mjs.map