{
  "version": 3,
  "sources": ["../src/index.ts", "../src/Account.ts", "../src/Address.ts", "../src/PublicKey.ts", "../src/Message.ts", "../src/Signature.ts", "../src/RawPrivateKey.ts"],
  "sourcesContent": ["export { type Account, type ExportableAccount } from \"./Account.js\";\nexport { Address } from \"./Address.js\";\nexport {\n  type AccountDeletion,\n  type AccountGeneration,\n  type AccountImportation,\n  type AccountMetadata,\n  type AccountRetrieval,\n  type ImportableKeyStore,\n  type KeyStore,\n  type MutableKeyStore,\n} from \"./KeyStore.js\";\nexport { type Message } from \"./Message.js\";\nexport { PublicKey, type PublicKeyForm } from \"./PublicKey.js\";\nexport { RawPrivateKey } from \"./RawPrivateKey.js\";\nexport { Signature } from \"./Signature.js\";\n", "import { type Message } from \"./Message.js\";\nimport Address from \"./Address.js\";\nimport PublicKey from \"./PublicKey.js\";\nimport RawPrivateKey from \"./RawPrivateKey.js\";\nimport Signature from \"./Signature.js\";\n\nexport interface Account {\n  getAddress(): Promise<Address>;\n  getPublicKey(): Promise<PublicKey>;\n  sign(message: Message): Promise<Signature>;\n}\n\nexport function isAccount(account: unknown): account is Account {\n  return (\n    typeof account === \"object\" &&\n    account != null &&\n    \"getAddress\" in account &&\n    account.getAddress instanceof Function &&\n    \"getPublicKey\" in account &&\n    account.getPublicKey instanceof Function &&\n    \"sign\" in account &&\n    account.sign instanceof Function\n  );\n}\n\nexport interface ExportableAccount extends Account {\n  exportPrivateKey(): Promise<RawPrivateKey>;\n}\n\nexport default Account;\n", "import { Buffer } from \"buffer\";\nimport { keccak_256 } from \"@noble/hashes/sha3\";\nimport { Account, isAccount } from \"./Account.js\";\nimport { PublicKey } from \"./PublicKey.js\";\n\nif (typeof globalThis.TextEncoder === \"undefined\") {\n  // FIXME: This is a workaround for the lack of TextEncoder in Vitest.\n  globalThis.TextEncoder = require(\"node:util\").TextEncoder;\n}\n\nfunction toHex(bytes: Uint8Array): string {\n  let hex = \"\";\n  for (let i = 0; i < bytes.length; i++) {\n    hex += bytes[i].toString(16).padStart(2, \"0\");\n  }\n  return hex;\n}\n\nfunction checksum(hex: string): string {\n  hex = hex.toLowerCase();\n\n  const hexAsciiIntoBytes = new TextEncoder!().encode(hex);\n  const hashedAddr = toHex(keccak_256(hexAsciiIntoBytes));\n  let checksum = \"\";\n  for (let nibbleIdx = 0; nibbleIdx < hex.length; nibbleIdx++) {\n    const nibbleHex = hex.charAt(nibbleIdx);\n    if (nibbleHex.match(/^[0-9]$/)) {\n      checksum += nibbleHex;\n      continue;\n    } else {\n      const nibble = parseInt(hashedAddr.charAt(nibbleIdx), 16);\n      checksum += nibble > 7 ? nibbleHex.toUpperCase() : nibbleHex;\n    }\n  }\n\n  return checksum;\n}\n\nexport class Address {\n  #bytes: Uint8Array;\n\n  private constructor(bytes: Uint8Array) {\n    this.#bytes = bytes;\n  }\n\n  static deriveFrom(publicKey: PublicKey): Address;\n  static deriveFrom(account: Account): Promise<Address>;\n\n  static deriveFrom(\n    publicKey: PublicKey | Account\n  ): Address | Promise<Address> {\n    if (isAccount(publicKey)) {\n      return publicKey.getPublicKey().then(this.#deriveFrom);\n    } else if (publicKey instanceof PublicKey) {\n      return this.#deriveFrom(publicKey);\n    }\n\n    throw new Error(\n      `Expected either PublicKey or Account, got ${typeof publicKey}`\n    );\n  }\n\n  static #deriveFrom(publicKey: PublicKey): Address {\n    const pub = publicKey.toBytes(\"uncompressed\").slice(1);\n    const digest = keccak_256(pub);\n    const addr = digest.slice(digest.length - 20);\n    return new Address(addr);\n  }\n\n  static fromHex(hex: string, ignoreChecksum: boolean = false): Address {\n    if (typeof hex !== \"string\") {\n      throw new Error(`Expected a string, but ${typeof hex} was given.`);\n    } else if (!hex.match(/^(0x)?[0-9a-f]{40}$/i)) {\n      throw new Error(\n        `Expected a string of 40 hexadecimals, but ${JSON.stringify(\n          hex\n        )} was given.`\n      );\n    }\n\n    if (hex.match(/^0x/i)) {\n      hex = hex.slice(2);\n    }\n\n    const addr = new Address(new Uint8Array(Buffer.from(hex, \"hex\")));\n    if (ignoreChecksum) {\n      return addr;\n    }\n\n    const expectedChecksum = checksum(hex);\n    if (expectedChecksum !== hex) {\n      throw new Error(\n        `Expected checksum is 0x${expectedChecksum}, but 0x${hex} was given.`\n      );\n    }\n\n    return addr;\n  }\n\n  static fromBytes(bytes: Uint8Array) {\n    if (!(bytes instanceof Uint8Array)) {\n      throw new Error(`Expected a Uint8Array, but ${typeof bytes} was given.`);\n    }\n\n    if (bytes.length !== 20) {\n      throw new Error(\n        `Expected 20 bytes, but ${bytes.length} bytes were given.`\n      );\n    }\n\n    return new Address(bytes);\n  }\n\n  toBytes(): Uint8Array {\n    return this.#bytes;\n  }\n\n  toHex(casing: \"checksum\" | \"lower\" = \"checksum\"): string {\n    const hex = toHex(this.#bytes);\n    return casing === \"checksum\" ? checksum(hex) : hex;\n  }\n\n  equals(other: Address): boolean {\n    if (!(other instanceof Address)) return false;\n    for (let i = 0; i < 20; i++) {\n      if (this.#bytes[i] !== other.#bytes[i]) return false;\n    }\n\n    return true;\n  }\n\n  isAddressOf(publicKey: PublicKey): boolean {\n    return Address.deriveFrom(publicKey).equals(this);\n  }\n\n  toString(): string {\n    return `0x${this.toHex()}`;\n  }\n}\n\nexport default Address;\n", "import { Buffer } from \"buffer\";\nimport * as secp256k1 from \"@noble/secp256k1\";\nimport { Message, hashMessage } from \"./Message.js\";\nimport Signature from \"./Signature.js\";\n\nexport type PublicKeyForm = \"compressed\" | \"uncompressed\";\n\nexport class PublicKey {\n  readonly #point: secp256k1.Point;\n\n  private constructor(point: secp256k1.Point) {\n    this.#point = point;\n  }\n\n  static fromBytes(bytes: Uint8Array, form: PublicKeyForm): PublicKey {\n    if (!(bytes instanceof Uint8Array)) {\n      throw new Error(`Expected a Uint8Array, but got ${typeof bytes}`);\n    }\n    const header = bytes[0];\n    if (form === \"compressed\") {\n      if (bytes.length !== 33) {\n        throw new Error(\n          `Invalid compressed public key: expected 33 bytes, but got ${bytes.length} bytes`\n        );\n      } else if (header !== 0x02 && header !== 0x03) {\n        throw new Error(\n          `Invalid compressed public key: expected either 0x02 or 0x03 as the header, but got 0x${header\n            .toString(16)\n            .padStart(2, \"0\")}`\n        );\n      }\n    } else if (form === \"uncompressed\") {\n      if (bytes.length !== 65) {\n        throw new Error(\n          `Invalid uncompressed public key expected 65 bytes, but got ${bytes.length} bytes`\n        );\n      } else if (header !== 0x04) {\n        throw new Error(\n          `Invalid compressed public key: expected 0x04 as the header, but got 0x${header\n            .toString(16)\n            .padStart(2, \"0\")}`\n        );\n      }\n    } else {\n      throw new Error(\n        \"Invalid public key form: choose 'compressed' or 'uncompressed'\"\n      );\n    }\n    return new PublicKey(secp256k1.Point.fromHex(bytes));\n  }\n\n  // TODO: more explicit length checking\n  static fromHex(hex: string, form: PublicKeyForm): PublicKey {\n    if (typeof hex !== \"string\") {\n      throw new Error(`Expected a string, but got ${typeof hex}`);\n    } else if (form === \"compressed\" && hex.length !== 66) {\n      throw new Error(\n        `Invalid compressed public key: expected 33 hexadigits, but got ${hex.length} hexadigits`\n      );\n    } else if (form === \"uncompressed\" && hex.length !== 130) {\n      throw new Error(\n        `Invalid uncompressed public key expected 130 hexadigits, but got ${hex.length} hexadigits`\n      );\n    }\n    const bytes = new Uint8Array(Buffer.from(hex, \"hex\"));\n    return this.fromBytes(bytes, form);\n  }\n\n  async verify(message: Message, signature: Signature): Promise<boolean> {\n    if (!(message instanceof Uint8Array)) {\n      throw new Error(`Expected Uint8Array, but got ${typeof message}`);\n    } else if (!(signature instanceof Signature)) {\n      throw new Error(`Expected Signature, but got ${typeof signature}`);\n    }\n    const msgHash = await hashMessage(message);\n    return secp256k1.verify(signature.toBytes(), msgHash, this.#point);\n  }\n\n  toBytes(form: PublicKeyForm): Uint8Array {\n    if (form !== \"compressed\" && form !== \"uncompressed\") {\n      throw new Error(\n        \"Invalid public key form: choose 'compressed' or 'uncompressed'\"\n      );\n    }\n    return this.#point.toRawBytes(form === \"compressed\");\n  }\n\n  toHex(form: PublicKeyForm): string {\n    if (form !== \"compressed\" && form !== \"uncompressed\") {\n      throw new Error(\n        \"Invalid public key form: choose 'compressed' or 'uncompressed'\"\n      );\n    }\n    return this.#point.toHex(form === \"compressed\");\n  }\n\n  equals(other: PublicKey): boolean {\n    return other instanceof PublicKey && this.#point.equals(other.#point);\n  }\n}\n\nexport default PublicKey;\n", "import { sha256 } from \"@noble/hashes/sha256\";\n\nexport type Message = Uint8Array;\n\nexport async function hashMessage(message: Message): Promise<Uint8Array> {\n  // TODO: Use Web Crypto API when it is available.\n  // return new Uint8Array(await crypto!.subtle.digest(\"SHA-256\", message));\n  return sha256(message);\n}\n\nexport default Message;\n", "import * as secp256k1 from \"@noble/secp256k1\";\n\nexport class Signature {\n  readonly #signature: secp256k1.Signature;\n\n  private constructor(signature: secp256k1.Signature) {\n    if (signature.hasHighS())\n      throw new RangeError(\n        \"A signature with high S is unsupported; \" +\n          \"normalize it to get rid of high S\",\n      );\n    this.#signature = signature;\n  }\n\n  static fromBytes(bytes: Uint8Array): Signature {\n    // NOTE: We decided to distinguish fromBytes from fromHex, although they\n    // call the same function in @noble/secp256k1 which takes both a hex string\n    // and a Uint8Array.\n    return new Signature(secp256k1.Signature.fromDER(bytes));\n  }\n\n  static fromHex(hex: string): Signature {\n    // NOTE: We decided to distinguish fromBytes from fromHex, although they\n    // call the same function in @noble/secp256k1 which takes both a hex string\n    // and a Uint8Array.\n    return new Signature(secp256k1.Signature.fromDER(hex));\n  }\n\n  toBytes(): Uint8Array {\n    return this.#signature.toDERRawBytes();\n  }\n\n  toHex(): string {\n    return this.#signature.toDERHex();\n  }\n\n  toString(): string {\n    return this.toHex();\n  }\n\n  [Symbol.for(\"nodejs.util.inspect.custom\")]() {\n    return `Signature { ${this.toHex()} }`;\n  }\n}\n\nexport default Signature;\n", "import { Buffer } from \"buffer\";\nimport * as secp256k1 from \"@noble/secp256k1\";\nimport Address from \"./Address.js\";\nimport { Message, hashMessage } from \"./Message.js\";\nimport PublicKey from \"./PublicKey.js\";\nimport Signature from \"./Signature.js\";\n\nexport class RawPrivateKey {\n  readonly #privatePart: Uint8Array;\n  #publicPart?: PublicKey;\n\n  private constructor(privatePart: Uint8Array) {\n    this.#privatePart = privatePart;\n  }\n\n  static fromBytes(bytes: Uint8Array): RawPrivateKey {\n    if (!(bytes instanceof Uint8Array)) {\n      throw new Error(`Expected Uint8Array, but got ${typeof bytes}`);\n    } else if (bytes.length !== 32) {\n      throw new Error(\n        `Incorrect private key length; expected 32 bytes, but got ${bytes.length} bytes`\n      );\n    } else if (!secp256k1.utils.isValidPrivateKey(bytes)) {\n      throw new Error(\"Invalid private key\");\n    }\n\n    // NOTE: The bytes should be copied because the original array can be\n    // mutated after the key is created.\n    return new RawPrivateKey(new Uint8Array(bytes));\n  }\n\n  static fromHex(hex: string): RawPrivateKey {\n    if (typeof hex !== \"string\") {\n      throw new Error(`Expected string, but got ${typeof hex}`);\n    } else if (hex.length !== 64) {\n      throw new Error(\n        `Incorrect private key length; expected 64 hexadigits, but got ${hex.length} hexadigits`\n      );\n    }\n    const bytes = new Uint8Array(Buffer.from(hex, \"hex\"));\n    if (!secp256k1.utils.isValidPrivateKey(bytes)) {\n      throw new Error(\"Invalid private key\");\n    }\n\n    return new RawPrivateKey(bytes);\n  }\n\n  static generate(): RawPrivateKey {\n    return this.fromBytes(secp256k1.utils.randomPrivateKey());\n  }\n\n  getAddress(): Promise<Address> {\n    return Promise.resolve(Address.deriveFrom(this.publicKey));\n  }\n\n  /**\n   * @deprecated Use {@link getPublicKey()} instead.\n   */\n  get publicKey(): PublicKey {\n    // TODO: This attribute is deprecated.  We should remove it and make\n    // getPublicKey() method the only choice in the future.\n    if (typeof this.#publicPart === \"undefined\") {\n      this.#publicPart = PublicKey.fromBytes(\n        secp256k1.getPublicKey(this.#privatePart),\n        \"uncompressed\"\n      );\n    }\n\n    return this.#publicPart;\n  }\n\n  getPublicKey(): Promise<PublicKey> {\n    return Promise.resolve(this.publicKey);\n  }\n\n  async sign(message: Message): Promise<Signature> {\n    const sig = await secp256k1.sign(\n      await hashMessage(message),\n      this.#privatePart,\n      { der: true }\n    );\n    return Signature.fromBytes(sig);\n  }\n\n  exportPrivateKey(): Promise<RawPrivateKey> {\n    return Promise.resolve(this);\n  }\n\n  toBytes(): Uint8Array {\n    // NOTE: The #privatePart should be copied because the returned reference\n    // can be mutated after this method is called.\n    return new Uint8Array(this.#privatePart);\n  }\n}\n\nexport default RawPrivateKey;\n"],
  "mappings": "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",
  "names": ["Signature", "import_buffer", "secp256k1", "Signature", "checksum", "import_buffer", "secp256k1"]
}