{"version":3,"sources":["../src/address.ts","../src/utils.ts"],"sourcesContent":["import { FuelError } from '@fuel-ts/errors';\nimport { arrayify, hexlify } from '@fuel-ts/utils';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport type { B256Address, EvmAddress, AssetId, ChecksumAddress, AddressInput } from './types';\nimport {\n  getRandomB256,\n  isB256,\n  isEvmAddress,\n  toB256AddressEvm,\n  fromPublicKeyToB256,\n  fromDynamicInputToB256,\n  normalizeB256,\n} from './utils';\n\n/**\n * `Address` provides a type safe wrapper for converting between different address formats\n * ands comparing them for equality.\n */\nexport class Address {\n  // #region address-2\n  readonly b256Address: B256Address;\n  // #endregion address-2\n\n  /**\n   * @param address - A B256 address, public key, EVM address, or Address instance\n   */\n  constructor(address: AddressInput) {\n    const b256Address = fromDynamicInputToB256(address);\n    this.b256Address = normalizeB256(b256Address);\n  }\n\n  /**\n   * Takes an B256 Address and returns back an checksum address.\n   * The implementation follows the ERC-55 https://github.com/ethereum/ercs/blob/master/ERCS/erc-55.md.\n   *\n   * @returns A new `ChecksumAddress` instance\n   */\n  toChecksum(): ChecksumAddress {\n    return Address.toChecksum(this.b256Address);\n  }\n\n  /**\n   * Returns the `b256Address` property\n   */\n  toAddress(): B256Address {\n    return this.b256Address;\n  }\n\n  /**\n   * Returns the B256 hash address as a string\n   *\n   * @returns The B256 address\n   */\n  toB256(): B256Address {\n    return this.b256Address;\n  }\n\n  /**\n   * Returns the B256 hash address as a Uint8Array\n   *\n   * @returns The B256 address as a Uint8Array\n   */\n  toBytes(): Uint8Array {\n    return arrayify(this.b256Address);\n  }\n\n  /**\n   * Returns the B256 hash address as a string\n   *\n   * @returns The B256 address\n   */\n  toHexString(): B256Address {\n    return this.toB256();\n  }\n\n  /**\n   * returns the address `checksum` as a string\n   *\n   * @returns The `b256Address` property as a string\n   */\n  toString(): string {\n    return this.toChecksum();\n  }\n\n  /**\n   * Converts and returns the `b256Address` property as a string\n   * @returns The `b256Address` property as a JSON string\n   */\n  toJSON(): string {\n    return this.b256Address;\n  }\n\n  /**\n   * Converts to an EVM address\n   *\n   * @returns an {@link EvmAddress | `EvmAddress`} representation of the address\n   */\n  toEvmAddress(): EvmAddress {\n    return {\n      bits: toB256AddressEvm(this.b256Address),\n    } as EvmAddress;\n  }\n\n  /**\n   * Wraps the B256 property and returns as an `AssetId`.\n   * @returns The B256 property as an {@link AssetId | `AssetId`}\n   */\n  toAssetId(): AssetId {\n    return {\n      bits: this.b256Address,\n    } as AssetId;\n  }\n\n  /**\n   * Wraps the B256 address `checksum` and returns it as a string\n   * @returns The B256 address `checksum` as a string\n   */\n  valueOf(): string {\n    return this.toChecksum();\n  }\n\n  /**\n   * Compares this the `b256Address` property to another for direct equality\n   * @param other - Another address to compare against\n   * @returns The equality of the comparison\n   */\n  equals(other: Address): boolean {\n    return this.toChecksum() === other.toChecksum();\n  }\n\n  /**\n   * Takes a Public Key, hashes it, and creates an `Address`\n   *\n   * @param publicKey - A wallets public key\n   * @returns A new `Address` instance\n   *\n   * @deprecated Use `new Address` instead\n   */\n  static fromPublicKey(publicKey: string): Address {\n    const b256Address = fromPublicKeyToB256(publicKey);\n    return new Address(b256Address);\n  }\n\n  /**\n   * Takes a B256 Address and creates an `Address`\n   *\n   * @param b256Address - A b256 hash\n   * @returns A new `Address` instance\n   *\n   * @deprecated Use `new Address` instead\n   */\n  static fromB256(b256Address: string): Address {\n    if (!isB256(b256Address)) {\n      throw new FuelError(\n        FuelError.CODES.INVALID_B256_ADDRESS,\n        `Invalid B256 Address: ${b256Address}.`\n      );\n    }\n\n    return new Address(b256Address);\n  }\n\n  /**\n   * Creates an `Address` with a randomized `b256Address` property\n   *\n   * @returns A new `Address` instance\n   */\n  static fromRandom(): Address {\n    return new Address(getRandomB256());\n  }\n\n  /**\n   * Takes an ambiguous string and attempts to create an `Address`\n   *\n   * @param address - An ambiguous string\n   * @returns A new `Address` instance\n   *\n   * @deprecated Use `new Address` instead\n   */\n  static fromString(address: string): Address {\n    return new Address(address);\n  }\n\n  /**\n   * Takes an ambiguous string or address and creates an `Address`\n   *\n   * @returns a new `Address` instance\n   *\n   * @deprecated Use `new Address` instead\n   */\n  static fromAddressOrString(address: string | Address): Address {\n    return new Address(address);\n  }\n\n  /**\n   * Takes a dynamic string or `Address` and creates an `Address`\n   *\n   * @param addressId - A string containing B256, or Public Key\n   * @throws Error - Unknown address if the format is not recognized\n   * @returns A new `Address` instance\n   *\n   * @deprecated Use `new Address` instead\n   */\n  static fromDynamicInput(address: string | Address): Address {\n    return new Address(address);\n  }\n\n  /**\n   * Takes an Evm Address and returns back an `Address`\n   *\n   * @returns A new `Address` instance\n   *\n   * @deprecated Use `new Address` instead\n   */\n  static fromEvmAddress(evmAddress: string): Address {\n    if (!isEvmAddress(evmAddress)) {\n      throw new FuelError(\n        FuelError.CODES.INVALID_EVM_ADDRESS,\n        `Invalid Evm Address: ${evmAddress}.`\n      );\n    }\n\n    return new Address(evmAddress);\n  }\n\n  /**\n   * Takes an ChecksumAddress and validates if it is a valid checksum address.\n   *\n   * @returns A `boolean` instance indicating if the address is valid.\n   */\n  static isChecksumValid(address: ChecksumAddress): boolean {\n    let addressParsed = address;\n\n    if (!address.startsWith('0x')) {\n      addressParsed = `0x${address}`;\n    }\n    if (addressParsed.trim().length !== 66) {\n      return false;\n    }\n\n    return Address.toChecksum(hexlify(addressParsed)) === addressParsed;\n  }\n\n  /** @hidden */\n  private static toChecksum(address: string) {\n    if (!isB256(address)) {\n      throw new FuelError(\n        FuelError.CODES.INVALID_B256_ADDRESS,\n        `Invalid B256 Address: ${address}.`\n      );\n    }\n\n    const addressHex = hexlify(address).toLowerCase().slice(2);\n    const checksum = sha256(addressHex);\n\n    let ret = '0x';\n    for (let i = 0; i < 32; ++i) {\n      const byte = checksum[i];\n      const ha = addressHex.charAt(i * 2);\n      const hb = addressHex.charAt(i * 2 + 1);\n      ret += (byte & 0xf0) >= 0x80 ? ha.toUpperCase() : ha;\n      ret += (byte & 0x0f) >= 0x08 ? hb.toUpperCase() : hb;\n    }\n\n    return ret;\n  }\n}\n","import { randomBytes } from '@fuel-ts/crypto';\nimport { FuelError } from '@fuel-ts/errors';\nimport { arrayify, concat, hexlify } from '@fuel-ts/utils';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport type { Address } from './address';\nimport type { AddressLike, ContractIdLike, B256Address, B256AddressEvm } from './types';\n\n/**\n * Determines if a given string is B256 format\n *\n * @hidden\n */\nexport function isB256(address: string): boolean {\n  return address.length === 66 && /(0x)[0-9a-f]{64}$/i.test(address);\n}\n\n/**\n * Determines if a given string is in Public Key format (512 bits)\n *\n * @hidden\n */\nexport function isPublicKey(address: string): boolean {\n  return address.length === 130 && /(0x)[0-9a-f]{128}$/i.test(address);\n}\n\n/**\n * Determines if a given string is in EVM Address format\n *\n * @hidden\n */\nexport function isEvmAddress(address: string): boolean {\n  return address.length === 42 && /(0x)[0-9a-f]{40}$/i.test(address);\n}\n\n/**\n * Normalizes a B256 address to lowercase\n *\n * @param address - The B256 address to normalize\n * @returns The normalized B256 address\n *\n * @hidden\n */\nexport function normalizeB256(address: B256Address): B256Address {\n  return address.toLowerCase();\n}\n\n/**\n * A simple type guard to check if an object is an Address\n *\n * @hidden\n */\nexport function isAddress(address: object): address is Address {\n  return 'b256Address' in address;\n}\n\n/**\n * Takes an indeterminate address type and returns an address\n *\n * @hidden\n */\nexport const addressify = (addressLike: AddressLike | ContractIdLike): Address => {\n  if (isAddress(addressLike)) {\n    return addressLike;\n  }\n\n  if ('address' in addressLike && isAddress(addressLike.address)) {\n    return addressLike.address;\n  }\n\n  if ('id' in addressLike && isAddress(addressLike.id)) {\n    return addressLike.id;\n  }\n\n  throw new FuelError(FuelError.CODES.INVALID_ADDRESS, 'Invalid address');\n};\n\n/**\n * @hidden\n */\nexport const getRandomB256 = () => hexlify(randomBytes(32));\n\n/**\n * Takes a B256 address and clears the first 12 bytes, this is required for an EVM Address\n *\n * @param b256 - the address to clear\n * @returns b256 with first 12 bytes cleared\n *\n * @hidden\n */\nexport const toB256AddressEvm = (b256: B256Address): B256AddressEvm => {\n  try {\n    if (!isB256(b256)) {\n      throw new FuelError(FuelError.CODES.INVALID_B256_ADDRESS, `Invalid B256 Address: ${b256}.`);\n    }\n\n    const evmBytes = arrayify(b256).slice(12);\n    const paddedBytes = new Uint8Array(12).fill(0);\n    return hexlify(concat([paddedBytes, evmBytes])) as B256AddressEvm;\n  } catch (error) {\n    throw new FuelError(\n      FuelError.CODES.PARSE_FAILED,\n      `Cannot generate EVM Address B256 from: ${b256}.`\n    );\n  }\n};\n\n/**\n * Pads the first 12 bytes of an Evm address. This is useful for padding addresses returned from\n * the EVM to interact with the Sway EVM Address Type.\n *\n * @param address - Evm address to be padded\n * @returns Evm address padded to a b256 address\n *\n * @hidden\n */\nexport const padFirst12BytesOfEvmAddress = (address: string): B256AddressEvm => {\n  if (!isEvmAddress(address)) {\n    throw new FuelError(FuelError.CODES.INVALID_EVM_ADDRESS, 'Invalid EVM address format.');\n  }\n\n  return address.replace('0x', '0x000000000000000000000000') as B256AddressEvm;\n};\n\n/**\n * Converts an EVM address to a B256 address\n *\n * @param address - The EVM address to convert\n * @returns The B256 address\n *\n * @hidden\n */\nexport const fromEvmAddressToB256 = (address: string): B256Address =>\n  padFirst12BytesOfEvmAddress(address);\n\n/**\n * Converts a Public Key to a B256 address\n *\n * @param publicKey - The Public Key to convert\n * @returns The B256 address\n *\n * @hidden\n */\nexport const fromPublicKeyToB256 = (publicKey: string): B256Address => {\n  if (!isPublicKey(publicKey)) {\n    throw new FuelError(FuelError.CODES.INVALID_PUBLIC_KEY, `Invalid Public Key: ${publicKey}.`);\n  }\n\n  return hexlify(sha256(arrayify(publicKey)));\n};\n\n/**\n * Converts a dynamic input to a B256 address\n *\n * @param address - The dynamic input to convert\n * @returns The B256 address\n *\n * @hidden\n */\nexport const fromDynamicInputToB256 = (address: string | Address): B256Address => {\n  if (typeof address !== 'string' && 'toB256' in address) {\n    return address.toB256();\n  }\n\n  if (isB256(address)) {\n    return address;\n  }\n\n  if (isPublicKey(address)) {\n    return fromPublicKeyToB256(address);\n  }\n\n  if (isEvmAddress(address)) {\n    return fromEvmAddressToB256(address);\n  }\n\n  throw new FuelError(\n    FuelError.CODES.PARSE_FAILED,\n    `Unknown address format: only 'B256', 'Public Key (512)', or 'EVM Address' are supported.`\n  );\n};\n"],"mappings":"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","names":["FuelError","arrayify","hexlify","sha256","arrayify","FuelError","hexlify","sha256"]}