@aptos-labs/ts-sdk 0.0.4 → 0.0.6

package/dist/esm/chunk-R26XML3D.mjs

@@ -0,0 +1,2 @@
+import{a as e,b as n,c as o}from"./chunk-NGCFPQ22.mjs";var s=class{constructor(t){this.config=t}async getAccountEventsByCreationNumber(t){return e({aptosConfig:this.config,...t})}async getAccountEventsByEventType(t){return n({aptosConfig:this.config,...t})}async getEvents(t){return o({aptosConfig:this.config,...t})}};export{s as a};
+//# sourceMappingURL=chunk-R26XML3D.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/event.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosConfig } from \"./aptosConfig\";\nimport { getAccountEventsByCreationNumber, getAccountEventsByEventType, getEvents } from \"../internal/event\";\nimport { AnyNumber, GetEventsResponse, MoveStructId, OrderBy, PaginationArgs } from \"../types\";\nimport { EventsBoolExp } from \"../types/generated/types\";\nimport { AccountAddressInput } from \"../core\";\n\n/**\n * A class to query all `Event` Aptos related queries\n */\nexport class Event {\n  readonly config: AptosConfig;\n\n  constructor(config: AptosConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Get events by creation number and an account address\n   *\n   * @param args.accountAddress - The account address\n   * @param args.creationNumber - The event creation number\n   *\n   * @returns Promise<GetEventsResponse>\n   */\n  async getAccountEventsByCreationNumber(args: {\n    accountAddress: AccountAddressInput;\n    creationNumber: AnyNumber;\n  }): Promise<GetEventsResponse> {\n    return getAccountEventsByCreationNumber({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Get events by event type and an account address\n   *\n   * @param args.accountAddress - The account address\n   * @param args.eventType - The event type\n   *\n   * @returns Promise<GetEventsResponse>\n   */\n  async getAccountEventsByEventType(args: {\n    accountAddress: AccountAddressInput;\n    eventType: MoveStructId;\n    options?: {\n      pagination?: PaginationArgs;\n      orderBy?: OrderBy<GetEventsResponse[0]>;\n    };\n  }): Promise<GetEventsResponse> {\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   *\n   * @example\n   * ```\n   * { where:\n   *  {\n   *   transaction_version: { _eq: 123456 },\n   *  }\n   * }\n   * ```\n   *\n   * @returns GetEventsQuery response type\n   */\n  async getEvents(args?: {\n    options?: {\n      where?: EventsBoolExp;\n      pagination?: PaginationArgs;\n      orderBy?: OrderBy<GetEventsResponse[0]>;\n    };\n  }): Promise<GetEventsResponse> {\n    return getEvents({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"uDAYO,IAAMA,EAAN,KAAY,CAGjB,YAAYC,EAAqB,CAC/B,KAAK,OAASA,CAChB,CAUA,MAAM,iCAAiCC,EAGR,CAC7B,OAAOC,EAAiC,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CAC/E,CAUA,MAAM,4BAA4BA,EAOH,CAC7B,OAAOE,EAA4B,CAAE,YAAa,KAAK,OAAQ,GAAGF,CAAK,CAAC,CAC1E,CAkBA,MAAM,UAAUA,EAMe,CAC7B,OAAOG,EAAU,CAAE,YAAa,KAAK,OAAQ,GAAGH,CAAK,CAAC,CACxD,CACF","names":["Event","config","args","getAccountEventsByCreationNumber","getAccountEventsByEventType","getEvents"]}

package/dist/esm/chunk-R3KWVOFG.mjs

@@ -0,0 +1,2 @@
+import{a as s}from"./chunk-EWTHPMEE.mjs";import{b as i}from"./chunk-NZIJV4O2.mjs";import{a as d}from"./chunk-HA6JD5R6.mjs";var o=class t extends d{constructor(e,r){super();this.address=e,this.name=r}static fromStr(e){let r=e.split("::");if(r.length!==2)throw new Error("Invalid module id.");return new t(i.fromStringRelaxed(r[0]),new s(r[1]))}serialize(e){this.address.serialize(e),this.name.serialize(e)}static deserialize(e){let r=i.deserialize(e),a=s.deserialize(e);return new t(r,a)}};export{o as a};
+//# sourceMappingURL=chunk-R3KWVOFG.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/instances/moduleId.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"./identifier\";\nimport { MoveModuleId } from \"../../types\";\n\n/**\n * Representation of a ModuleId that can serialized and deserialized\n * ModuleId means the module address (e.g \"0x1\") and the module name (e.g \"coin\")\n */\nexport class ModuleId extends Serializable {\n  public readonly address: AccountAddress;\n\n  public readonly name: Identifier;\n\n  /**\n   * Full name of a module.\n   * @param address The account address. e.g \"0x1\"\n   * @param name The module name under the \"address\". e.g \"coin\"\n   */\n  constructor(address: AccountAddress, name: Identifier) {\n    super();\n    this.address = address;\n    this.name = name;\n  }\n\n  /**\n   * Converts a string literal to a ModuleId\n   * @param moduleId String literal in format \"account_address::module_name\", e.g. \"0x1::coin\"\n   * @returns ModuleId\n   */\n  static fromStr(moduleId: MoveModuleId): ModuleId {\n    const parts = moduleId.split(\"::\");\n    if (parts.length !== 2) {\n      throw new Error(\"Invalid module id.\");\n    }\n    return new ModuleId(AccountAddress.fromStringRelaxed(parts[0]), new Identifier(parts[1]));\n  }\n\n  serialize(serializer: Serializer): void {\n    this.address.serialize(serializer);\n    this.name.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): ModuleId {\n    const address = AccountAddress.deserialize(deserializer);\n    const name = Identifier.deserialize(deserializer);\n    return new ModuleId(address, name);\n  }\n}\n"],"mappings":"2HAaO,IAAMA,EAAN,MAAMC,UAAiBC,CAAa,CAUzC,YAAYC,EAAyBC,EAAkB,CACrD,MAAM,EACN,KAAK,QAAUD,EACf,KAAK,KAAOC,CACd,CAOA,OAAO,QAAQC,EAAkC,CAC/C,IAAMC,EAAQD,EAAS,MAAM,IAAI,EACjC,GAAIC,EAAM,SAAW,EACnB,MAAM,IAAI,MAAM,oBAAoB,EAEtC,OAAO,IAAIL,EAASM,EAAe,kBAAkBD,EAAM,CAAC,CAAC,EAAG,IAAIE,EAAWF,EAAM,CAAC,CAAC,CAAC,CAC1F,CAEA,UAAUG,EAA8B,CACtC,KAAK,QAAQ,UAAUA,CAAU,EACjC,KAAK,KAAK,UAAUA,CAAU,CAChC,CAEA,OAAO,YAAYC,EAAsC,CACvD,IAAMP,EAAUI,EAAe,YAAYG,CAAY,EACjDN,EAAOI,EAAW,YAAYE,CAAY,EAChD,OAAO,IAAIT,EAASE,EAASC,CAAI,CACnC,CACF","names":["ModuleId","_ModuleId","Serializable","address","name","moduleId","parts","AccountAddress","Identifier","serializer","deserializer"]}

package/dist/esm/chunk-R7G3CLRI.mjs

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

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

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

package/dist/esm/chunk-RMMOF53Q.mjs

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

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

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

package/dist/esm/chunk-RYETO74W.mjs

@@ -0,0 +1,2 @@
+import{a as h,b as p,c as m}from"./chunk-EFIYW4WK.mjs";import{d as H,f as E,g as x,h as z,i as S,j as f}from"./chunk-LR65XHSF.mjs";import{b as i}from"./chunk-TIH6ARYP.mjs";import o from"tweetnacl";var n=class n extends h{constructor(e){super();let r=i.fromHexInput(e);if(r.toUint8Array().length!==n.LENGTH)throw new Error(`PublicKey length should be ${n.LENGTH}`);this.key=r}toUint8Array(){return this.key.toUint8Array()}toString(){return this.key.toString()}verifySignature(e){let{message:r,signature:a}=e,y=i.fromHexInput(r).toUint8Array(),l=a.toUint8Array();return o.sign.detached.verify(y,l,this.key.toUint8Array())}serialize(e){e.serializeBytes(this.key.toUint8Array())}static deserialize(e){let r=e.deserializeBytes();return new n(r)}static load(e){let r=e.deserializeBytes();return new n(r)}};n.LENGTH=32;var u=n,t=class t extends p{constructor(e){super();let r=i.fromHexInput(e);if(r.toUint8Array().length!==t.LENGTH)throw new Error(`PrivateKey length should be ${t.LENGTH}`);this.signingKeyPair=o.sign.keyPair.fromSeed(r.toUint8Array().slice(0,t.LENGTH))}toUint8Array(){return this.signingKeyPair.secretKey.slice(0,t.LENGTH)}toString(){return i.fromHexInput(this.toUint8Array()).toString()}sign(e){let r=i.fromHexInput(e),a=o.sign.detached(r.toUint8Array(),this.signingKeyPair.secretKey);return new d(a)}serialize(e){e.serializeBytes(this.toUint8Array())}static deserialize(e){let r=e.deserializeBytes();return new t(r)}static generate(){let e=o.sign.keyPair();return new t(e.secretKey.slice(0,t.LENGTH))}publicKey(){let e=this.signingKeyPair.publicKey;return new u(e)}static fromDerivationPath(e,r){if(!E(e))throw new Error(`Invalid derivation path ${e}`);return t.fromDerivationPathInner(e,f(r))}static fromDerivationPathInner(e,r,a=H){let{key:y,chainCode:l}=x(t.SLIP_0010_SEED,r),A=S(e).map(c=>parseInt(c,10)),{key:v}=A.reduce((c,K)=>z(c,K+a),{key:y,chainCode:l});return new t(v)}};t.LENGTH=32,t.SLIP_0010_SEED="ed25519 seed";var P=t,s=class s extends m{constructor(e){super();let r=i.fromHexInput(e);if(r.toUint8Array().length!==s.LENGTH)throw new Error(`Signature length should be ${s.LENGTH}`);this.data=r}toUint8Array(){return this.data.toUint8Array()}toString(){return this.data.toString()}serialize(e){e.serializeBytes(this.data.toUint8Array())}static deserialize(e){let r=e.deserializeBytes();return new s(r)}static load(e){let r=e.deserializeBytes();return new s(r)}};s.LENGTH=64;var d=s;export{u as a,P as b,d as c};
+//# sourceMappingURL=chunk-RYETO74W.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/crypto/ed25519.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport nacl from \"tweetnacl\";\nimport { PublicKey, PrivateKey, Signature } from \"./asymmetricCrypto\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializer } from \"../../bcs/serializer\";\nimport { Hex } from \"../hex\";\nimport { HexInput } from \"../../types\";\nimport { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from \"./hdKey\";\n\n/**\n * Represents the public key of an Ed25519 key pair.\n *\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentication keys.\n *\n * Ed25519 scheme is represented in the SDK as `Legacy authentication key` and also\n * as `AnyPublicKey` that represents any `Unified authentication key`\n */\nexport class Ed25519PublicKey extends PublicKey {\n  /**\n   * Length of an Ed25519 public key\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * Bytes of the public key\n   * @private\n   */\n  private readonly key: Hex;\n\n  /**\n   * Create a new PublicKey instance from a Uint8Array or String.\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   */\n  constructor(hexInput: HexInput) {\n    super();\n\n    const hex = Hex.fromHexInput(hexInput);\n    if (hex.toUint8Array().length !== Ed25519PublicKey.LENGTH) {\n      throw new Error(`PublicKey length should be ${Ed25519PublicKey.LENGTH}`);\n    }\n    this.key = hex;\n  }\n\n  /**\n   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   */\n  toUint8Array(): Uint8Array {\n    return this.key.toUint8Array();\n  }\n\n  /**\n   * Get the public key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the public key\n   */\n  toString(): string {\n    return this.key.toString();\n  }\n\n  /**\n   * Verifies a signed data with a public key\n   * @param args.message a signed message\n   * @param args.signature the signature of the message\n   */\n  verifySignature(args: { message: HexInput; signature: Ed25519Signature }): boolean {\n    const { message, signature } = args;\n    const rawMessage = Hex.fromHexInput(message).toUint8Array();\n    const rawSignature = signature.toUint8Array();\n    return nacl.sign.detached.verify(rawMessage, rawSignature, this.key.toUint8Array());\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.key.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Ed25519PublicKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Ed25519PublicKey(bytes);\n  }\n\n  static load(deserializer: Deserializer): Ed25519PublicKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Ed25519PublicKey(bytes);\n  }\n}\n\n/**\n * Represents the private key of an Ed25519 key pair.\n */\nexport class Ed25519PrivateKey extends PrivateKey {\n  /**\n   * Length of an Ed25519 private key\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * The Ed25519 key seed to use for BIP-32 compatibility\n   * See more {@link https://github.com/satoshilabs/slips/blob/master/slip-0010.md}\n   */\n  static readonly SLIP_0010_SEED = \"ed25519 seed\";\n\n  /**\n   * The Ed25519 signing key\n   * @private\n   */\n  private readonly signingKeyPair: nacl.SignKeyPair;\n\n  /**\n   * Create a new PrivateKey instance from a Uint8Array or String.\n   *\n   * @param hexInput HexInput (string or Uint8Array)\n   */\n  constructor(hexInput: HexInput) {\n    super();\n\n    const privateKeyHex = Hex.fromHexInput(hexInput);\n    if (privateKeyHex.toUint8Array().length !== Ed25519PrivateKey.LENGTH) {\n      throw new Error(`PrivateKey length should be ${Ed25519PrivateKey.LENGTH}`);\n    }\n\n    // Create keyPair from Private key in Uint8Array format\n    this.signingKeyPair = nacl.sign.keyPair.fromSeed(privateKeyHex.toUint8Array().slice(0, Ed25519PrivateKey.LENGTH));\n  }\n\n  /**\n   * Get the private key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the private key\n   */\n  toUint8Array(): Uint8Array {\n    return this.signingKeyPair.secretKey.slice(0, Ed25519PrivateKey.LENGTH);\n  }\n\n  /**\n   * Get the private key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the private key\n   */\n  toString(): string {\n    return Hex.fromHexInput(this.toUint8Array()).toString();\n  }\n\n  /**\n   * Sign the given message with the private key.\n   *\n   * @param message in HexInput format\n   * @returns Signature\n   */\n  sign(message: HexInput): Ed25519Signature {\n    const hex = Hex.fromHexInput(message);\n    const signature = nacl.sign.detached(hex.toUint8Array(), this.signingKeyPair.secretKey);\n    return new Ed25519Signature(signature);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Ed25519PrivateKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Ed25519PrivateKey(bytes);\n  }\n\n  /**\n   * Generate a new random private key.\n   *\n   * @returns Ed25519PrivateKey\n   */\n  static generate(): Ed25519PrivateKey {\n    const keyPair = nacl.sign.keyPair();\n    return new Ed25519PrivateKey(keyPair.secretKey.slice(0, Ed25519PrivateKey.LENGTH));\n  }\n\n  /**\n   * Derive the Ed25519PublicKey for this private key.\n   *\n   * @returns Ed25519PublicKey\n   */\n  publicKey(): Ed25519PublicKey {\n    const bytes = this.signingKeyPair.publicKey;\n    return new Ed25519PublicKey(bytes);\n  }\n\n  /**\n   * Derives a private key from a mnemonic seed phrase.\n   *\n   * To derive multiple keys from the same phrase, change the path\n   *\n   * IMPORTANT: Ed25519 supports hardened derivation only (since it lacks a key homomorphism,\n   * so non-hardened derivation cannot work)\n   *\n   * @param path the BIP44 path\n   * @param mnemonics the mnemonic seed phrase\n   */\n  static fromDerivationPath(path: string, mnemonics: string): Ed25519PrivateKey {\n    if (!isValidHardenedPath(path)) {\n      throw new Error(`Invalid derivation path ${path}`);\n    }\n    return Ed25519PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));\n  }\n\n  /**\n   * A private inner function so we can separate from the main fromDerivationPath() method\n   * to add tests to verify we create the keys correctly.\n   *\n   * @param path the BIP44 path\n   * @param seed the seed phrase created by the mnemonics\n   * @param offset the offset used for key derivation, defaults to 0x80000000\n   * @returns\n   */\n  private static fromDerivationPathInner(path: string, seed: Uint8Array, offset = HARDENED_OFFSET): Ed25519PrivateKey {\n    const { key, chainCode } = deriveKey(Ed25519PrivateKey.SLIP_0010_SEED, seed);\n\n    const segments = splitPath(path).map((el) => parseInt(el, 10));\n\n    // Derive the child key based on the path\n    const { key: privateKey } = segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {\n      key,\n      chainCode,\n    });\n    return new Ed25519PrivateKey(privateKey);\n  }\n}\n\n/**\n * A signature of a message signed using an Ed25519 private key\n */\nexport class Ed25519Signature extends Signature {\n  /**\n   * Length of an Ed25519 signature\n   */\n  static readonly LENGTH = 64;\n\n  /**\n   * The signature bytes\n   * @private\n   */\n  private readonly data: Hex;\n\n  constructor(hexInput: HexInput) {\n    super();\n    const hex = Hex.fromHexInput(hexInput);\n    if (hex.toUint8Array().length !== Ed25519Signature.LENGTH) {\n      throw new Error(`Signature length should be ${Ed25519Signature.LENGTH}`);\n    }\n\n    this.data = hex;\n  }\n\n  /**\n   * Get the signature in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the signature\n   */\n  toUint8Array(): Uint8Array {\n    return this.data.toUint8Array();\n  }\n\n  /**\n   * Get the signature as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the signature\n   */\n  toString(): string {\n    return this.data.toString();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.data.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Ed25519Signature {\n    const bytes = deserializer.deserializeBytes();\n    return new Ed25519Signature(bytes);\n  }\n\n  static load(deserializer: Deserializer): Ed25519Signature {\n    const bytes = deserializer.deserializeBytes();\n    return new Ed25519Signature(bytes);\n  }\n}\n"],"mappings":"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","names":["nacl","_Ed25519PublicKey","PublicKey","hexInput","hex","Hex","args","message","signature","rawMessage","rawSignature","nacl","serializer","deserializer","bytes","Ed25519PublicKey","_Ed25519PrivateKey","PrivateKey","privateKeyHex","Ed25519Signature","keyPair","path","mnemonics","isValidHardenedPath","mnemonicToSeed","seed","offset","HARDENED_OFFSET","key","chainCode","deriveKey","segments","splitPath","el","privateKey","parentKeys","segment","CKDPriv","Ed25519PrivateKey","_Ed25519Signature","Signature"]}

package/dist/esm/chunk-S36IYY6K.mjs

@@ -0,0 +1,2 @@
+import{a as g}from"./chunk-VWVEDCBM.mjs";import{a as p}from"./chunk-R3KWVOFG.mjs";import{a as y}from"./chunk-EWTHPMEE.mjs";import{a as S}from"./chunk-HVADSXTB.mjs";import{a as M}from"./chunk-4ADA5BE7.mjs";import{a as F,b as d,c as T,d as E,e as _,f as w,g as x}from"./chunk-X32O46IB.mjs";import{b as u}from"./chunk-NZIJV4O2.mjs";import{a as b}from"./chunk-HA6JD5R6.mjs";function D(r){let e=r.deserializeUleb128AsU32();switch(e){case 0:return d.deserialize(r);case 1:return _.deserialize(r);case 2:return w.deserialize(r);case 3:return u.deserialize(r);case 4:return M.deserialize(r,d);case 5:return F.deserialize(r);case 6:return T.deserialize(r);case 7:return E.deserialize(r);case 8:return x.deserialize(r);default:throw new Error(`Unknown variant index for ScriptTransactionArgument: ${e}`)}}var a=class extends b{static deserialize(e){let t=e.deserializeUleb128AsU32();switch(t){case 0:return m.load(e);case 2:return A.load(e);case 3:return z.load(e);default:throw new Error(`Unknown variant index for TransactionPayload: ${t}`)}}},m=class r extends a{constructor(t){super();this.script=t}serialize(t){t.serializeU32AsUleb128(0),this.script.serialize(t)}static load(t){let i=h.deserialize(t);return new r(i)}},A=class r extends a{constructor(t){super();this.entryFunction=t}serialize(t){t.serializeU32AsUleb128(2),this.entryFunction.serialize(t)}static load(t){let i=l.deserialize(t);return new r(i)}},z=class r extends a{constructor(t){super();this.multiSig=t}serialize(t){t.serializeU32AsUleb128(3),this.multiSig.serialize(t)}static load(t){let i=U.deserialize(t);return new r(i)}},l=class r{constructor(e,t,i,n){this.module_name=e,this.function_name=t,this.type_args=i,this.args=n}static build(e,t,i,n){return new r(p.fromStr(e),new y(t),i,n)}serialize(e){this.module_name.serialize(e),this.function_name.serialize(e),e.serializeVector(this.type_args),e.serializeU32AsUleb128(this.args.length),this.args.forEach(t=>{t.serializeForEntryFunction(e)})}static deserialize(e){let t=p.deserialize(e),i=y.deserialize(e),n=e.deserializeVector(g),o=e.deserializeUleb128AsU32(),s=new Array;for(let c=0;c<o;c+=1){let v=e.deserializeUleb128AsU32(),B=S.deserialize(e,v);s.push(B)}return new r(t,i,n,s)}},h=class r{constructor(e,t,i){this.bytecode=e,this.type_args=t,this.args=i}serialize(e){e.serializeBytes(this.bytecode),e.serializeVector(this.type_args),e.serializeU32AsUleb128(this.args.length),this.args.forEach(t=>{t.serializeForScriptFunction(e)})}static deserialize(e){let t=e.deserializeBytes(),i=e.deserializeVector(g),n=e.deserializeUleb128AsU32(),o=new Array;for(let s=0;s<n;s+=1){let c=D(e);o.push(c)}return new r(t,i,o)}},U=class r{constructor(e,t){this.multisig_address=e,this.transaction_payload=t}serialize(e){this.multisig_address.serialize(e),this.transaction_payload===void 0?e.serializeBool(!1):(e.serializeBool(!0),this.transaction_payload.serialize(e))}static deserialize(e){let t=u.deserialize(e),i=e.deserializeBool(),n;return i&&(n=f.deserialize(e)),new r(t,n)}},f=class r{constructor(e){this.transaction_payload=e}serialize(e){e.serializeU32AsUleb128(0),this.transaction_payload.serialize(e)}static deserialize(e){return e.deserializeUleb128AsU32(),new r(l.deserialize(e))}};export{D as a,a as b,m as c,A as d,z as e,l as f,h as g,U as h,f as i};
+//# sourceMappingURL=chunk-S36IYY6K.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/instances/transactionPayload.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 { EntryFunctionBytes } from \"../../bcs/serializable/entryFunctionBytes\";\nimport { Bool, U128, U16, U256, U32, U64, U8 } from \"../../bcs/serializable/movePrimitives\";\nimport { MoveVector } from \"../../bcs/serializable/moveStructs\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"./identifier\";\nimport { ModuleId } from \"./moduleId\";\nimport type { EntryFunctionArgument, ScriptFunctionArgument, TransactionArgument } from \"./transactionArgument\";\nimport { MoveModuleId, ScriptTransactionArgumentVariants, TransactionPayloadVariants } from \"../../types\";\nimport { TypeTag } from \"../typeTag\";\n\n/**\n * Deserialize a Script Transaction Argument\n */\nexport function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument {\n  // index enum variant\n  const index = deserializer.deserializeUleb128AsU32();\n  switch (index) {\n    case ScriptTransactionArgumentVariants.U8:\n      return U8.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U64:\n      return U64.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U128:\n      return U128.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.Address:\n      return AccountAddress.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U8Vector:\n      return MoveVector.deserialize(deserializer, U8);\n    case ScriptTransactionArgumentVariants.Bool:\n      return Bool.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U16:\n      return U16.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U32:\n      return U32.deserialize(deserializer);\n    case ScriptTransactionArgumentVariants.U256:\n      return U256.deserialize(deserializer);\n    default:\n      throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`);\n  }\n}\n\n/**\n * Representation of the supported Transaction Payload\n * that can serialized and deserialized\n */\nexport abstract class TransactionPayload extends Serializable {\n  /**\n   * Serialize a Transaction Payload\n   */\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Deserialize a Transaction Payload\n   */\n  static deserialize(deserializer: Deserializer): TransactionPayload {\n    // index enum variant\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case TransactionPayloadVariants.Script:\n        return TransactionPayloadScript.load(deserializer);\n      case TransactionPayloadVariants.EntryFunction:\n        return TransactionPayloadEntryFunction.load(deserializer);\n      case TransactionPayloadVariants.Multisig:\n        return TransactionPayloadMultisig.load(deserializer);\n      default:\n        throw new Error(`Unknown variant index for TransactionPayload: ${index}`);\n    }\n  }\n}\n\n/**\n * Representation of a Transaction Payload Script that can serialized and deserialized\n */\nexport class TransactionPayloadScript extends TransactionPayload {\n  public readonly script: Script;\n\n  constructor(script: Script) {\n    super();\n    this.script = script;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionPayloadVariants.Script);\n    this.script.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TransactionPayloadScript {\n    const script = Script.deserialize(deserializer);\n    return new TransactionPayloadScript(script);\n  }\n}\n\n/**\n * Representation of a Transaction Payload Entry Function that can serialized and deserialized\n */\nexport class TransactionPayloadEntryFunction extends TransactionPayload {\n  public readonly entryFunction: EntryFunction;\n\n  constructor(entryFunction: EntryFunction) {\n    super();\n    this.entryFunction = entryFunction;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionPayloadVariants.EntryFunction);\n    this.entryFunction.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TransactionPayloadEntryFunction {\n    const entryFunction = EntryFunction.deserialize(deserializer);\n    return new TransactionPayloadEntryFunction(entryFunction);\n  }\n}\n\n/**\n * Representation of a Transaction Payload Multi-sig that can serialized and deserialized\n */\nexport class TransactionPayloadMultisig extends TransactionPayload {\n  public readonly multiSig: MultiSig;\n\n  constructor(multiSig: MultiSig) {\n    super();\n    this.multiSig = multiSig;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TransactionPayloadVariants.Multisig);\n    this.multiSig.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TransactionPayloadMultisig {\n    const multiSig = MultiSig.deserialize(deserializer);\n    return new TransactionPayloadMultisig(multiSig);\n  }\n}\n\n/**\n * Representation of a EntryFunction that can serialized and deserialized\n */\nexport class EntryFunction {\n  public readonly module_name: ModuleId;\n\n  public readonly function_name: Identifier;\n\n  public readonly type_args: Array<TypeTag>;\n\n  public readonly args: Array<EntryFunctionArgument>;\n\n  /**\n   * Contains the payload to run a function within a module.\n   * @param module_name Fully qualified module name in format \"account_address::module_name\" e.g. \"0x1::coin\"\n   * @param function_name The function name. e.g \"transfer\"\n   * @param type_args Type arguments that move function requires.\n   *\n   * @example\n   * A coin transfer function has one type argument \"CoinType\".\n   * ```\n   * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)\n   * ```\n   * @param args arguments to the move function.\n   *\n   * @example\n   * A coin transfer function has three arguments \"from\", \"to\" and \"amount\".\n   * ```\n   * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)\n   * ```\n   */\n  constructor(\n    module_name: ModuleId,\n    function_name: Identifier,\n    type_args: Array<TypeTag>,\n    args: Array<EntryFunctionArgument>,\n  ) {\n    this.module_name = module_name;\n    this.function_name = function_name;\n    this.type_args = type_args;\n    this.args = args;\n  }\n\n  /**\n   * A helper function to build a EntryFunction payload from raw primitive values\n   *\n   * @param module_id Fully qualified module name in format \"AccountAddress::module_id\" e.g. \"0x1::coin\"\n   * @param function_name Function name\n   * @param type_args Type arguments that move function requires.\n   *\n   * @example\n   * A coin transfer function has one type argument \"CoinType\".\n   * ```\n   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)\n   * ```\n   * @param args Arguments to the move function.\n   *\n   * @example\n   * A coin transfer function has three arguments \"from\", \"to\" and \"amount\".\n   * ```\n   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)\n   * ```\n   * @returns EntryFunction\n   */\n  static build(\n    module_id: MoveModuleId,\n    function_name: string,\n    type_args: Array<TypeTag>,\n    args: Array<EntryFunctionArgument>,\n  ): EntryFunction {\n    return new EntryFunction(ModuleId.fromStr(module_id), new Identifier(function_name), type_args, args);\n  }\n\n  serialize(serializer: Serializer): void {\n    this.module_name.serialize(serializer);\n    this.function_name.serialize(serializer);\n    serializer.serializeVector<TypeTag>(this.type_args);\n    serializer.serializeU32AsUleb128(this.args.length);\n    this.args.forEach((item: EntryFunctionArgument) => {\n      item.serializeForEntryFunction(serializer);\n    });\n  }\n\n  /**\n   * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.\n   * @see EntryFunctionBytes\n   *\n   * NOTE: When you deserialize an EntryFunction payload with this method, the entry function\n   * arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes\n   * in the form of the EntryFunctionBytes class.\n   *\n   * In order to correctly deserialize these arguments as their actual type representations, you\n   * must know the types of the arguments beforehand and deserialize them yourself individually.\n   *\n   * One way you could achieve this is by using the ABIs for an entry function and deserializing each\n   * argument as its given, corresponding type.\n   *\n   * @param deserializer\n   * @returns A deserialized EntryFunction payload for a transaction.\n   *\n   */\n  static deserialize(deserializer: Deserializer): EntryFunction {\n    const module_name = ModuleId.deserialize(deserializer);\n    const function_name = Identifier.deserialize(deserializer);\n    const type_args = deserializer.deserializeVector(TypeTag);\n\n    const length = deserializer.deserializeUleb128AsU32();\n    const args: Array<EntryFunctionArgument> = new Array<EntryFunctionBytes>();\n\n    for (let i = 0; i < length; i += 1) {\n      const fixedBytesLength = deserializer.deserializeUleb128AsU32();\n      const fixedBytes = EntryFunctionBytes.deserialize(deserializer, fixedBytesLength);\n      args.push(fixedBytes);\n    }\n\n    return new EntryFunction(module_name, function_name, type_args, args);\n  }\n}\n\n/**\n * Representation of a Script that can serialized and deserialized\n */\nexport class Script {\n  /**\n   * The move module bytecode\n   */\n  public readonly bytecode: Uint8Array;\n\n  /**\n   * The type arguments that the bytecode function requires.\n   */\n  public readonly type_args: Array<TypeTag>;\n\n  /**\n   * The arguments that the bytecode function requires.\n   */\n  public readonly args: Array<ScriptFunctionArgument>;\n\n  /**\n   * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.\n   *\n   * @param bytecode The move module bytecode\n   * @param type_args The type arguments that the bytecode function requires.\n   *\n   * @example\n   * A coin transfer function has one type argument \"CoinType\".\n   * ```\n   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)\n   * ```\n   * @param args The arguments that the bytecode function requires.\n   *\n   * @example\n   * A coin transfer function has three arguments \"from\", \"to\" and \"amount\".\n   * ```\n   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)\n   * ```\n   */\n  constructor(bytecode: Uint8Array, type_args: Array<TypeTag>, args: Array<ScriptFunctionArgument>) {\n    this.bytecode = bytecode;\n    this.type_args = type_args;\n    this.args = args;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.bytecode);\n    serializer.serializeVector<TypeTag>(this.type_args);\n    serializer.serializeU32AsUleb128(this.args.length);\n    this.args.forEach((item: ScriptFunctionArgument) => {\n      item.serializeForScriptFunction(serializer);\n    });\n  }\n\n  static deserialize(deserializer: Deserializer): Script {\n    const bytecode = deserializer.deserializeBytes();\n    const type_args = deserializer.deserializeVector(TypeTag);\n    const length = deserializer.deserializeUleb128AsU32();\n    const args = new Array<ScriptFunctionArgument>();\n    for (let i = 0; i < length; i += 1) {\n      // Note that we deserialize directly to the Move value, not its Script argument representation.\n      // We are abstracting away the Script argument representation because knowing about it is\n      // functionally useless.\n      const scriptArgument = deserializeFromScriptArgument(deserializer);\n      args.push(scriptArgument);\n    }\n    return new Script(bytecode, type_args, args);\n  }\n}\n\n/**\n * Representation of a MultiSig that can serialized and deserialized\n */\nexport class MultiSig {\n  public readonly multisig_address: AccountAddress;\n\n  public readonly transaction_payload?: MultisigTransactionPayload;\n\n  /**\n   * Contains the payload to run a multi-sig account transaction.\n   *\n   * @param multisig_address The multi-sig account address the transaction will be executed as.\n   *\n   * @param transaction_payload The payload of the multi-sig transaction. This is optional when executing a multi-sig\n   *  transaction whose payload is already stored on chain.\n   */\n  constructor(multisig_address: AccountAddress, transaction_payload?: MultisigTransactionPayload) {\n    this.multisig_address = multisig_address;\n    this.transaction_payload = transaction_payload;\n  }\n\n  serialize(serializer: Serializer): void {\n    this.multisig_address.serialize(serializer);\n    // Options are encoded with an extra u8 field before the value - 0x0 is none and 0x1 is present.\n    // We use serializeBool below to create this prefix value.\n    if (this.transaction_payload === undefined) {\n      serializer.serializeBool(false);\n    } else {\n      serializer.serializeBool(true);\n      this.transaction_payload.serialize(serializer);\n    }\n  }\n\n  static deserialize(deserializer: Deserializer): MultiSig {\n    const multisig_address = AccountAddress.deserialize(deserializer);\n    const payloadPresent = deserializer.deserializeBool();\n    let transaction_payload;\n    if (payloadPresent) {\n      transaction_payload = MultisigTransactionPayload.deserialize(deserializer);\n    }\n    return new MultiSig(multisig_address, transaction_payload);\n  }\n}\n\n/**\n * Representation of a MultiSig Transaction Payload from `multisig_account.move`\n * that can be serialized and deserialized\n\n * This class exists right now to represent an extensible transaction payload class for\n * transactions used in `multisig_account.move`. Eventually, this class will be able to\n * support script payloads when the `multisig_account.move` module supports them.\n */\nexport class MultisigTransactionPayload {\n  public readonly transaction_payload: EntryFunction;\n\n  /**\n   * Contains the payload to run a multi-sig account transaction.\n   *\n   * @param transaction_payload The payload of the multi-sig transaction.\n   * This can only be EntryFunction for now but,\n   * Script might be supported in the future.\n   */\n  constructor(transaction_payload: EntryFunction) {\n    this.transaction_payload = transaction_payload;\n  }\n\n  serialize(serializer: Serializer): void {\n    /**\n     * We can support multiple types of inner transaction payload in the future.\n     * For now, it's only EntryFunction but if we support more types,\n     * we need to serialize with the right enum values here\n     */\n    serializer.serializeU32AsUleb128(0);\n    this.transaction_payload.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): MultisigTransactionPayload {\n    // This is the enum value indicating which type of payload the multi-sig transaction contains.\n    deserializer.deserializeUleb128AsU32();\n    return new MultisigTransactionPayload(EntryFunction.deserialize(deserializer));\n  }\n}\n"],"mappings":"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","names":["deserializeFromScriptArgument","deserializer","index","U8","U64","U128","AccountAddress","MoveVector","Bool","U16","U32","U256","TransactionPayload","Serializable","TransactionPayloadScript","TransactionPayloadEntryFunction","TransactionPayloadMultisig","_TransactionPayloadScript","script","serializer","Script","_TransactionPayloadEntryFunction","entryFunction","EntryFunction","_TransactionPayloadMultisig","multiSig","MultiSig","_EntryFunction","module_name","function_name","type_args","args","module_id","ModuleId","Identifier","item","TypeTag","length","i","fixedBytesLength","fixedBytes","EntryFunctionBytes","_Script","bytecode","scriptArgument","_MultiSig","multisig_address","transaction_payload","payloadPresent","MultisigTransactionPayload","_MultisigTransactionPayload"]}

package/dist/esm/chunk-TCTZCPQ6.mjs

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

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

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

package/dist/esm/chunk-TIH6ARYP.mjs

@@ -0,0 +1,2 @@
+import{a}from"./chunk-FBPNHF54.mjs";import{bytesToHex as o,hexToBytes as l}from"@noble/hashes/utils";var g=(e=>(e.TOO_SHORT="too_short",e.INVALID_LENGTH="invalid_length",e.INVALID_HEX_CHARS="invalid_hex_chars",e))(g||{}),i=class n{constructor(t){this.data=t}toUint8Array(){return this.data}toStringWithoutPrefix(){return o(this.data)}toString(){return`0x${this.toStringWithoutPrefix()}`}static fromString(t){let r=t;if(r.startsWith("0x")&&(r=r.slice(2)),r.length===0)throw new a("Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.","too_short");if(r.length%2!==0)throw new a("Hex string must be an even number of hex characters.","invalid_length");try{return new n(l(r))}catch(e){let s=e;throw new a(`Hex string contains invalid hex characters: ${s.message}`,"invalid_hex_chars")}}static fromHexInput(t){return t instanceof Uint8Array?new n(t):n.fromString(t)}static isValid(t){try{return n.fromString(t),{valid:!0}}catch(r){let e=r;return{valid:!1,invalidReason:e.invalidReason,invalidReasonMessage:e.message}}}equals(t){return this.data.length!==t.data.length?!1:this.data.every((r,e)=>r===t.data[e])}};export{g as a,i as b};
+//# sourceMappingURL=chunk-TIH6ARYP.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/hex.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bytesToHex, hexToBytes } from \"@noble/hashes/utils\";\nimport { ParsingError, ParsingResult } from \"./common\";\nimport { HexInput } from \"../types\";\n\n/**\n * This enum is used to explain why parsing might have failed.\n */\nexport enum HexInvalidReason {\n  TOO_SHORT = \"too_short\",\n  INVALID_LENGTH = \"invalid_length\",\n  INVALID_HEX_CHARS = \"invalid_hex_chars\",\n}\n\n/**\n * NOTE: Do not use this class when working with account addresses, use AccountAddress.\n *\n * NOTE: When accepting hex data as input to a function, prefer to accept HexInput and\n * then use the static helper methods of this class to convert it into the desired\n * format. This enables the greatest flexibility for the developer.\n *\n * Hex is a helper class for working with hex data. Hex data, when represented as a\n * string, generally looks like this, for example: 0xaabbcc, 45cd32, etc.\n *\n * You might use this class like this:\n *\n * ```ts\n * getTransactionByHash(txnHash: HexInput): Promise<Transaction> {\n *   const txnHashString = Hex.fromHexInput(txnHash).toString();\n *   return await getTransactionByHashInner(txnHashString);\n * }\n * ```\n *\n * This call to `Hex.fromHexInput().toString()` converts the HexInput to a hex string\n * with a leading 0x prefix, regardless of what the input format was.\n *\n * These are some other ways to chain the functions together:\n * - `Hex.fromString({ hexInput: \"0x1f\" }).toUint8Array()`\n * - `new Hex([1, 3]).toStringWithoutPrefix()`\n */\nexport class Hex {\n  private readonly data: Uint8Array;\n\n  /**\n   * Create a new Hex instance from a Uint8Array.\n   *\n   * @param data Uint8Array\n   */\n  constructor(data: Uint8Array) {\n    this.data = data;\n  }\n\n  // ===\n  // Methods for representing an instance of Hex as other types.\n  // ===\n\n  /**\n   * Get the inner hex data. The inner data is already a Uint8Array so no conversion\n   * is taking place here, it just returns the inner data.\n   *\n   * @returns Hex data as Uint8Array\n   */\n  toUint8Array(): Uint8Array {\n    return this.data;\n  }\n\n  /**\n   * Get the hex data as a string without the 0x prefix.\n   *\n   * @returns Hex string without 0x prefix\n   */\n  toStringWithoutPrefix(): string {\n    return bytesToHex(this.data);\n  }\n\n  /**\n   * Get the hex data as a string with the 0x prefix.\n   *\n   * @returns Hex string with 0x prefix\n   */\n  toString(): string {\n    return `0x${this.toStringWithoutPrefix()}`;\n  }\n\n  // ===\n  // Methods for creating an instance of Hex from other types.\n  // ===\n\n  /**\n   * Static method to convert a hex string to Hex\n   *\n   * @param str A hex string, with or without the 0x prefix\n   *\n   * @returns Hex\n   */\n  static fromString(str: string): Hex {\n    let input = str;\n\n    if (input.startsWith(\"0x\")) {\n      input = input.slice(2);\n    }\n\n    if (input.length === 0) {\n      throw new ParsingError(\n        \"Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.\",\n        HexInvalidReason.TOO_SHORT,\n      );\n    }\n\n    if (input.length % 2 !== 0) {\n      throw new ParsingError(\"Hex string must be an even number of hex characters.\", HexInvalidReason.INVALID_LENGTH);\n    }\n\n    try {\n      return new Hex(hexToBytes(input));\n    } catch (e) {\n      const error = e as Error;\n      throw new ParsingError(\n        `Hex string contains invalid hex characters: ${error.message}`,\n        HexInvalidReason.INVALID_HEX_CHARS,\n      );\n    }\n  }\n\n  /**\n   * Static method to convert an instance of HexInput to Hex\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   *\n   * @returns Hex\n   */\n  static fromHexInput(hexInput: HexInput): Hex {\n    if (hexInput instanceof Uint8Array) return new Hex(hexInput);\n    return Hex.fromString(hexInput);\n  }\n\n  // ===\n  // Methods for checking validity.\n  // ===\n\n  /**\n   * Check if the string is valid hex.\n   *\n   * @param str A hex string representing byte data.\n   *\n   * @returns valid = true if the string is valid, false if not. If the string is not\n   * valid, invalidReason and invalidReasonMessage will be set explaining why it is\n   * invalid.\n   */\n  static isValid(str: string): ParsingResult<HexInvalidReason> {\n    try {\n      Hex.fromString(str);\n      return { valid: true };\n    } catch (e) {\n      const error = e as ParsingError<HexInvalidReason>;\n      return {\n        valid: false,\n        invalidReason: error.invalidReason,\n        invalidReasonMessage: error.message,\n      };\n    }\n  }\n\n  /**\n   * Return whether Hex instances are equal. Hex instances are considered equal if\n   * their underlying byte data is identical.\n   *\n   * @param other The Hex instance to compare to.\n   * @returns true if the Hex instances are equal, false if not.\n   */\n  equals(other: Hex): boolean {\n    if (this.data.length !== other.data.length) return false;\n    return this.data.every((value, index) => value === other.data[index]);\n  }\n}\n"],"mappings":"oCAGA,OAAS,cAAAA,EAAY,cAAAC,MAAkB,sBAOhC,IAAKC,OACVA,EAAA,UAAY,YACZA,EAAA,eAAiB,iBACjBA,EAAA,kBAAoB,oBAHVA,OAAA,IAgCCC,EAAN,MAAMC,CAAI,CAQf,YAAYC,EAAkB,CAC5B,KAAK,KAAOA,CACd,CAYA,cAA2B,CACzB,OAAO,KAAK,IACd,CAOA,uBAAgC,CAC9B,OAAOC,EAAW,KAAK,IAAI,CAC7B,CAOA,UAAmB,CACjB,MAAO,KAAK,KAAK,sBAAsB,CAAC,EAC1C,CAaA,OAAO,WAAWC,EAAkB,CAClC,IAAIC,EAAQD,EAMZ,GAJIC,EAAM,WAAW,IAAI,IACvBA,EAAQA,EAAM,MAAM,CAAC,GAGnBA,EAAM,SAAW,EACnB,MAAM,IAAIC,EACR,4FACA,WACF,EAGF,GAAID,EAAM,OAAS,IAAM,EACvB,MAAM,IAAIC,EAAa,uDAAwD,gBAA+B,EAGhH,GAAI,CACF,OAAO,IAAIL,EAAIM,EAAWF,CAAK,CAAC,CAClC,OAAS,EAAG,CACV,IAAMG,EAAQ,EACd,MAAM,IAAIF,EACR,+CAA+CE,EAAM,OAAO,GAC5D,mBACF,CACF,CACF,CASA,OAAO,aAAaC,EAAyB,CAC3C,OAAIA,aAAoB,WAAmB,IAAIR,EAAIQ,CAAQ,EACpDR,EAAI,WAAWQ,CAAQ,CAChC,CAeA,OAAO,QAAQL,EAA8C,CAC3D,GAAI,CACF,OAAAH,EAAI,WAAWG,CAAG,EACX,CAAE,MAAO,EAAK,CACvB,OAASM,EAAG,CACV,IAAMF,EAAQE,EACd,MAAO,CACL,MAAO,GACP,cAAeF,EAAM,cACrB,qBAAsBA,EAAM,OAC9B,CACF,CACF,CASA,OAAOG,EAAqB,CAC1B,OAAI,KAAK,KAAK,SAAWA,EAAM,KAAK,OAAe,GAC5C,KAAK,KAAK,MAAM,CAACC,EAAOC,IAAUD,IAAUD,EAAM,KAAKE,CAAK,CAAC,CACtE,CACF","names":["bytesToHex","hexToBytes","HexInvalidReason","Hex","_Hex","data","bytesToHex","str","input","ParsingError","hexToBytes","error","hexInput","e","other","value","index"]}

package/dist/esm/chunk-TQD4IGUM.mjs

@@ -0,0 +1,2 @@
+import{a as b}from"./chunk-AH44UPM4.mjs";import{d as S,g as d}from"./chunk-7MNEEVXY.mjs";import{c as C,d as h,e as w,f as k,g as T,i as O,j as q,k as v}from"./chunk-WX43AJTD.mjs";import{b as g,c as p}from"./chunk-3JVGSFHP.mjs";import{a as l}from"./chunk-6FBKUTGF.mjs";import{a as f}from"./chunk-UPLWWSB4.mjs";import{a as A}from"./chunk-U3LO2FSJ.mjs";import{a as _}from"./chunk-YYRDFZE6.mjs";import{b as m}from"./chunk-62SCW5NH.mjs";import{b as y}from"./chunk-RYETO74W.mjs";import{b as a}from"./chunk-NZIJV4O2.mjs";async function M(t){let{aptosConfig:n,accountAddress:e}=t,{data:o}=await g({aptosConfig:n,originMethod:"getInfo",path:`accounts/${a.from(e).toString()}`});return o}async function co(t){let{aptosConfig:n,accountAddress:e,options:o}=t;return p({aptosConfig:n,originMethod:"getModules",path:`accounts/${a.from(e).toString()}/modules`,params:{ledger_version:o?.ledgerVersion,start:o?.offset,limit:o?.limit??1e3}})}async function ao(t){return t.options?.ledgerVersion!==void 0?G(t):b(async()=>G(t),`module-${t.accountAddress}-${t.moduleName}`,1e3*60*5)()}async function G(t){let{aptosConfig:n,accountAddress:e,moduleName:o,options:s}=t,{data:r}=await g({aptosConfig:n,originMethod:"getModule",path:`accounts/${a.from(e).toString()}/module/${o}`,params:{ledger_version:s?.ledgerVersion}});return r}async function io(t){let{aptosConfig:n,accountAddress:e,options:o}=t;return p({aptosConfig:n,originMethod:"getTransactions",path:`accounts/${a.from(e).toString()}/transactions`,params:{start:o?.offset,limit:o?.limit}})}async function uo(t){let{aptosConfig:n,accountAddress:e,options:o}=t;return p({aptosConfig:n,originMethod:"getResources",path:`accounts/${a.from(e).toString()}/resources`,params:{ledger_version:o?.ledgerVersion,start:o?.offset,limit:o?.limit??999}})}async function K(t){let{aptosConfig:n,accountAddress:e,resourceType:o,options:s}=t,{data:r}=await g({aptosConfig:n,originMethod:"getResource",path:`accounts/${a.from(e).toString()}/resource/${o}`,params:{ledger_version:s?.ledgerVersion}});return r.data}async function Q(t){let{aptosConfig:n,authenticationKey:e,options:o}=t,s=await K({aptosConfig:n,accountAddress:"0x1",resourceType:"0x1::account::OriginatingAddress",options:o}),{address_map:{handle:r}}=s,c=a.from(e);try{let i=await S({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 l&&i.data.error_code==="table_item_not_found")return c;throw i}}async function go(t){let{aptosConfig:n,accountAddress:e}=t,s={owner_address:{_eq:a.from(e).toStringLong()},amount:{_gt:0}},c=await d({aptosConfig:n,query:{query:q,variables:{where_condition:s}},originMethod:"getAccountTokensCount"});if(!c.current_token_ownerships_v2_aggregate.aggregate)throw Error("Failed to get the count of account tokens");return c.current_token_ownerships_v2_aggregate.aggregate.count}async function po(t){let{aptosConfig:n,accountAddress:e,options:o}=t,r={owner_address:{_eq:a.from(e).toStringLong()},amount:{_gt:0}};o?.tokenStandard&&(r.token_standard={_eq:o?.tokenStandard});let c={query:T,variables:{where_condition:r,offset:o?.pagination?.offset,limit:o?.pagination?.limit,order_by:o?.orderBy}};return(await d({aptosConfig:n,query:c,originMethod:"getAccountOwnedTokens"})).current_token_ownerships_v2}async function Ao(t){let{aptosConfig:n,accountAddress:e,collectionAddress:o,options:s}=t,r=a.from(e).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:O,variables:{where_condition:i,offset:s?.pagination?.offset,limit:s?.pagination?.limit,order_by:s?.orderBy}};return(await d({aptosConfig:n,query:u,originMethod:"getAccountOwnedTokensFromCollectionAddress"})).current_token_ownerships_v2}async function fo(t){let{aptosConfig:n,accountAddress:e,options:o}=t,r={owner_address:{_eq:a.from(e).toStringLong()},amount:{_gt:0}};o?.tokenStandard&&(r.current_collection={token_standard:{_eq:o?.tokenStandard}});let c={query:w,variables:{where_condition:r,offset:o?.pagination?.offset,limit:o?.pagination?.limit,order_by:o?.orderBy}};return(await d({aptosConfig:n,query:c,originMethod:"getAccountCollectionsWithOwnedTokens"})).current_collection_ownership_v2_view}async function lo(t){let{aptosConfig:n,accountAddress:e}=t,o=a.from(e).toStringLong(),r=await d({aptosConfig:n,query:{query:v,variables:{address:o}},originMethod:"getAccountTransactionsCount"});if(!r.account_transactions_aggregate.aggregate)throw Error("Failed to get the count of account transactions");return r.account_transactions_aggregate.aggregate.count}async function yo(t){let{aptosConfig:n,accountAddress:e,options:o}=t,r={owner_address:{_eq:a.from(e).toStringLong()}},c={query:h,variables:{where_condition:r,offset:o?.pagination?.offset,limit:o?.pagination?.limit,order_by:o?.orderBy}};return(await d({aptosConfig:n,query:c,originMethod:"getAccountCoinsData"})).current_fungible_asset_balances}async function mo(t){let{aptosConfig:n,accountAddress:e}=t,o=a.from(e).toStringLong(),r=await d({aptosConfig:n,query:{query:C,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 _o(t){let{aptosConfig:n,accountAddress:e,options:o}=t,r={owner_address:{_eq:a.from(e).toStringLong()}},c={query:k,variables:{where_condition:r,offset:o?.pagination?.offset,limit:o?.pagination?.limit,order_by:o?.orderBy}};return(await d({aptosConfig:n,query:c,originMethod:"getAccountOwnedObjects"})).current_objects}async function Co(t){let{aptosConfig:n,privateKey:e}=t,o=new _(e.publicKey());if(e instanceof m){let r=A.fromPublicKeyAndScheme({publicKey:o,scheme:2}).derivedAddress();return f.fromPrivateKeyAndAddress({privateKey:e,address:r})}if(e instanceof y){let s=A.fromPublicKeyAndScheme({publicKey:o,scheme:2});if(await P({authKey:s,aptosConfig:n})){let u=s.derivedAddress();return f.fromPrivateKeyAndAddress({privateKey:e,address:u,legacy:!1})}let c=A.fromPublicKeyAndScheme({publicKey:o,scheme:0});if(await P({authKey:c,aptosConfig:n})){let u=c.derivedAddress();return f.fromPrivateKeyAndAddress({privateKey:e,address:u,legacy:!0})}}throw new Error(`Can't derive account from private key ${e}`)}async function P(t){let{aptosConfig:n,authKey:e}=t,o=await Q({aptosConfig:n,authenticationKey:e.derivedAddress()});try{return await M({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{M as a,co as b,ao as c,io as d,uo as e,K as f,Q as g,go as h,po as i,Ao as j,fo as k,lo as l,yo as m,mo as n,_o as o,Co as p,P as q};
+//# sourceMappingURL=chunk-TQD4IGUM.mjs.map

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

@@ -0,0 +1 @@
+{"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 \"../core/account\";\nimport { PrivateKey } from \"../core/crypto/asymmetricCrypto\";\nimport { getTableItem, queryIndexer } from \"./general\";\nimport {\n  AccountData,\n  GetAccountCoinsDataResponse,\n  GetAccountCollectionsWithOwnedTokenResponse,\n  GetAccountOwnedObjectsResponse,\n  GetAccountOwnedTokensFromCollectionResponse,\n  GetAccountOwnedTokensQueryResponse,\n  LedgerVersion,\n  MoveModuleBytecode,\n  MoveResource,\n  MoveStructId,\n  OrderBy,\n  PaginationArgs,\n  SigningScheme,\n  TokenStandard,\n  TransactionResponse,\n} from \"../types\";\nimport {\n  GetAccountCoinsCountQuery,\n  GetAccountCoinsDataQuery,\n  GetAccountCollectionsWithOwnedTokensQuery,\n  GetAccountOwnedObjectsQuery,\n  GetAccountOwnedTokensFromCollectionQuery,\n  GetAccountOwnedTokensQuery,\n  GetAccountTokensCountQuery,\n  GetAccountTransactionsCountQuery,\n} from \"../types/generated/operations\";\nimport {\n  GetAccountCoinsCount,\n  GetAccountCoinsData,\n  GetAccountCollectionsWithOwnedTokens,\n  GetAccountOwnedObjects,\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 { AnyPublicKey } from \"../core/crypto/anyPublicKey\";\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 & LedgerVersion;\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?: LedgerVersion;\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?: LedgerVersion;\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 & LedgerVersion;\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?: LedgerVersion;\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?: LedgerVersion;\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  if (!data.current_token_ownerships_v2_aggregate.aggregate) {\n    throw Error(\"Failed to get the count of account tokens\");\n  }\n  return data.current_token_ownerships_v2_aggregate.aggregate.count;\n}\n\nexport async function getAccountOwnedTokens(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: {\n    tokenStandard?: TokenStandard;\n    pagination?: PaginationArgs;\n    orderBy?: OrderBy<GetAccountOwnedTokensQueryResponse[0]>;\n  };\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?.pagination?.offset,\n      limit: options?.pagination?.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?: {\n    tokenStandard?: TokenStandard;\n    pagination?: PaginationArgs;\n    orderBy?: OrderBy<GetAccountOwnedTokensFromCollectionResponse[0]>;\n  };\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?.pagination?.offset,\n      limit: options?.pagination?.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?: {\n    tokenStandard?: TokenStandard;\n    pagination?: PaginationArgs;\n    orderBy?: OrderBy<GetAccountCollectionsWithOwnedTokenResponse[0]>;\n  };\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    amount: { _gt: number };\n    current_collection?: { token_standard: { _eq: string } };\n  } = {\n    owner_address: { _eq: address },\n    amount: { _gt: 0 },\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?.pagination?.offset,\n      limit: options?.pagination?.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  if (!data.account_transactions_aggregate.aggregate) {\n    throw Error(\"Failed to get the count of account transactions\");\n  }\n\n  return data.account_transactions_aggregate.aggregate.count;\n}\n\nexport async function getAccountCoinsData(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: {\n    pagination?: PaginationArgs;\n    orderBy?: OrderBy<GetAccountCoinsDataResponse[0]>;\n  };\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    owner_address: { _eq: address },\n  };\n\n  const graphqlQuery = {\n    query: GetAccountCoinsData,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.pagination?.offset,\n      limit: options?.pagination?.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?: {\n    pagination?: PaginationArgs;\n    orderBy?: OrderBy<GetAccountOwnedObjectsResponse[0]>;\n  };\n}): Promise<GetAccountOwnedObjectsResponse> {\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: GetAccountOwnedObjects,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.pagination?.offset,\n      limit: options?.pagination?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n  const data = await queryIndexer<GetAccountOwnedObjectsQuery>({\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.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.SingleKey });\n    const address = authKey.derivedAddress();\n    return Account.fromPrivateKeyAndAddress({ privateKey, address });\n  }\n\n  if (privateKey instanceof Ed25519PrivateKey) {\n    // lookup single sender ed25519\n    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKeyAndScheme({\n      publicKey,\n      scheme: SigningScheme.SingleKey,\n    });\n    const isSingleSenderTransactionAuthenticator = await isAccountExist({\n      authKey: singleSenderTransactionAuthenticatorAuthKey,\n      aptosConfig,\n    });\n    if (isSingleSenderTransactionAuthenticator) {\n      const address = singleSenderTransactionAuthenticatorAuthKey.derivedAddress();\n      return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: false });\n    }\n    // lookup legacy ed25519\n    const legacyAuthKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.Ed25519 });\n    const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });\n    if (isLegacyEd25519) {\n      const address = legacyAuthKey.derivedAddress();\n      return Account.fromPrivateKeyAndAddress({ 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","GetAccountOwnedObjects","deriveAccountFromPrivateKey","privateKey","publicKey","AnyPublicKey","Secp256k1PrivateKey","AuthenticationKey","Account","Ed25519PrivateKey","singleSenderTransactionAuthenticatorAuthKey","isAccountExist","legacyAuthKey","authKey","error"]}

package/dist/esm/chunk-U25N2VWA.mjs

@@ -0,0 +1,2 @@
+import{a as l,c as h}from"./chunk-RYETO74W.mjs";import{a as E,c as b}from"./chunk-EFIYW4WK.mjs";import{b as u}from"./chunk-TIH6ARYP.mjs";var i=class i extends E{constructor(e){super();let{publicKeys:t,threshold:r}=e;if(t.length>i.MAX_KEYS||t.length<i.MIN_KEYS)throw new Error(`Must have between ${i.MIN_KEYS} and ${i.MAX_KEYS} public keys, inclusive`);if(r<i.MIN_THRESHOLD||r>t.length)throw new Error(`Threshold must be between ${i.MIN_THRESHOLD} and ${t.length}, inclusive`);this.publicKeys=t,this.threshold=r}toUint8Array(){let e=new Uint8Array(this.publicKeys.length*l.LENGTH+1);return this.publicKeys.forEach((t,r)=>{e.set(t.toUint8Array(),r*l.LENGTH)}),e[this.publicKeys.length*l.LENGTH]=this.threshold,e}toString(){return u.fromHexInput(this.toUint8Array()).toString()}verifySignature(e){throw new Error("TODO - Method not implemented.")}serialize(e){e.serializeBytes(this.toUint8Array())}static deserialize(e){let t=e.deserializeBytes(),r=t[t.length-1],o=[];for(let a=0;a<t.length-1;a+=l.LENGTH){let s=a;o.push(new l(t.subarray(s,s+l.LENGTH)))}return new i({publicKeys:o,threshold:r})}};i.MAX_KEYS=32,i.MIN_KEYS=2,i.MIN_THRESHOLD=1;var g=i,n=class n extends b{constructor(e){super();let{signatures:t,bitmap:r}=e;if(r.length!==n.BITMAP_LEN)throw new Error(`"bitmap" length should be ${n.BITMAP_LEN}`);if(t.length>n.MAX_SIGNATURES_SUPPORTED)throw new Error(`The number of signatures cannot be greater than ${n.MAX_SIGNATURES_SUPPORTED}`);this.signatures=t,this.bitmap=r}toUint8Array(){let e=new Uint8Array(this.signatures.length*h.LENGTH+n.BITMAP_LEN);return this.signatures.forEach((t,r)=>{e.set(t.toUint8Array(),r*h.LENGTH)}),e.set(this.bitmap,this.signatures.length*h.LENGTH),e}toString(){return u.fromHexInput(this.toUint8Array()).toString()}static createBitmap(e){let{bits:t}=e,r=128,o=new Uint8Array([0,0,0,0]),a=new Set;return t.forEach(s=>{if(s>=n.MAX_SIGNATURES_SUPPORTED)throw new Error(`Cannot have a signature larger than ${n.MAX_SIGNATURES_SUPPORTED-1}.`);if(a.has(s))throw new Error("Duplicate bits detected.");a.add(s);let c=Math.floor(s/8),y=o[c];y|=r>>s%8,o[c]=y}),o}serialize(e){e.serializeBytes(this.toUint8Array())}static deserialize(e){let t=e.deserializeBytes(),r=t.subarray(t.length-4),o=[];for(let a=0;a<t.length-r.length;a+=h.LENGTH){let s=a;o.push(new h(t.subarray(s,s+h.LENGTH)))}return new n({signatures:o,bitmap:r})}};n.MAX_SIGNATURES_SUPPORTED=32,n.BITMAP_LEN=4;var p=n;export{g as a,p as b};
+//# sourceMappingURL=chunk-U25N2VWA.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/crypto/multiEd25519.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { PublicKey, Signature } from \"./asymmetricCrypto\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializer } from \"../../bcs/serializer\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"./ed25519\";\nimport { Hex } from \"../hex\";\nimport { HexInput } from \"../../types\";\n\n/**\n * Represents the public key of a K-of-N Ed25519 multi-sig transaction.\n */\nexport class MultiEd25519PublicKey extends PublicKey {\n  /**\n   * Maximum number of public keys supported\n   */\n  static readonly MAX_KEYS = 32;\n\n  /**\n   * Minimum number of public keys needed\n   */\n  static readonly MIN_KEYS = 2;\n\n  /**\n   * Minimum threshold for the number of valid signatures required\n   */\n  static readonly MIN_THRESHOLD = 1;\n\n  /**\n   * List of Ed25519 public keys for this MultiEd25519PublicKey\n   */\n  public readonly publicKeys: Ed25519PublicKey[];\n\n  /**\n   * The minimum number of valid signatures required, for the number of public keys specified\n   */\n  public readonly threshold: number;\n\n  /**\n   * Public key for a K-of-N multi-sig transaction. A K-of-N multi-sig transaction means that for such a\n   * transaction to be executed, at least K out of the N authorized signers have signed the transaction\n   * and passed the check conducted by the chain.\n   *\n   * @see {@link\n   * https://aptos.dev/integration/creating-a-signed-transaction/ | Creating a Signed Transaction}\n   *\n   * @param args.publicKeys A list of public keys\n   * @param args.threshold At least \"threshold\" signatures must be valid\n   */\n  constructor(args: { publicKeys: Ed25519PublicKey[]; threshold: number }) {\n    super();\n\n    const { publicKeys, threshold } = args;\n\n    // Validate number of public keys\n    if (publicKeys.length > MultiEd25519PublicKey.MAX_KEYS || publicKeys.length < MultiEd25519PublicKey.MIN_KEYS) {\n      throw new Error(\n        `Must have between ${MultiEd25519PublicKey.MIN_KEYS} and ${MultiEd25519PublicKey.MAX_KEYS} public keys, inclusive`,\n      );\n    }\n\n    // Validate threshold: must be between 1 and the number of public keys, inclusive\n    if (threshold < MultiEd25519PublicKey.MIN_THRESHOLD || threshold > publicKeys.length) {\n      throw new Error(\n        `Threshold must be between ${MultiEd25519PublicKey.MIN_THRESHOLD} and ${publicKeys.length}, inclusive`,\n      );\n    }\n\n    this.publicKeys = publicKeys;\n    this.threshold = threshold;\n  }\n\n  /**\n   * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold\n   */\n  toUint8Array(): Uint8Array {\n    const bytes = new Uint8Array(this.publicKeys.length * Ed25519PublicKey.LENGTH + 1);\n    this.publicKeys.forEach((k: Ed25519PublicKey, i: number) => {\n      bytes.set(k.toUint8Array(), i * Ed25519PublicKey.LENGTH);\n    });\n\n    bytes[this.publicKeys.length * Ed25519PublicKey.LENGTH] = this.threshold;\n\n    return bytes;\n  }\n\n  toString(): string {\n    return Hex.fromHexInput(this.toUint8Array()).toString();\n  }\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  verifySignature(args: { message: HexInput; signature: MultiEd25519Signature }): boolean {\n    throw new Error(\"TODO - Method not implemented.\");\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): MultiEd25519PublicKey {\n    const bytes = deserializer.deserializeBytes();\n    const threshold = bytes[bytes.length - 1];\n\n    const keys: Ed25519PublicKey[] = [];\n\n    for (let i = 0; i < bytes.length - 1; i += Ed25519PublicKey.LENGTH) {\n      const begin = i;\n      keys.push(new Ed25519PublicKey(bytes.subarray(begin, begin + Ed25519PublicKey.LENGTH)));\n    }\n    return new MultiEd25519PublicKey({ publicKeys: keys, threshold });\n  }\n}\n\n/**\n * Represents the signature of a K-of-N Ed25519 multi-sig transaction.\n */\nexport class MultiEd25519Signature extends Signature {\n  /**\n   * Maximum number of Ed25519 signatures supported\n   */\n  static MAX_SIGNATURES_SUPPORTED = 32;\n\n  /**\n   * Number of bytes in the bitmap representing who signed the transaction (32-bits)\n   */\n  static BITMAP_LEN: number = 4;\n\n  /**\n   * The list of underlying Ed25519 signatures\n   */\n  public readonly signatures: Ed25519Signature[];\n\n  /**\n   * 32-bit Bitmap representing who signed the transaction\n   *\n   * This is represented where each public key can be masked to determine whether the message was signed by that key.\n   */\n  public readonly bitmap: Uint8Array;\n\n  /**\n   * Signature for a K-of-N multi-sig transaction.\n   *\n   * @see {@link\n   * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}\n   *\n   * @param args.signatures A list of signatures\n   * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth\n   * signature should be provided in `signatures`. Bits are read from left to right\n   */\n  constructor(args: { signatures: Ed25519Signature[]; bitmap: Uint8Array }) {\n    super();\n\n    const { signatures, bitmap } = args;\n    if (bitmap.length !== MultiEd25519Signature.BITMAP_LEN) {\n      throw new Error(`\"bitmap\" length should be ${MultiEd25519Signature.BITMAP_LEN}`);\n    }\n\n    if (signatures.length > MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {\n      throw new Error(\n        `The number of signatures cannot be greater than ${MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED}`,\n      );\n    }\n\n    this.signatures = signatures;\n    this.bitmap = bitmap;\n  }\n\n  /**\n   * Converts a MultiSignature into Uint8Array (bytes) with `bytes = s1_bytes | ... | sn_bytes | bitmap`\n   */\n  toUint8Array(): Uint8Array {\n    const bytes = new Uint8Array(this.signatures.length * Ed25519Signature.LENGTH + MultiEd25519Signature.BITMAP_LEN);\n    this.signatures.forEach((k: Ed25519Signature, i: number) => {\n      bytes.set(k.toUint8Array(), i * Ed25519Signature.LENGTH);\n    });\n\n    bytes.set(this.bitmap, this.signatures.length * Ed25519Signature.LENGTH);\n\n    return bytes;\n  }\n\n  toString(): string {\n    return Hex.fromHexInput(this.toUint8Array()).toString();\n  }\n\n  /**\n   * Helper method to create a bitmap out of the specified bit positions\n   * @param args.bits The bitmap positions that should be set. A position starts at index 0.\n   * Valid position should range between 0 and 31.\n   * @example\n   * Here's an example of valid `bits`\n   * ```\n   * [0, 2, 31]\n   * ```\n   * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.\n   * The result bitmap should be 0b1010000000000000000000000000001\n   *\n   * @returns bitmap that is 32bit long\n   */\n  static createBitmap(args: { bits: number[] }): Uint8Array {\n    const { bits } = args;\n    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.\n    // The decimal value of 0b10000000 is 128.\n    const firstBitInByte = 128;\n    const bitmap = new Uint8Array([0, 0, 0, 0]);\n\n    // Check if duplicates exist in bits\n    const dupCheckSet = new Set();\n\n    bits.forEach((bit: number) => {\n      if (bit >= MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {\n        throw new Error(`Cannot have a signature larger than ${MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED - 1}.`);\n      }\n\n      if (dupCheckSet.has(bit)) {\n        throw new Error(\"Duplicate bits detected.\");\n      }\n\n      dupCheckSet.add(bit);\n\n      const byteOffset = Math.floor(bit / 8);\n\n      let byte = bitmap[byteOffset];\n\n      // eslint-disable-next-line no-bitwise\n      byte |= firstBitInByte >> bit % 8;\n\n      bitmap[byteOffset] = byte;\n    });\n\n    return bitmap;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): MultiEd25519Signature {\n    const bytes = deserializer.deserializeBytes();\n    const bitmap = bytes.subarray(bytes.length - 4);\n\n    const signatures: Ed25519Signature[] = [];\n\n    for (let i = 0; i < bytes.length - bitmap.length; i += Ed25519Signature.LENGTH) {\n      const begin = i;\n      signatures.push(new Ed25519Signature(bytes.subarray(begin, begin + Ed25519Signature.LENGTH)));\n    }\n    return new MultiEd25519Signature({ signatures, bitmap });\n  }\n}\n"],"mappings":"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","names":["_MultiEd25519PublicKey","PublicKey","args","publicKeys","threshold","bytes","Ed25519PublicKey","k","i","Hex","serializer","deserializer","keys","begin","MultiEd25519PublicKey","_MultiEd25519Signature","Signature","signatures","bitmap","Ed25519Signature","bits","firstBitInByte","dupCheckSet","bit","byteOffset","byte","MultiEd25519Signature"]}

package/dist/esm/chunk-U3LO2FSJ.mjs

@@ -0,0 +1,2 @@
+import{a as y}from"./chunk-U25N2VWA.mjs";import{a as m}from"./chunk-44MGBJ73.mjs";import{a as d}from"./chunk-YYRDFZE6.mjs";import{a as l}from"./chunk-RYETO74W.mjs";import{b as u}from"./chunk-NZIJV4O2.mjs";import{a as c}from"./chunk-HA6JD5R6.mjs";import{b as s}from"./chunk-TIH6ARYP.mjs";import{sha3_256 as b}from"@noble/hashes/sha3";var i=class i extends c{constructor(r){super();let{data:t}=r,e=s.fromHexInput(t);if(e.toUint8Array().length!==i.LENGTH)throw new Error(`Authentication Key length should be ${i.LENGTH}`);this.data=e}serialize(r){r.serializeFixedBytes(this.data.toUint8Array())}static deserialize(r){let t=r.deserializeFixedBytes(i.LENGTH);return new i({data:t})}toString(){return this.data.toString()}toUint8Array(){return this.data.toUint8Array()}static fromPublicKeyAndScheme(r){let{publicKey:t,scheme:e}=r,n;switch(e){case 3:case 2:{let a=t.bcsToBytes();n=new Uint8Array([...a,e]);break}case 0:case 1:{let a=t.toUint8Array(),p=s.fromHexInput(a).toUint8Array();n=new Uint8Array([...p,e]);break}default:throw new Error(`Scheme ${e} is not supported`)}let o=b.create();o.update(n);let f=o.digest();return new i({data:f})}static fromPublicKey(r){let{publicKey:t}=r,e;if(t instanceof l)e=0 .valueOf();else if(t instanceof y)e=1 .valueOf();else if(t instanceof d)e=2 .valueOf();else if(t instanceof m)e=3 .valueOf();else throw new Error("No supported authentication scheme for public key");return i.fromPublicKeyAndScheme({publicKey:t,scheme:e})}derivedAddress(){return new u(this.data.toUint8Array())}};i.LENGTH=32;var h=i;export{h as a};
+//# sourceMappingURL=chunk-U3LO2FSJ.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/authenticationKey.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport { AccountAddress } from \"./accountAddress\";\nimport { PublicKey } from \"./crypto/asymmetricCrypto\";\nimport { Ed25519PublicKey } from \"./crypto/ed25519\";\nimport { MultiEd25519PublicKey } from \"./crypto/multiEd25519\";\nimport { Hex } from \"./hex\";\nimport { AuthenticationKeyScheme, HexInput, SigningScheme } from \"../types\";\nimport { AnyPublicKey } from \"./crypto/anyPublicKey\";\nimport { MultiKey } from \"./crypto/multiKey\";\nimport { Serializable, Serializer } from \"../bcs/serializer\";\nimport { Deserializer } from \"../bcs/deserializer\";\n\n/**\n * Each account stores an authentication key. Authentication key enables account owners to rotate\n * their private key(s) associated with the account without changing the address that hosts their account.\n * @see {@link https://aptos.dev/concepts/accounts | Account Basics}\n *\n * Account addresses can be derived from AuthenticationKey\n */\nexport class AuthenticationKey extends Serializable {\n  /**\n   * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.\n   *\n   * The data to hash depends on the underlying public key type and the derivation scheme.\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * The raw bytes of the authentication key.\n   */\n  public readonly data: Hex;\n\n  constructor(args: { data: HexInput }) {\n    super();\n    const { data } = args;\n    const hex = Hex.fromHexInput(data);\n    if (hex.toUint8Array().length !== AuthenticationKey.LENGTH) {\n      throw new Error(`Authentication Key length should be ${AuthenticationKey.LENGTH}`);\n    }\n    this.data = hex;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.data.toUint8Array());\n  }\n\n  /**\n   * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.\n   * @param deserializer The deserializer to deserialize the AuthenticationKey from.\n   * @returns An instance of AuthenticationKey.\n   */\n  static deserialize(deserializer: Deserializer): AuthenticationKey {\n    const bytes = deserializer.deserializeFixedBytes(AuthenticationKey.LENGTH);\n    return new AuthenticationKey({ data: bytes });\n  }\n\n  toString(): string {\n    return this.data.toString();\n  }\n\n  toUint8Array(): Uint8Array {\n    return this.data.toUint8Array();\n  }\n\n  /**\n   * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.\n   *\n   * This facilitates targeting a specific scheme for deriving an authentication key from a public key.\n   *\n   * @param args - the public key and scheme to use for the derivation\n   */\n  public static fromPublicKeyAndScheme(args: { publicKey: PublicKey; scheme: AuthenticationKeyScheme }) {\n    const { publicKey, scheme } = args;\n    let authKeyBytes: Uint8Array;\n\n    switch (scheme) {\n      case SigningScheme.MultiKey:\n      case SigningScheme.SingleKey: {\n        const singleKeyBytes = publicKey.bcsToBytes();\n        authKeyBytes = new Uint8Array([...singleKeyBytes, scheme]);\n        break;\n      }\n\n      case SigningScheme.Ed25519:\n      case SigningScheme.MultiEd25519: {\n        const ed25519PublicKeyBytes = publicKey.toUint8Array();\n        const inputBytes = Hex.fromHexInput(ed25519PublicKeyBytes).toUint8Array();\n        authKeyBytes = new Uint8Array([...inputBytes, scheme]);\n        break;\n      }\n\n      default:\n        throw new Error(`Scheme ${scheme} is not supported`);\n    }\n\n    const hash = sha3Hash.create();\n    hash.update(authKeyBytes);\n    const hashDigest = hash.digest();\n    return new AuthenticationKey({ data: hashDigest });\n  }\n\n  /**\n   * Converts a PublicKey(s) to an AuthenticationKey, using the derivation scheme inferred from the\n   * instance of the PublicKey type passed in.\n   *\n   * @param args.publicKey\n   * @returns AuthenticationKey\n   */\n  static fromPublicKey(args: { publicKey: PublicKey }): AuthenticationKey {\n    const { publicKey } = args;\n\n    let scheme: number;\n    if (publicKey instanceof Ed25519PublicKey) {\n      // for legacy support\n      scheme = SigningScheme.Ed25519.valueOf();\n    } else if (publicKey instanceof MultiEd25519PublicKey) {\n      // for legacy support\n      scheme = SigningScheme.MultiEd25519.valueOf();\n    } else if (publicKey instanceof AnyPublicKey) {\n      scheme = SigningScheme.SingleKey.valueOf();\n    } else if (publicKey instanceof MultiKey) {\n      scheme = SigningScheme.MultiKey.valueOf();\n    } else {\n      throw new Error(\"No supported authentication scheme for public key\");\n    }\n\n    return AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme });\n  }\n\n  /**\n   * Derives an account address from an AuthenticationKey. Since an AccountAddress is also 32 bytes,\n   * the AuthenticationKey bytes are directly translated to an AccountAddress.\n   *\n   * @returns AccountAddress\n   */\n  derivedAddress(): AccountAddress {\n    return new AccountAddress(this.data.toUint8Array());\n  }\n}\n"],"mappings":"+RAGA,OAAS,YAAYA,MAAgB,qBAmB9B,IAAMC,EAAN,MAAMA,UAA0BC,CAAa,CAalD,YAAYC,EAA0B,CACpC,MAAM,EACN,GAAM,CAAE,KAAAC,CAAK,EAAID,EACXE,EAAMC,EAAI,aAAaF,CAAI,EACjC,GAAIC,EAAI,aAAa,EAAE,SAAWJ,EAAkB,OAClD,MAAM,IAAI,MAAM,uCAAuCA,EAAkB,MAAM,EAAE,EAEnF,KAAK,KAAOI,CACd,CAEA,UAAUE,EAA8B,CACtCA,EAAW,oBAAoB,KAAK,KAAK,aAAa,CAAC,CACzD,CAOA,OAAO,YAAYC,EAA+C,CAChE,IAAMC,EAAQD,EAAa,sBAAsBP,EAAkB,MAAM,EACzE,OAAO,IAAIA,EAAkB,CAAE,KAAMQ,CAAM,CAAC,CAC9C,CAEA,UAAmB,CACjB,OAAO,KAAK,KAAK,SAAS,CAC5B,CAEA,cAA2B,CACzB,OAAO,KAAK,KAAK,aAAa,CAChC,CASA,OAAc,uBAAuBN,EAAiE,CACpG,GAAM,CAAE,UAAAO,EAAW,OAAAC,CAAO,EAAIR,EAC1BS,EAEJ,OAAQD,EAAQ,CACd,OACA,OAA8B,CAC5B,IAAME,EAAiBH,EAAU,WAAW,EAC5CE,EAAe,IAAI,WAAW,CAAC,GAAGC,EAAgBF,CAAM,CAAC,EACzD,KACF,CAEA,OACA,OAAiC,CAC/B,IAAMG,EAAwBJ,EAAU,aAAa,EAC/CK,EAAaT,EAAI,aAAaQ,CAAqB,EAAE,aAAa,EACxEF,EAAe,IAAI,WAAW,CAAC,GAAGG,EAAYJ,CAAM,CAAC,EACrD,KACF,CAEA,QACE,MAAM,IAAI,MAAM,UAAUA,CAAM,mBAAmB,CACvD,CAEA,IAAMK,EAAOC,EAAS,OAAO,EAC7BD,EAAK,OAAOJ,CAAY,EACxB,IAAMM,EAAaF,EAAK,OAAO,EAC/B,OAAO,IAAIf,EAAkB,CAAE,KAAMiB,CAAW,CAAC,CACnD,CASA,OAAO,cAAcf,EAAmD,CACtE,GAAM,CAAE,UAAAO,CAAU,EAAIP,EAElBQ,EACJ,GAAID,aAAqBS,EAEvBR,KAA+B,QAAQ,UAC9BD,aAAqBU,EAE9BT,KAAoC,QAAQ,UACnCD,aAAqBW,EAC9BV,KAAiC,QAAQ,UAChCD,aAAqBY,EAC9BX,KAAgC,QAAQ,MAExC,OAAM,IAAI,MAAM,mDAAmD,EAGrE,OAAOV,EAAkB,uBAAuB,CAAE,UAAAS,EAAW,OAAAC,CAAO,CAAC,CACvE,CAQA,gBAAiC,CAC/B,OAAO,IAAIY,EAAe,KAAK,KAAK,aAAa,CAAC,CACpD,CACF,EAvHatB,EAMK,OAAiB,GAN5B,IAAMuB,EAANvB","names":["sha3Hash","_AuthenticationKey","Serializable","args","data","hex","Hex","serializer","deserializer","bytes","publicKey","scheme","authKeyBytes","singleKeyBytes","ed25519PublicKeyBytes","inputBytes","hash","sha3Hash","hashDigest","Ed25519PublicKey","MultiEd25519PublicKey","AnyPublicKey","MultiKey","AccountAddress","AuthenticationKey"]}

package/dist/esm/chunk-U6SZNNVL.mjs

@@ -0,0 +1,2 @@
+import{b as w,c as f,d as x,e as v,f as U,g as A,h as P,i as C,j as y,k as E,l as b,m as I,n as G,o as M}from"./chunk-VWVEDCBM.mjs";import{a as d}from"./chunk-EWTHPMEE.mjs";import{b as l}from"./chunk-NZIJV4O2.mjs";function N(e){return!!e.match(/^[_a-zA-Z0-9]+$/)}function V(e){return!!e.match(/\s/)}function $(e){return!!e.match(/^T[0-9]+$/)}function F(e,n){let i=n;for(;i<e.length;i+=1){let c=e[i];if(!V(c))break}return i}var S=(t=>(t.InvalidTypeTag="unknown type",t.UnexpectedGenericType="unexpected generic type",t.UnexpectedTypeArgumentClose="unexpected '>'",t.UnexpectedWhitespaceCharacter="unexpected whitespace character",t.UnexpectedComma="unexpected ','",t.TypeArgumentCountMismatch="type argument count doesn't match expected amount",t.MissingTypeArgumentClose="no matching '>' for '<'",t.UnexpectedPrimitiveTypeArguments="primitive types not expected to have type arguments",t.UnexpectedVectorTypeArgumentCount="vector type expected to have exactly one type argument",t.UnexpectedStructFormat="unexpected struct format, must be of the form 0xaddress::module_name::struct_name",t.InvalidModuleNameCharacter="module name must only contain alphanumeric or '_' characters",t.InvalidStructNameCharacter="struct name must only contain alphanumeric or '_' characters",t))(S||{}),r=class extends Error{constructor(n,i){super(`Failed to parse typeTag '${n}', ${i}`)}};function Z(e,n){let i=n?.allowGenerics??!1,c=[],o=[],p=[],T=0,a="",u=1;for(;T<e.length;){let g=e[T];if(g==="<")c.push({savedExpectedTypes:u,savedStr:a,savedTypes:p}),a="",p=[],u=1;else if(g===">"){if(a!==""){let _=m(a,o,i);p.push(_)}let s=c.pop();if(s===void 0)throw new r(e,"unexpected '>'");if(u!==p.length)throw new r(e,"type argument count doesn't match expected amount");let{savedStr:h,savedTypes:t,savedExpectedTypes:W}=s;o=p,p=t,a=h,u=W}else if(g===","){if(a.length!==0){let s=m(a,o,i);o=[],p.push(s),a="",u+=1}}else if(V(g)){let s=!1;if(a.length!==0){let t=m(a,o,i);o=[],p.push(t),a="",s=!0}T=F(e,T);let h=e[T];if(T<e.length&&s&&h!==","&&h!==">")throw new r(e,"unexpected whitespace character");continue}else a+=g;T+=1}if(c.length>0)throw new r(e,"no matching '>' for '<'");switch(p.length){case 0:return m(a,o,i);case 1:if(a==="")return p[0];throw new r(e,"unexpected ','");default:throw new r(e,"unexpected whitespace character")}}function m(e,n,i){switch(e){case"&signer":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new E(new y);case"signer":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new y;case"bool":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new w;case"address":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new C;case"u8":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new f;case"u16":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new x;case"u32":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new v;case"u64":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new U;case"u128":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new A;case"u256":if(n.length>0)throw new r(e,"primitive types not expected to have type arguments");return new P;case"vector":if(n.length!==1)throw new r(e,"vector type expected to have exactly one type argument");return new I(n[0]);default:if($(e)){if(i)return new b(Number(e.split("T")[1]));throw new r(e,"unexpected generic type")}if(!e.match(/.*:.*/))throw new r(e,"unknown type");let c=e.split("::");if(c.length!==3)throw new r(e,"unexpected struct format, must be of the form 0xaddress::module_name::struct_name");if(!N(c[1]))throw new r(e,"module name must only contain alphanumeric or '_' characters");if(!N(c[2]))throw new r(e,"struct name must only contain alphanumeric or '_' characters");return new G(new M(l.fromStringRelaxed(c[0]),new d(c[1]),new d(c[2]),n))}}export{S as a,r as b,Z as c};
+//# sourceMappingURL=chunk-U6SZNNVL.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/typeTag/parser.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  StructTag,\n  TypeTag,\n  TypeTagAddress,\n  TypeTagBool,\n  TypeTagGeneric,\n  TypeTagReference,\n  TypeTagSigner,\n  TypeTagStruct,\n  TypeTagU128,\n  TypeTagU16,\n  TypeTagU256,\n  TypeTagU32,\n  TypeTagU64,\n  TypeTagU8,\n  TypeTagVector,\n} from \".\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"../instances/identifier\";\n\nfunction isValidIdentifier(str: string) {\n  return !!str.match(/^[_a-zA-Z0-9]+$/);\n}\n\nfunction isValidWhitespaceCharacter(char: string) {\n  return !!char.match(/\\s/);\n}\n\nfunction isGeneric(str: string) {\n  return !!str.match(/^T[0-9]+$/);\n}\n\nfunction consumeWhitespace(tagStr: string, pos: number) {\n  let i = pos;\n  for (; i < tagStr.length; i += 1) {\n    const innerChar = tagStr[i];\n\n    if (!isValidWhitespaceCharacter(innerChar)) {\n      // If it's not colons, and it's an invalid character, we will stop here\n      break;\n    }\n  }\n  return i;\n}\n\ntype TypeTagState = {\n  savedExpectedTypes: number;\n  savedStr: string;\n  savedTypes: Array<TypeTag>;\n};\n\nexport enum TypeTagParserErrorType {\n  InvalidTypeTag = \"unknown type\",\n  UnexpectedGenericType = \"unexpected generic type\",\n  UnexpectedTypeArgumentClose = \"unexpected '>'\",\n  UnexpectedWhitespaceCharacter = \"unexpected whitespace character\",\n  UnexpectedComma = \"unexpected ','\",\n  TypeArgumentCountMismatch = \"type argument count doesn't match expected amount\",\n  MissingTypeArgumentClose = \"no matching '>' for '<'\",\n  UnexpectedPrimitiveTypeArguments = \"primitive types not expected to have type arguments\",\n  UnexpectedVectorTypeArgumentCount = \"vector type expected to have exactly one type argument\",\n  UnexpectedStructFormat = \"unexpected struct format, must be of the form 0xaddress::module_name::struct_name\",\n  InvalidModuleNameCharacter = \"module name must only contain alphanumeric or '_' characters\",\n  InvalidStructNameCharacter = \"struct name must only contain alphanumeric or '_' characters\",\n}\n\nexport class TypeTagParserError extends Error {\n  constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType) {\n    super(`Failed to parse typeTag '${typeTagStr}', ${invalidReason}`);\n  }\n}\n\n/**\n * All types are made of a few parts they're either:\n * 1. A simple type e.g. u8\n * 2. A standalone struct e.g. 0x1::account::Account\n * 3. A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin>\n *\n * There are a few more special cases that need to be handled, however.\n * 1. Multiple generics e.g 0x1::pair::Pair<u8, u16>\n * 2. Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16>\n * 3. Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8>\n * 4. Generics for types in ABIs are filled in with placeholders e.g T1, T2, T3\n */\nexport function parseTypeTag(typeStr: string, options?: { allowGenerics?: boolean }) {\n  const allowGenerics = options?.allowGenerics ?? false;\n\n  const saved: Array<TypeTagState> = [];\n  // This represents the internal types for a type tag e.g. '0x1::coin::Coin<innerTypes>'\n  let innerTypes: Array<TypeTag> = [];\n  // This represents the current parsed types in a comma list e.g. 'u8, u8'\n  let curTypes: Array<TypeTag> = [];\n  // This represents the current character index\n  let cur: number = 0;\n  // This represents the current working string as a type or struct name\n  let currentStr: string = \"\";\n  let expectedTypes: number = 1;\n\n  // Iterate through each character, and handle the border conditions\n  while (cur < typeStr.length) {\n    const char = typeStr[cur];\n\n    if (char === \"<\") {\n      // Start of a type argument, push current state onto a stack\n      saved.push({\n        savedExpectedTypes: expectedTypes,\n        savedStr: currentStr,\n        savedTypes: curTypes,\n      });\n\n      // Clear current state\n      currentStr = \"\";\n      curTypes = [];\n      expectedTypes = 1;\n    } else if (char === \">\") {\n      // Process last type, if there is no type string, then don't parse it\n      if (currentStr !== \"\") {\n        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n        curTypes.push(newType);\n      }\n\n      // Pop off stack outer type, if there's nothing left, there were too many '>'\n      const savedPop = saved.pop();\n      if (savedPop === undefined) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedTypeArgumentClose);\n      }\n\n      // If the expected types don't match the number of commas, then we also fail\n      if (expectedTypes !== curTypes.length) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.TypeArgumentCountMismatch);\n      }\n\n      // Add in the new created type, shifting the current types to the inner types\n      const { savedStr, savedTypes, savedExpectedTypes } = savedPop;\n      innerTypes = curTypes;\n      curTypes = savedTypes;\n      currentStr = savedStr;\n      expectedTypes = savedExpectedTypes;\n    } else if (char === \",\") {\n      // Comma means we need to start parsing a new tag, push the previous one to the curTypes\n      // Process last type, if there is no type string, then don't parse it\n      if (currentStr.length !== 0) {\n        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n\n        // parse type tag and push it on the types\n        innerTypes = [];\n        curTypes.push(newType);\n        currentStr = \"\";\n        expectedTypes += 1;\n      }\n    } else if (isValidWhitespaceCharacter(char)) {\n      // This means we should save what we have and everything else should skip until the next\n      let parsedTypeTag = false;\n      if (currentStr.length !== 0) {\n        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n\n        // parse type tag and push it on the types\n        innerTypes = [];\n        curTypes.push(newType);\n        currentStr = \"\";\n        parsedTypeTag = true;\n      }\n\n      // Skip ahead on any more whitespace\n      cur = consumeWhitespace(typeStr, cur);\n\n      // The next space MUST be a comma, or a closing > if there was something parsed before\n      // e.g. `u8 u8` is invalid but `u8, u8` is valid\n      const nextChar = typeStr[cur];\n      if (cur < typeStr.length && parsedTypeTag && nextChar !== \",\" && nextChar !== \">\") {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedWhitespaceCharacter);\n      }\n\n      // eslint-disable-next-line no-continue\n      continue;\n    } else {\n      // Any other characters just append to the current string\n      currentStr += char;\n    }\n\n    cur += 1;\n  }\n\n  // This prevents a missing '>' on type arguments\n  if (saved.length > 0) {\n    throw new TypeTagParserError(typeStr, TypeTagParserErrorType.MissingTypeArgumentClose);\n  }\n\n  // This prevents 'u8, u8' as an input\n  switch (curTypes.length) {\n    case 0:\n      return parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n    case 1:\n      if (currentStr === \"\") {\n        return curTypes[0];\n      }\n      throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedComma);\n    default:\n      throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedWhitespaceCharacter);\n  }\n}\n\n/**\n * Parses a type tag with internal types associated\n * @param str\n * @param types\n */\nfunction parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: boolean): TypeTag {\n  // TODO: Parse references to any item not just signer\n  switch (str) {\n    case \"&signer\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagReference(new TypeTagSigner());\n    case \"signer\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagSigner();\n    case \"bool\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagBool();\n    case \"address\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagAddress();\n    case \"u8\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagU8();\n    case \"u16\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagU16();\n    case \"u32\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagU32();\n    case \"u64\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagU64();\n    case \"u128\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagU128();\n    case \"u256\":\n      if (types.length > 0) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n      }\n      return new TypeTagU256();\n    case \"vector\":\n      if (types.length !== 1) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedVectorTypeArgumentCount);\n      }\n      return new TypeTagVector(types[0]);\n    default:\n      if (isGeneric(str)) {\n        if (allowGenerics) {\n          return new TypeTagGeneric(Number(str.split(\"T\")[1]));\n        }\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedGenericType);\n      }\n\n      // If the value doesn't contain a colon, then we'll assume it isn't trying to be a struct\n      if (!str.match(/.*:.*/)) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidTypeTag);\n      }\n\n      // Parse for a struct tag\n      // eslint-disable-next-line no-case-declarations\n      const structParts = str.split(\"::\");\n      if (structParts.length !== 3) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedStructFormat);\n      }\n\n      // Validate identifier characters\n      if (!isValidIdentifier(structParts[1])) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidModuleNameCharacter);\n      }\n      if (!isValidIdentifier(structParts[2])) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidStructNameCharacter);\n      }\n\n      return new TypeTagStruct(\n        new StructTag(\n          AccountAddress.fromStringRelaxed(structParts[0]),\n          new Identifier(structParts[1]),\n          new Identifier(structParts[2]),\n          types,\n        ),\n      );\n  }\n}\n"],"mappings":"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","names":["isValidIdentifier","str","isValidWhitespaceCharacter","char","isGeneric","consumeWhitespace","tagStr","pos","innerChar","TypeTagParserErrorType","TypeTagParserError","typeTagStr","invalidReason","parseTypeTag","typeStr","options","allowGenerics","saved","innerTypes","curTypes","cur","currentStr","expectedTypes","newType","parseTypeTagInner","savedPop","savedStr","savedTypes","savedExpectedTypes","parsedTypeTag","nextChar","types","TypeTagReference","TypeTagSigner","TypeTagBool","TypeTagAddress","TypeTagU8","TypeTagU16","TypeTagU32","TypeTagU64","TypeTagU128","TypeTagU256","TypeTagVector","TypeTagGeneric","structParts","TypeTagStruct","StructTag","AccountAddress","Identifier"]}

package/dist/esm/chunk-UAAI3NCA.mjs

@@ -0,0 +1,2 @@
+import{a as o,b as r}from"./chunk-4ADA5BE7.mjs";import{e as u}from"./chunk-X32O46IB.mjs";import{b as t}from"./chunk-NZIJV4O2.mjs";import{a as i}from"./chunk-HA6JD5R6.mjs";var c=class extends i{constructor(e){super();this.accountAddress=t.ONE;this.moduleName=new r("account");this.structName=new r("RotationProofChallenge");this.sequenceNumber=new u(e.sequenceNumber),this.originator=e.originator,this.currentAuthKey=e.currentAuthKey,this.newPublicKey=o.U8(e.newPublicKey.toUint8Array())}serialize(e){e.serialize(this.accountAddress),e.serialize(this.moduleName),e.serialize(this.structName),e.serialize(this.sequenceNumber),e.serialize(this.originator),e.serialize(this.currentAuthKey),e.serialize(this.newPublicKey)}};export{c as a};
+//# sourceMappingURL=chunk-UAAI3NCA.mjs.map

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

@@ -0,0 +1 @@
+{"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/asymmetricCrypto\";\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-UNQNACJT.mjs

@@ -0,0 +1,2 @@
+import{a as n}from"./chunk-WKY5ENCK.mjs";var t=class{constructor(o){this.config=o}async fundAccount(o){return n({aptosConfig:this.config,...o})}};export{t as a};
+//# sourceMappingURL=chunk-UNQNACJT.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/faucet.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosConfig } from \"./aptosConfig\";\nimport { fundAccount } from \"../internal/faucet\";\nimport { WaitForTransactionOptions } from \"../types\";\nimport { AccountAddressInput } from \"../core\";\n\n/**\n * A class to query all `Faucet` related queries on Aptos.\n */\nexport class Faucet {\n  readonly config: AptosConfig;\n\n  constructor(config: AptosConfig) {\n    this.config = config;\n  }\n\n  /**\n   * This creates an account if it does not exist and mints the specified amount of\n   * coins into that account\n   *\n   * @param args.accountAddress Address of the account to fund\n   * @param args.amount Amount of tokens to fund the account with\n   * @param args.options Configuration options for waitForTransaction\n   * @returns Transaction hash of the transaction that funded the account\n   */\n  async fundAccount(args: {\n    accountAddress: AccountAddressInput;\n    amount: number;\n    options?: WaitForTransactionOptions;\n  }): Promise<string> {\n    return fundAccount({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"yCAWO,IAAMA,EAAN,KAAa,CAGlB,YAAYC,EAAqB,CAC/B,KAAK,OAASA,CAChB,CAWA,MAAM,YAAYC,EAIE,CAClB,OAAOC,EAAY,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CAC1D,CACF","names":["Faucet","config","args","fundAccount"]}

package/dist/esm/chunk-UPLWWSB4.mjs

@@ -0,0 +1,2 @@
+import{a as u}from"./chunk-U3LO2FSJ.mjs";import{a as K}from"./chunk-U25N2VWA.mjs";import{a as n}from"./chunk-YYRDFZE6.mjs";import{a as d,b as y}from"./chunk-62SCW5NH.mjs";import{a as p,b as o}from"./chunk-RYETO74W.mjs";import{b as l}from"./chunk-TIH6ARYP.mjs";var g=class a{constructor(t){let{privateKey:e,address:i,legacy:r}=t,c=r??!0;if(this.publicKey=e.publicKey(),this.publicKey instanceof p)c?this.signingScheme=0:(this.publicKey=new n(this.publicKey),this.signingScheme=2);else if(this.publicKey instanceof K)this.signingScheme=1;else if(this.publicKey instanceof d)this.publicKey=new n(this.publicKey),this.signingScheme=2;else throw new Error("Can not create new Account, unsupported public key type");this.privateKey=e,this.accountAddress=i}static generate(t){let e=t?.legacy??!0,i,r;switch(t?.scheme){case 2:i=y.generate(),r=new n(i.publicKey());break;default:i=o.generate(),e===!1?r=new n(i.publicKey()):r=i.publicKey()}let s=u.fromPublicKey({publicKey:r}).derivedAddress();return new a({privateKey:i,address:s,legacy:t?.legacy})}static fromPrivateKey(t){let{privateKey:e,legacy:i}=t,r=i??!0,c;if(e instanceof y)c=new n(e.publicKey());else if(e instanceof o)r?c=e.publicKey():c=new n(e.publicKey());else throw new Error(`Unsupported private key ${e}`);let m=u.fromPublicKey({publicKey:c}).derivedAddress();return new a({privateKey:e,address:m,legacy:r})}static fromPrivateKeyAndAddress(t){let{privateKey:e,address:i,legacy:r}=t;return new a({privateKey:e,address:i,legacy:r})}static fromDerivationPath(t){let{path:e,mnemonic:i,scheme:r,legacy:c}=t,s;switch(r){case 2:s=y.fromDerivationPath(e,i);break;case 0:s=o.fromDerivationPath(e,i);break;default:throw new Error(`Unsupported scheme ${r}`)}return a.fromPrivateKey({privateKey:s,legacy:c})}static authKey(t){let{publicKey:e}=t;return u.fromPublicKey({publicKey:e})}sign(t){return this.privateKey.sign(t)}verifySignature(t){let{message:e,signature:i}=t,r=l.fromHexInput(e).toUint8Array();return this.publicKey.verifySignature({message:r,signature:i})}};export{g as a};
+//# sourceMappingURL=chunk-UPLWWSB4.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/account.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccountAddress } from \"./accountAddress\";\nimport { AuthenticationKey } from \"./authenticationKey\";\nimport { PrivateKey, PublicKey, Signature } from \"./crypto/asymmetricCrypto\";\nimport { Ed25519PrivateKey, Ed25519PublicKey } from \"./crypto/ed25519\";\nimport { MultiEd25519PublicKey } from \"./crypto/multiEd25519\";\nimport { Secp256k1PrivateKey, Secp256k1PublicKey } from \"./crypto/secp256k1\";\nimport { Hex } from \"./hex\";\nimport { GenerateAccount, HexInput, SigningScheme, SigningSchemeInput } from \"../types\";\nimport { AnyPublicKey } from \"./crypto/anyPublicKey\";\n\n/**\n * Class for creating and managing account on Aptos network\n *\n * Use this class to create accounts, sign transactions, and more.\n * Note: Creating an account instance does not create the account on-chain.\n *\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentications.\n *\n * @Legacy includes `ED25519` and `MultiED25519`\n * @Unified includes `SingleSender` and `MultiSender`, where currently\n * `SingleSender` supports `ED25519` and `Secp256k1`, and `MultiSender` supports\n * `MultiED25519`.\n *\n * In TypeScript SDK, we support all of these options:\n *\n * @generate default to generate Legacy Ed25519 keys, with an optional `legacy` boolean argument\n * that lets you generate new keys conforming to the Unified authentication.\n *\n * @fromPrivateKey derives an account by a provided private key and address, with an optional\n * `legacy` boolean argument that lets you generate new keys conforming to the Unified authentication.\n *\n * @fromDerivationPath derives an account with bip44 path and mnemonics,\n *\n */\nexport class Account {\n  /**\n   * Public key associated with the account\n   */\n  readonly publicKey: PublicKey;\n\n  /**\n   * Private key associated with the account\n   */\n  readonly privateKey: PrivateKey;\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   * constructor for Account\n   *\n   * Need to update this to use the new crypto library if new schemes are added.\n   *\n   * @param args.privateKey PrivateKey - private key of the account\n   * @param args.address AccountAddress - address of the account\n   * @param args.legacy optional. If set to true, the keypair authentication keys will be derived with a Legacy scheme.\n   * Defaults to deriving an authentication key with a Unified scheme\n   *\n   * This method is private because it should only be called by the factory static methods.\n   * @returns Account\n   */\n  private constructor(args: { privateKey: PrivateKey; address: AccountAddress; legacy?: boolean }) {\n    const { privateKey, address, legacy } = args;\n    const useLegacy = legacy ?? true;\n\n    // Derive the public key from the private key\n    this.publicKey = privateKey.publicKey();\n\n    // Derive the signing scheme from the public key\n    if (this.publicKey instanceof Ed25519PublicKey) {\n      if (useLegacy) {\n        this.signingScheme = SigningScheme.Ed25519;\n      } else {\n        this.publicKey = new AnyPublicKey(this.publicKey);\n        this.signingScheme = SigningScheme.SingleKey;\n      }\n    } else if (this.publicKey instanceof MultiEd25519PublicKey) {\n      this.signingScheme = SigningScheme.MultiEd25519;\n    } else if (this.publicKey instanceof Secp256k1PublicKey) {\n      this.publicKey = new AnyPublicKey(this.publicKey);\n      this.signingScheme = SigningScheme.SingleKey;\n    } else {\n      throw new Error(\"Can not create new Account, unsupported public key type\");\n    }\n\n    this.privateKey = privateKey;\n    this.accountAddress = address;\n  }\n\n  /**\n   * Derives an account with random private key and address.\n   *\n   * Default generation is using the Legacy ED25519 key\n   *\n   * @param args optional. Unify GenerateAccount type for Legacy and Unified keys\n   *\n   * Account input type to generate an account using Legacy\n   * Ed25519 or MultiEd25519 keys or without a specified `scheme`.\n   * ```\n   * GenerateAccountWithLegacyKey = {\n   *  scheme?: SigningSchemeInput.Ed25519 | SigningSchemeInput.MultiEd25519;\n   *  legacy: true;\n   * };\n   * ```\n   *\n   * Account input type to generate an account using Unified\n   * Secp256k1Ecdsa key\n   * In this case `legacy` is always false\n   * ```\n   * GenerateAccountWithUnifiedKey = {\n   *  scheme: SigningSchemeInput.Secp256k1Ecdsa;\n   *  legacy?: false;\n   * };\n   * ```\n   *\n   * @returns Account with the given signing scheme\n   */\n  static generate(args?: GenerateAccount): Account {\n    const useLegacy = args?.legacy ?? true;\n\n    let privateKey: PrivateKey;\n    let publicKey: PublicKey;\n\n    switch (args?.scheme) {\n      case SigningSchemeInput.Secp256k1Ecdsa:\n        privateKey = Secp256k1PrivateKey.generate();\n        publicKey = new AnyPublicKey(privateKey.publicKey());\n        break;\n      default:\n        privateKey = Ed25519PrivateKey.generate();\n        if (useLegacy === false) {\n          publicKey = new AnyPublicKey(privateKey.publicKey());\n        } else {\n          publicKey = privateKey.publicKey();\n        }\n    }\n    const authKey = AuthenticationKey.fromPublicKey({ publicKey });\n\n    const address = authKey.derivedAddress();\n    return new Account({ privateKey, address, legacy: args?.legacy });\n  }\n\n  /**\n   * Instantiates an account given a private key.\n   *\n   * This is used as a local calculation and therefore is used to instantiate an `Account`\n   * that has not had its authentication key rotated.\n   *\n   * @param privateKey PrivateKey - private key of the account\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 fromPrivateKey(args: { privateKey: PrivateKey; legacy?: boolean }): Account {\n    const { privateKey, legacy } = args;\n    const useLegacy = legacy ?? true;\n\n    let publicKey;\n    if (privateKey instanceof Secp256k1PrivateKey) {\n      // Secp256k1 single sender\n      publicKey = new AnyPublicKey(privateKey.publicKey());\n    } else if (privateKey instanceof Ed25519PrivateKey) {\n      // legacy Ed25519\n      if (useLegacy) {\n        publicKey = privateKey.publicKey();\n      } else {\n        // Ed25519 single sender\n        publicKey = new AnyPublicKey(privateKey.publicKey());\n      }\n    } else {\n      throw new Error(`Unsupported private key ${privateKey}`);\n    }\n\n    const authKey = AuthenticationKey.fromPublicKey({ publicKey });\n    const address = authKey.derivedAddress();\n    return new Account({ privateKey, address, legacy: useLegacy });\n  }\n\n  /**\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: {\n    privateKey: PrivateKey;\n    address: AccountAddress;\n    legacy?: boolean;\n  }): Account {\n    const { privateKey, address, legacy } = args;\n    return new Account({ privateKey, address, legacy });\n  }\n\n  /**\n   * Derives an account with bip44 path and mnemonics,\n   *\n   * @param args.scheme The signing scheme to derive 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   * @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 fromDerivationPath(args: {\n    scheme: SigningSchemeInput;\n    path: string;\n    mnemonic: string;\n    legacy?: boolean;\n  }): Account {\n    const { path, mnemonic, scheme, legacy } = args;\n    let privateKey: PrivateKey;\n    switch (scheme) {\n      case SigningSchemeInput.Secp256k1Ecdsa:\n        privateKey = Secp256k1PrivateKey.fromDerivationPath(path, mnemonic);\n        break;\n      case SigningSchemeInput.Ed25519:\n        privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);\n        break;\n      default:\n        throw new Error(`Unsupported scheme ${scheme}`);\n    }\n    return Account.fromPrivateKey({ privateKey, legacy });\n  }\n\n  /**\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: PublicKey }): AuthenticationKey {\n    const { publicKey } = args;\n    return AuthenticationKey.fromPublicKey({ publicKey });\n  }\n\n  /**\n   * Sign the given message with the private key.\n   *\n   * TODO: Add sign transaction or specific types\n   *\n   * @param data in HexInput format\n   * @returns Signature\n   */\n  sign(data: HexInput): Signature {\n    return this.privateKey.sign(data);\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.signature signed message Signature\n   * @returns\n   */\n  verifySignature(args: { message: HexInput; signature: Signature }): boolean {\n    const { message, signature } = args;\n    const rawMessage = Hex.fromHexInput(message).toUint8Array();\n    return this.publicKey.verifySignature({ message: rawMessage, signature });\n  }\n}\n"],"mappings":"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","names":["Account","_Account","args","privateKey","address","legacy","useLegacy","Ed25519PublicKey","AnyPublicKey","MultiEd25519PublicKey","Secp256k1PublicKey","publicKey","Secp256k1PrivateKey","Ed25519PrivateKey","AuthenticationKey","path","mnemonic","scheme","data","message","signature","rawMessage","Hex"]}

package/dist/esm/chunk-UYVPNUH3.mjs

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

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

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

package/dist/esm/chunk-V3MBJJTL.mjs

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

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

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

package/dist/esm/chunk-V45RFKH7.mjs

@@ -0,0 +1,2 @@
+import{a as o}from"./chunk-IXMB2GOK.mjs";var t=class{constructor(n){this.config=n}async transferCoinTransaction(n){return o({aptosConfig:this.config,...n})}};export{t as a};
+//# sourceMappingURL=chunk-V45RFKH7.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/coin.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosConfig } from \"./aptosConfig\";\nimport { Account, AccountAddressInput } from \"../core\";\nimport { transferCoinTransaction } from \"../internal/coin\";\nimport { InputSingleSignerTransaction, InputGenerateTransactionOptions } from \"../transactions/types\";\nimport { AnyNumber, MoveStructId } from \"../types\";\n\n/**\n * A class to handle all `Coin` operations\n */\nexport class Coin {\n  readonly config: AptosConfig;\n\n  constructor(config: AptosConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Generate a transfer coin transaction that can be simulated and/or signed and submitted\n   *\n   * @param args.sender The sender account\n   * @param args.recipient The recipient address\n   * @param args.amount The amount to transfer\n   * @param args.coinType optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin\n   *\n   * @returns SingleSignerTransaction\n   */\n  async transferCoinTransaction(args: {\n    sender: Account;\n    recipient: AccountAddressInput;\n    amount: AnyNumber;\n    coinType?: MoveStructId;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<InputSingleSignerTransaction> {\n    return transferCoinTransaction({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"yCAYO,IAAMA,EAAN,KAAW,CAGhB,YAAYC,EAAqB,CAC/B,KAAK,OAASA,CAChB,CAYA,MAAM,wBAAwBC,EAMY,CACxC,OAAOC,EAAwB,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CACtE,CACF","names":["Coin","config","args","transferCoinTransaction"]}

package/dist/esm/chunk-VMQWW5UT.mjs

@@ -0,0 +1,2 @@
+import{g as a}from"./chunk-7MNEEVXY.mjs";import{o as g,s as d}from"./chunk-WX43AJTD.mjs";import{b as s}from"./chunk-NZIJV4O2.mjs";async function f(e){let{aptosConfig:t,poolAddress:o}=e,r=s.fromRelaxed(o).toStringLong(),i=await a({aptosConfig:t,query:{query:d,variables:{where_condition:{pool_address:{_eq:r}}}}});if(i.num_active_delegator_per_pool.length===0)throw Error("Delegator pool not found");return i.num_active_delegator_per_pool[0].num_active_delegator}async function m(e){let{aptosConfig:t,options:o}=e,r={query:d,variables:{where_condition:{},order_by:o?.orderBy}};return(await a({aptosConfig:t,query:r})).num_active_delegator_per_pool}async function A(e){let{aptosConfig:t,delegatorAddress:o,poolAddress:r}=e,n={query:g,variables:{delegatorAddress:s.fromRelaxed(o).toStringLong(),poolAddress:s.fromRelaxed(r).toStringLong()}};return(await a({aptosConfig:t,query:n})).delegated_staking_activities}export{f as a,m as b,A as c};
+//# sourceMappingURL=chunk-VMQWW5UT.mjs.map

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

@@ -0,0 +1 @@
+{"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, OrderBy } 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.fromRelaxed(poolAddress).toStringLong();\n  const query = {\n    query: GetNumberOfDelegators,\n    variables: { where_condition: { pool_address: { _eq: address } } },\n  };\n  const data: GetNumberOfDelegatorsQuery = await queryIndexer<GetNumberOfDelegatorsQuery>({ aptosConfig, query });\n  if (data.num_active_delegator_per_pool.length === 0) {\n    throw Error(\"Delegator pool not found\");\n  }\n  return data.num_active_delegator_per_pool[0].num_active_delegator;\n}\n\nexport async function getNumberOfDelegatorsForAllPools(args: {\n  aptosConfig: AptosConfig;\n  options?: {\n    orderBy?: OrderBy<GetNumberOfDelegatorsResponse[0]>;\n  };\n}): Promise<GetNumberOfDelegatorsResponse> {\n  const { aptosConfig, options } = args;\n  const query = {\n    query: GetNumberOfDelegators,\n    variables: { where_condition: {}, order_by: options?.orderBy },\n  };\n  const data: GetNumberOfDelegatorsQuery = 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.fromRelaxed(delegatorAddress).toStringLong(),\n      poolAddress: AccountAddress.fromRelaxed(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,YAAYF,CAAW,EAAE,aAAa,EAK/DG,EAAmC,MAAMC,EAAyC,CAAE,YAAAL,EAAa,MAJzF,CACZ,MAAOM,EACP,UAAW,CAAE,gBAAiB,CAAE,aAAc,CAAE,IAAKJ,CAAQ,CAAE,CAAE,CACnE,CAC6G,CAAC,EAC9G,GAAIE,EAAK,8BAA8B,SAAW,EAChD,MAAM,MAAM,0BAA0B,EAExC,OAAOA,EAAK,8BAA8B,CAAC,EAAE,oBAC/C,CAEA,eAAsBG,EAAiCR,EAKZ,CACzC,GAAM,CAAE,YAAAC,EAAa,QAAAQ,CAAQ,EAAIT,EAC3BU,EAAQ,CACZ,MAAOH,EACP,UAAW,CAAE,gBAAiB,CAAC,EAAG,SAAUE,GAAS,OAAQ,CAC/D,EAKA,OAJyC,MAAMH,EAAyC,CACtF,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,YAAYQ,CAAgB,EAAE,aAAa,EAC5E,YAAaR,EAAe,YAAYF,CAAW,EAAE,aAAa,CACpE,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-VOYW2TZW.mjs

@@ -0,0 +1,2 @@
+import{a as m}from"./chunk-BFSEVKNA.mjs";import{a as p}from"./chunk-AAIBCWZY.mjs";import{a as h}from"./chunk-EYXHVA6W.mjs";import{a as A}from"./chunk-ARVSIDVB.mjs";import{a as r}from"./chunk-V45RFKH7.mjs";import{a}from"./chunk-BWMNPUTK.mjs";import{a as c}from"./chunk-R26XML3D.mjs";import{a as f}from"./chunk-UNQNACJT.mjs";import{a as g}from"./chunk-Q6N6QACD.mjs";import{a as l}from"./chunk-4RVIA63I.mjs";import{a as s}from"./chunk-J5ZFOJN2.mjs";import{a as u}from"./chunk-IG5CHHSI.mjs";var n=class{constructor(i){this.config=new A(i),this.account=new s(this.config),this.ans=new u(this.config),this.coin=new r(this.config),this.digitalAsset=new a(this.config),this.event=new c(this.config),this.faucet=new f(this.config),this.fungibleAsset=new g(this.config),this.general=new l(this.config),this.staking=new m(this.config),this.transaction=new p(this.config),this.transactionSubmission=new h(this.config)}};function t(y,i,d){Object.getOwnPropertyNames(i.prototype).forEach(o=>{let e=Object.getOwnPropertyDescriptor(i.prototype,o);e&&(e.value=function(...b){return this[d][o](...b)},Object.defineProperty(y.prototype,o,e))})}t(n,s,"account");t(n,u,"ans");t(n,r,"coin");t(n,a,"digitalAsset");t(n,c,"event");t(n,f,"faucet");t(n,g,"fungibleAsset");t(n,l,"general");t(n,m,"staking");t(n,p,"transaction");t(n,h,"transactionSubmission");export{n as a};
+//# sourceMappingURL=chunk-VOYW2TZW.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/aptos.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Account } from \"./account\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { Coin } from \"./coin\";\nimport { DigitalAsset } from \"./digitalAsset\";\nimport { Event } from \"./event\";\nimport { Faucet } from \"./faucet\";\nimport { FungibleAsset } from \"./fungibleAsset\";\nimport { General } from \"./general\";\nimport { ANS } from \"./ans\";\nimport { Staking } from \"./staking\";\nimport { Transaction } from \"./transaction\";\nimport { TransactionSubmission } from \"./transactionSubmission\";\n\n/**\n * This class is the main entry point into Aptos's\n * APIs and separates functionality into different namespaces.\n *\n * To use the SDK, create a new Aptos instance to get access\n * to all the sdk functionality.\n */\nexport class Aptos {\n  readonly config: AptosConfig;\n\n  readonly account: Account;\n\n  readonly ans: ANS;\n\n  readonly coin: Coin;\n\n  readonly digitalAsset: DigitalAsset;\n\n  readonly event: Event;\n\n  readonly faucet: Faucet;\n\n  readonly fungibleAsset: FungibleAsset;\n\n  readonly general: General;\n\n  readonly staking: Staking;\n\n  readonly transaction: Transaction;\n\n  readonly transactionSubmission: TransactionSubmission;\n\n  constructor(settings?: AptosConfig) {\n    this.config = new AptosConfig(settings);\n    this.account = new Account(this.config);\n    this.ans = new ANS(this.config);\n    this.coin = new Coin(this.config);\n    this.digitalAsset = new DigitalAsset(this.config);\n    this.event = new Event(this.config);\n    this.faucet = new Faucet(this.config);\n    this.fungibleAsset = new FungibleAsset(this.config);\n    this.general = new General(this.config);\n    this.staking = new Staking(this.config);\n    this.transaction = new Transaction(this.config);\n    this.transactionSubmission = new TransactionSubmission(this.config);\n  }\n}\n\nexport interface Aptos\n  extends Account,\n    Coin,\n    DigitalAsset,\n    Event,\n    Faucet,\n    FungibleAsset,\n    General,\n    Staking,\n    Transaction,\n    ANS,\n    TransactionSubmission {}\n\n/**\nIn TypeScript, we can’t inherit or extend from more than one class,\nMixins helps us to get around that by creating a partial classes\nthat we can combine to form a single class that contains all the methods and properties from the partial classes.\n{@link https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern}\n\nHere, we combine any subclass and the Aptos class.\n*/\nfunction applyMixin(targetClass: any, baseClass: any, baseClassProp: string) {\n  // Mixin instance methods\n  Object.getOwnPropertyNames(baseClass.prototype).forEach((propertyName) => {\n    const propertyDescriptor = Object.getOwnPropertyDescriptor(baseClass.prototype, propertyName);\n    if (!propertyDescriptor) return;\n    // eslint-disable-next-line func-names\n    propertyDescriptor.value = function (...args: any) {\n      return (this as any)[baseClassProp][propertyName](...args);\n    };\n    Object.defineProperty(targetClass.prototype, propertyName, propertyDescriptor);\n  });\n}\n\napplyMixin(Aptos, Account, \"account\");\napplyMixin(Aptos, ANS, \"ans\");\napplyMixin(Aptos, Coin, \"coin\");\napplyMixin(Aptos, DigitalAsset, \"digitalAsset\");\napplyMixin(Aptos, Event, \"event\");\napplyMixin(Aptos, Faucet, \"faucet\");\napplyMixin(Aptos, FungibleAsset, \"fungibleAsset\");\napplyMixin(Aptos, General, \"general\");\napplyMixin(Aptos, Staking, \"staking\");\napplyMixin(Aptos, Transaction, \"transaction\");\napplyMixin(Aptos, TransactionSubmission, \"transactionSubmission\");\n"],"mappings":"ueAuBO,IAAMA,EAAN,KAAY,CAyBjB,YAAYC,EAAwB,CAClC,KAAK,OAAS,IAAIC,EAAYD,CAAQ,EACtC,KAAK,QAAU,IAAIE,EAAQ,KAAK,MAAM,EACtC,KAAK,IAAM,IAAIC,EAAI,KAAK,MAAM,EAC9B,KAAK,KAAO,IAAIC,EAAK,KAAK,MAAM,EAChC,KAAK,aAAe,IAAIC,EAAa,KAAK,MAAM,EAChD,KAAK,MAAQ,IAAIC,EAAM,KAAK,MAAM,EAClC,KAAK,OAAS,IAAIC,EAAO,KAAK,MAAM,EACpC,KAAK,cAAgB,IAAIC,EAAc,KAAK,MAAM,EAClD,KAAK,QAAU,IAAIC,EAAQ,KAAK,MAAM,EACtC,KAAK,QAAU,IAAIC,EAAQ,KAAK,MAAM,EACtC,KAAK,YAAc,IAAIC,EAAY,KAAK,MAAM,EAC9C,KAAK,sBAAwB,IAAIC,EAAsB,KAAK,MAAM,CACpE,CACF,EAuBA,SAASC,EAAWC,EAAkBC,EAAgBC,EAAuB,CAE3E,OAAO,oBAAoBD,EAAU,SAAS,EAAE,QAASE,GAAiB,CACxE,IAAMC,EAAqB,OAAO,yBAAyBH,EAAU,UAAWE,CAAY,EACvFC,IAELA,EAAmB,MAAQ,YAAaC,EAAW,CACjD,OAAQ,KAAaH,CAAa,EAAEC,CAAY,EAAE,GAAGE,CAAI,CAC3D,EACA,OAAO,eAAeL,EAAY,UAAWG,EAAcC,CAAkB,EAC/E,CAAC,CACH,CAEAL,EAAWd,EAAOG,EAAS,SAAS,EACpCW,EAAWd,EAAOI,EAAK,KAAK,EAC5BU,EAAWd,EAAOK,EAAM,MAAM,EAC9BS,EAAWd,EAAOM,EAAc,cAAc,EAC9CQ,EAAWd,EAAOO,EAAO,OAAO,EAChCO,EAAWd,EAAOQ,EAAQ,QAAQ,EAClCM,EAAWd,EAAOS,EAAe,eAAe,EAChDK,EAAWd,EAAOU,EAAS,SAAS,EACpCI,EAAWd,EAAOW,EAAS,SAAS,EACpCG,EAAWd,EAAOY,EAAa,aAAa,EAC5CE,EAAWd,EAAOa,EAAuB,uBAAuB","names":["Aptos","settings","AptosConfig","Account","ANS","Coin","DigitalAsset","Event","Faucet","FungibleAsset","General","Staking","Transaction","TransactionSubmission","applyMixin","targetClass","baseClass","baseClassProp","propertyName","propertyDescriptor","args"]}

package/dist/esm/chunk-VWVEDCBM.mjs

@@ -0,0 +1,2 @@
+import{a}from"./chunk-EWTHPMEE.mjs";import{b as n}from"./chunk-NZIJV4O2.mjs";import{a as x}from"./chunk-HA6JD5R6.mjs";var t=class extends x{static deserialize(e){let r=e.deserializeUleb128AsU32();switch(r){case 0:return u.load(e);case 1:return c.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 v.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 u}isAddress(){return this instanceof S}isGeneric(){return this instanceof h}isSigner(){return this instanceof U}isVector(){return this instanceof y}isStruct(){return this instanceof v}isU8(){return this instanceof c}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}},u=class i extends t{toString(){return"bool"}serialize(e){e.serializeU32AsUleb128(0)}static load(e){return new i}},c=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}},A=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}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()}>`}serialize(r){r.serializeU32AsUleb128(6),this.value.serialize(r)}static load(r){let s=t.deserialize(r);return new i(s)}},v=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(n.ONE,"string","String")}isOption(){return this.isTypeTag(n.ONE,"option","Option")}isObject(){return this.isTypeTag(n.ONE,"object","Object")}},o=class i extends x{constructor(r,s,l,b){super();this.address=r,this.moduleName=s,this.name=l,this.typeArgs=b}serialize(r){r.serialize(this.address),r.serialize(this.moduleName),r.serialize(this.name),r.serializeVector(this.typeArgs)}static deserialize(r){let s=n.deserialize(r),l=a.deserialize(r),b=a.deserialize(r),f=r.deserializeVector(t);return new i(s,l,b,f)}};function E(){return new o(n.ONE,new a("aptos_coin"),new a("AptosCoin"),[])}function j(){return new o(n.ONE,new a("string"),new a("String"),[])}function V(i){return new o(n.ONE,new a("option"),new a("Option"),[i])}function I(i){return new o(n.ONE,new a("object"),new a("Object"),[i])}export{t as a,u as b,c,d,g as e,p as f,z as g,T as h,S as i,U as j,A as k,h as l,y as m,v as n,o,E as p,j as q,V as r,I as s};
+//# sourceMappingURL=chunk-VWVEDCBM.mjs.map