@feelyourprotocol/util 8141.0.0

package/src/address.ts

@@ -0,0 +1,158 @@
+import {
+  generateAddress,
+  generateAddress2,
+  isValidAddress,
+  privateToAddress,
+  pubToAddress,
+} from './account.ts'
+import {
+  bigIntToBytes,
+  bytesToBigInt,
+  bytesToHex,
+  equalsBytes,
+  hexToBytes,
+  setLengthLeft,
+} from './bytes.ts'
+import { BIGINT_0 } from './constants.ts'
+import { EthereumJSErrorWithoutCode } from './errors.ts'
+
+import type { PrefixedHexString } from './types.ts'
+
+/**
+ * Handling and generating Ethereum addresses
+ */
+export class Address {
+  public readonly bytes: Uint8Array
+
+  constructor(bytes: Uint8Array) {
+    if (bytes.length !== 20) {
+      throw EthereumJSErrorWithoutCode('Invalid address length')
+    }
+    this.bytes = bytes
+  }
+
+  /**
+   * Is address equal to another.
+   */
+  equals(address: Address): boolean {
+    return equalsBytes(this.bytes, address.bytes)
+  }
+
+  /**
+   * Is address zero.
+   */
+  isZero(): boolean {
+    return this.equals(new Address(new Uint8Array(20)))
+  }
+
+  /**
+   * True if address is in the address range defined
+   * by EIP-1352
+   */
+  isPrecompileOrSystemAddress(): boolean {
+    const address = bytesToBigInt(this.bytes)
+    const rangeMin = BIGINT_0
+    const rangeMax = BigInt('0xffff')
+    return address >= rangeMin && address <= rangeMax
+  }
+
+  /**
+   * Returns hex encoding of address.
+   */
+  toString(): PrefixedHexString {
+    return bytesToHex(this.bytes)
+  }
+
+  /**
+   * Returns a new Uint8Array representation of address.
+   */
+  toBytes(): Uint8Array {
+    return new Uint8Array(this.bytes)
+  }
+}
+
+/**
+ * Returns the zero address.
+ */
+export function createZeroAddress(): Address {
+  return new Address(new Uint8Array(20))
+}
+
+/**
+ * Returns an Address object from a bigint address (they are stored as bigints on the stack)
+ * @param value The bigint address
+ */
+export function createAddressFromBigInt(value: bigint): Address {
+  const bytes = bigIntToBytes(value)
+  if (bytes.length > 20) {
+    throw EthereumJSErrorWithoutCode(`Invalid address, too long: ${bytes.length}`)
+  }
+  return new Address(setLengthLeft(bytes, 20))
+}
+
+/**
+ * Returns an Address object from a hex-encoded string.
+ * @param str - Hex-encoded address
+ */
+export function createAddressFromString(str: string): Address {
+  if (!isValidAddress(str)) {
+    throw EthereumJSErrorWithoutCode(`Invalid address input=${str}`)
+  }
+  return new Address(hexToBytes(str))
+}
+
+/**
+ * Returns an address for a given public key.
+ * @param pubKey The two points of an uncompressed key
+ */
+export function createAddressFromPublicKey(pubKey: Uint8Array): Address {
+  if (!(pubKey instanceof Uint8Array)) {
+    throw EthereumJSErrorWithoutCode('Public key should be Uint8Array')
+  }
+  const bytes = pubToAddress(pubKey)
+  return new Address(bytes)
+}
+
+/**
+ * Returns an address for a given private key.
+ * @param privateKey A private key must be 256 bits wide
+ */
+export function createAddressFromPrivateKey(privateKey: Uint8Array): Address {
+  if (!(privateKey instanceof Uint8Array)) {
+    throw EthereumJSErrorWithoutCode('Private key should be Uint8Array')
+  }
+  const bytes = privateToAddress(privateKey)
+  return new Address(bytes)
+}
+
+/**
+ * Generates an address for a newly created contract.
+ * @param from The address which is creating this new address
+ * @param nonce The nonce of the from account
+ */
+export function createContractAddress(from: Address, nonce: bigint): Address {
+  if (typeof nonce !== 'bigint') {
+    throw EthereumJSErrorWithoutCode('Expected nonce to be a bigint')
+  }
+  return new Address(generateAddress(from.bytes, bigIntToBytes(nonce)))
+}
+
+/**
+ * Generates an address for a contract created using CREATE2.
+ * @param from The address which is creating this new address
+ * @param salt A salt
+ * @param initCode The init code of the contract being created
+ */
+export function createContractAddress2(
+  from: Address,
+  salt: Uint8Array,
+  initCode: Uint8Array,
+): Address {
+  if (!(salt instanceof Uint8Array)) {
+    throw EthereumJSErrorWithoutCode('Expected salt to be a Uint8Array')
+  }
+  if (!(initCode instanceof Uint8Array)) {
+    throw EthereumJSErrorWithoutCode('Expected initCode to be a Uint8Array')
+  }
+  return new Address(generateAddress2(from.bytes, salt, initCode))
+}

package/src/authorization.ts

@@ -0,0 +1,180 @@
+// Utility helpers to convert authorization lists from the byte format and JSON format and vice versa
+
+import { EthereumJSErrorWithoutCode, RLP } from '@feelyourprotocol/rlp'
+import { secp256k1 } from '@noble/curves/secp256k1.js'
+import { keccak_256 } from '@noble/hashes/sha3.js'
+import { publicToAddress } from './account.ts'
+import { Address } from './address.ts'
+import {
+  bigIntToUnpaddedBytes,
+  bytesToBigInt,
+  bytesToHex,
+  concatBytes,
+  hexToBytes,
+  setLengthLeft,
+  unpadBytes,
+} from './bytes.ts'
+import { ecrecover } from './signature.ts'
+import type {
+  EOACode7702AuthorizationListBytesItem,
+  EOACode7702AuthorizationListBytesItemUnsigned,
+  EOACode7702AuthorizationListItem,
+  EOACode7702AuthorizationListItemUnsigned,
+} from './types.ts'
+
+export const EOA_CODE_7702_AUTHORITY_SIGNING_MAGIC = hexToBytes('0x05')
+
+/**
+ * Converts an authorization list to a JSON format
+ * @param authorizationList
+ * @returns authorizationList in JSON format
+ */
+export function eoaCode7702AuthorizationListBytesItemToJSON(
+  authorizationList: EOACode7702AuthorizationListBytesItem,
+): EOACode7702AuthorizationListItem {
+  const [chainId, address, nonce, yParity, r, s] = authorizationList
+  return {
+    chainId: bytesToHex(chainId),
+    address: bytesToHex(address),
+    nonce: bytesToHex(nonce),
+    yParity: bytesToHex(yParity),
+    r: bytesToHex(r),
+    s: bytesToHex(s),
+  }
+}
+
+/**
+ * Converts an authority list in JSON to a bytes format
+ * @param authorizationList
+ * @returns bytes format of the authority list
+ */
+export function eoaCode7702AuthorizationListJSONItemToBytes(
+  authorizationList: EOACode7702AuthorizationListItem,
+): EOACode7702AuthorizationListBytesItem {
+  const requiredFields = ['chainId', 'address', 'nonce', 'yParity', 'r', 's'] as const
+
+  // Validate all required fields are present
+  for (const field of requiredFields) {
+    if (authorizationList[field] === undefined) {
+      throw EthereumJSErrorWithoutCode(
+        `EIP-7702 authorization list invalid: ${field} is not defined`,
+      )
+    }
+  }
+
+  return [
+    unpadBytes(hexToBytes(authorizationList.chainId)),
+    hexToBytes(authorizationList.address),
+    unpadBytes(hexToBytes(authorizationList.nonce)),
+    unpadBytes(hexToBytes(authorizationList.yParity)),
+    unpadBytes(hexToBytes(authorizationList.r)),
+    unpadBytes(hexToBytes(authorizationList.s)),
+  ]
+}
+
+/** Authorization signing utility methods */
+function unsignedAuthorizationListToBytes(input: EOACode7702AuthorizationListItemUnsigned) {
+  const { chainId: chainIdHex, address: addressHex, nonce: nonceHex } = input
+  const chainId = unpadBytes(hexToBytes(chainIdHex))
+  const address = setLengthLeft(hexToBytes(addressHex), 20)
+  const nonce = unpadBytes(hexToBytes(nonceHex))
+  return [chainId, address, nonce]
+}
+
+/**
+ * Returns the bytes (RLP-encoded) to sign
+ * @param input Either the bytes or the object format of the authorization list item
+ * @returns
+ */
+export function eoaCode7702AuthorizationMessageToSign(
+  input: EOACode7702AuthorizationListItemUnsigned | EOACode7702AuthorizationListBytesItemUnsigned,
+) {
+  if (Array.isArray(input)) {
+    // The address is validated, the chainId and nonce will be `unpadBytes` such that these are valid
+    const [chainId, address, nonce] = input
+    if (address.length !== 20) {
+      throw EthereumJSErrorWithoutCode('Cannot sign authority: address length should be 20 bytes')
+    }
+    return concatBytes(
+      EOA_CODE_7702_AUTHORITY_SIGNING_MAGIC,
+      RLP.encode([unpadBytes(chainId), address, unpadBytes(nonce)]),
+    )
+  } else {
+    const [chainId, address, nonce] = unsignedAuthorizationListToBytes(input)
+    return concatBytes(EOA_CODE_7702_AUTHORITY_SIGNING_MAGIC, RLP.encode([chainId, address, nonce]))
+  }
+}
+
+/**
+ * Hashes the RLP-encoded message to sign
+ * @param input
+ * @returns
+ */
+export function eoaCode7702AuthorizationHashedMessageToSign(
+  input: EOACode7702AuthorizationListItemUnsigned | EOACode7702AuthorizationListBytesItemUnsigned,
+) {
+  return keccak_256(eoaCode7702AuthorizationMessageToSign(input))
+}
+
+/**
+ * Signs an authorization list item and returns it in `bytes` format.
+ * To get the JSON format, use `authorizationListBytesToJSON([signed])[0] to convert it`
+ * @param input
+ * @param privateKey
+ * @param ecSign
+ * @returns
+ */
+export function eoaCode7702SignAuthorization(
+  input: EOACode7702AuthorizationListItemUnsigned | EOACode7702AuthorizationListBytesItemUnsigned,
+  privateKey: Uint8Array,
+  ecSign?: (
+    msg: Uint8Array,
+    pk: Uint8Array,
+    ecSignOpts?: { extraEntropy?: Uint8Array | boolean },
+  ) => Pick<ReturnType<typeof secp256k1.Signature.fromBytes>, 'recovery' | 'r' | 's'>,
+): EOACode7702AuthorizationListBytesItem {
+  const msgHash = eoaCode7702AuthorizationHashedMessageToSign(input)
+  const secp256k1Sign = (msgHash: Uint8Array, pk: Uint8Array) => {
+    return (
+      ecSign?.(msgHash, pk) ??
+      secp256k1.Signature.fromBytes(
+        secp256k1.sign(msgHash, pk, { prehash: false, format: 'recovered' }),
+        'recovered',
+      )
+    )
+  }
+
+  const signed = secp256k1Sign(msgHash, privateKey)
+
+  const [chainId, address, nonce] = Array.isArray(input)
+    ? input
+    : unsignedAuthorizationListToBytes(input)
+
+  return [
+    unpadBytes(chainId),
+    address,
+    unpadBytes(nonce),
+    bigIntToUnpaddedBytes(BigInt(signed.recovery!)),
+    bigIntToUnpaddedBytes(signed.r),
+    bigIntToUnpaddedBytes(signed.s),
+  ]
+}
+
+export function eoaCode7702RecoverAuthority(
+  input: EOACode7702AuthorizationListItem | EOACode7702AuthorizationListBytesItem,
+): Address {
+  const inputBytes = Array.isArray(input)
+    ? input
+    : eoaCode7702AuthorizationListJSONItemToBytes(input)
+  const [chainId, address, nonce, yParity, r, s] = [
+    unpadBytes(inputBytes[0]),
+    inputBytes[1],
+    unpadBytes(inputBytes[2]),
+    unpadBytes(inputBytes[3]),
+    unpadBytes(inputBytes[4]),
+    unpadBytes(inputBytes[5]),
+  ]
+  const msgHash = eoaCode7702AuthorizationHashedMessageToSign([chainId, address, nonce])
+  const pubKey = ecrecover(msgHash, bytesToBigInt(yParity), r, s)
+  return new Address(publicToAddress(pubKey))
+}