@hfunlabs/hyperliquid 0.30.0-hfunlabs.1 → 0.30.2-hfunlabs.2

package/src/deps/jsr.io/@paulmillr/micro-eth-signer/0.18.1/src/core/tx.ts

@@ -0,0 +1,274 @@
+/*! micro-eth-signer - MIT License (c) 2021 Paul Miller (paulmillr.com) */
+import { keccak_256 } from '../../../../../@noble/hashes/2.0.1/src/sha3.js';
+import { bytesToHex, hexToBytes } from '../../../../../@noble/hashes/2.0.1/src/utils.js';
+import { type UnwrapCoder } from '../../../../micro-packed/0.8.0/src/index.js';
+import { addr } from './address.js';
+import {
+  RawTx,
+  TxVersions,
+  decodeLegacyV,
+  removeSig,
+  sortRawData,
+  validateFields,
+  type TxCoder,
+  type TxType,
+} from './tx-internal.js';
+// prettier-ignore
+import { secp256k1 } from '../../../../../@noble/curves/2.0.1/src/secp256k1.js';
+import {
+  amounts,
+  cloneDeep,
+  ethHex,
+  ethHexNoLeadingZero,
+  initSig,
+  isBytes,
+  sign,
+  strip0x,
+  verify,
+} from '../utils.js';
+
+// The file exports Transaction, but actual (RLP) parsing logic is done in `./tx`
+
+// Transaction-related utils.
+
+// 4 fields are required. Others are pre-filled with default values.
+const TX_DEFAULTS = {
+  accessList: [], // needs to be .slice()-d to create new reference
+  authorizationList: [],
+  chainId: BigInt(1) satisfies bigint as bigint, // mainnet
+  data: '',
+  gasLimit: BigInt(21000) satisfies bigint as bigint, // TODO: investigate if limit is smaller in eip4844 txs
+  maxPriorityFeePerGas: (BigInt(1) * amounts.GWEI) satisfies bigint as bigint, // Reduce fingerprinting by using standard, popular value
+  type: 'eip1559',
+} as const;
+type DefaultField = keyof typeof TX_DEFAULTS;
+type DefaultType = (typeof TX_DEFAULTS)['type'];
+type DefaultsOptional<T> = {
+  [P in keyof T as P extends DefaultField ? P : never]?: T[P];
+} & {
+  [P in keyof T as P extends DefaultField ? never : P]: T[P];
+};
+type HumanInputInner<T extends TxType> = DefaultsOptional<{ type: T } & TxCoder<T>>;
+type HumanInputInnerDefault = DefaultsOptional<TxCoder<DefaultType>>;
+type Required<T> = T extends undefined ? never : T;
+type HumanInput<T extends TxType | undefined> = T extends undefined
+  ? HumanInputInnerDefault
+  : HumanInputInner<Required<T>>;
+type TxVersions = typeof TxVersions;
+type SpecifyVersion<T extends TxType[]> = UnwrapCoder<
+  {
+    [K in keyof TxVersions]: K extends T[number] ? TxVersions[K] : never;
+  }[keyof TxVersions]
+>;
+type SpecifyVersionNeg<T extends TxType[]> = UnwrapCoder<
+  Exclude<
+    {
+      [K in keyof TxVersions]: TxVersions[K];
+    }[keyof TxVersions],
+    {
+      [K in keyof TxVersions]: K extends T[number] ? TxVersions[K] : never;
+    }[keyof TxVersions]
+  >
+>;
+
+// Changes:
+// - legacy: instead of hardfork now accepts additional param chainId
+//           if chainId is present, we enable relay protection
+//           This removes hardfork param and simplifies replay protection logic
+// - tx parametrized over type: you cannot access fields from different tx version
+// - legacy: 'v' param is hidden in coders. Transaction operates in terms chainId and yParity.
+// TODO: tx is kinda immutable, but user can change .raw values before signing
+// need to think about re-validation?
+export class Transaction<T extends TxType> {
+  readonly type: T;
+  readonly raw: TxCoder<T>;
+  readonly isSigned: boolean;
+
+  // Doesn't force any defaults, catches if fields incompatible with type
+  constructor(type: T, raw: TxCoder<T>, strict = true, allowSignatureFields = true) {
+    this.type = type;
+    this.raw = raw;
+    validateFields(type, raw, strict, allowSignatureFields);
+    this.isSigned = typeof raw.r === 'bigint' && typeof raw.s === 'bigint';
+  }
+  // Defaults
+  static prepare<T extends { type: undefined }>(
+    data: T & HumanInputInnerDefault,
+    strict?: boolean
+  ): Transaction<(typeof TX_DEFAULTS)['type']>;
+  static prepare<TT extends TxType, T extends { type: TT } & HumanInput<TT>>(
+    data: HumanInput<TT>,
+    strict?: boolean
+  ): Transaction<T['type']>;
+  static prepare<T extends TxType>(data: HumanInput<T>, strict = true): Transaction<T> {
+    const type = (data.type !== undefined ? data.type : TX_DEFAULTS.type) as T;
+    if (!TxVersions.hasOwnProperty(type)) throw new Error(`wrong transaction type=${type}`);
+    const coder = TxVersions[type];
+    const fields = new Set(coder.fields as string[]);
+    // Copy default fields, but only if the field is present on the tx type.
+    const raw: Record<string, any> = { type };
+    for (const f in TX_DEFAULTS) {
+      if (f !== 'type' && fields.has(f)) {
+        raw[f] = TX_DEFAULTS[f as DefaultField];
+        if (['accessList', 'authorizationList'].includes(f)) raw[f] = cloneDeep(raw[f]);
+      }
+    }
+    // Copy all fields, so we can validate unexpected ones.
+    return new Transaction(type, sortRawData(Object.assign(raw, data)), strict, false);
+  }
+  /**
+   * Creates transaction which sends whole account balance. Does two things:
+   * 1. `amount = accountBalance - maxFeePerGas * gasLimit`
+   * 2. `maxPriorityFeePerGas = maxFeePerGas`
+   *
+   * Every eth block sets a fee for all its transactions, called base fee.
+   * maxFeePerGas indicates how much gas user is able to spend in the worst case.
+   * If the block's base fee is 5 gwei, while user is able to spend 10 gwei in maxFeePerGas,
+   * the transaction would only consume 5 gwei. That means, base fee is unknown
+   * before the transaction is included in a block.
+   *
+   * By setting priorityFee to maxFee, we make the process deterministic:
+   * `maxFee = 10, maxPriority = 10, baseFee = 5` would always spend 10 gwei.
+   * In the end, the balance would become 0.
+   *
+   * WARNING: using the method would decrease privacy of a transfer, because
+   * payments for services have specific amounts, and not *the whole amount*.
+   * @param accountBalance - account balance in wei
+   * @param burnRemaining - send unspent fee to miners. When false, some "small amount" would remain
+   * @returns new transaction with adjusted amounts
+   */
+  setWholeAmount(accountBalance: bigint, burnRemaining = true): Transaction<T> {
+    const _0n = BigInt(0);
+    if (typeof accountBalance !== 'bigint' || accountBalance <= _0n)
+      throw new Error('account balance must be bigger than 0');
+    const fee = this.fee;
+    const amountToSend = accountBalance - fee;
+    if (amountToSend <= _0n) throw new Error('account balance must be bigger than fee of ' + fee);
+    const raw = { ...this.raw, value: amountToSend };
+    if (!['legacy', 'eip2930'].includes(this.type) && burnRemaining) {
+      const r = raw as SpecifyVersionNeg<['legacy', 'eip2930']>;
+      r.maxPriorityFeePerGas = r.maxFeePerGas;
+    }
+    return new Transaction(this.type, raw);
+  }
+  static fromRawBytes(
+    bytes: Uint8Array,
+    strict = false
+  ): Transaction<'legacy' | 'eip2930' | 'eip1559' | 'eip4844' | 'eip7702'> {
+    const raw = RawTx.decode(bytes);
+    return new Transaction(raw.type, raw.data, strict);
+  }
+  static fromHex(
+    hex: string,
+    strict = false
+  ): Transaction<'eip1559' | 'legacy' | 'eip2930' | 'eip4844' | 'eip7702'> {
+    return Transaction.fromRawBytes(ethHexNoLeadingZero.decode(hex), strict);
+  }
+  private assertIsSigned() {
+    if (!this.isSigned) throw new Error('expected signed transaction');
+  }
+  /**
+   * Converts transaction to RLP.
+   * @param includeSignature whether to include signature
+   */
+  toBytes(includeSignature: boolean = this.isSigned): Uint8Array {
+    // cloneDeep is not necessary here
+    let data = Object.assign({}, this.raw);
+    if (includeSignature) {
+      this.assertIsSigned();
+    } else {
+      removeSig(data);
+    }
+    return RawTx.encode({ type: this.type, data } as any); // TODO: remove any
+  }
+  /**
+   * Converts transaction to hex.
+   * @param includeSignature whether to include signature
+   */
+  toHex(includeSignature: boolean = this.isSigned): string {
+    return ethHex.encode(this.toBytes(includeSignature));
+  }
+  /** Calculates keccak-256 hash of signed transaction. Used in block explorers. */
+  get hash(): string {
+    this.assertIsSigned();
+    return bytesToHex(this.calcHash(true));
+  }
+  /** Returns sender's address. */
+  get sender(): string {
+    return this.recoverSender().address;
+  }
+  /**
+   * For legacy transactions, but can be used with libraries when yParity presented as v.
+   */
+  get v(): bigint | undefined {
+    return decodeLegacyV(this.raw);
+  }
+  private calcHash(includeSignature: boolean): Uint8Array {
+    return keccak_256(this.toBytes(includeSignature));
+  }
+  /** Calculates MAXIMUM fee in wei that could be spent. */
+  get fee(): bigint {
+    const { type, raw } = this;
+    // Fee calculation is not exact, real fee can be smaller
+    let gasFee;
+    if (type === 'legacy' || type === 'eip2930') {
+      // Because TypeScript is not smart enough to narrow down types here :(
+      const r = raw as SpecifyVersion<['legacy', 'eip2930']>;
+      gasFee = r.gasPrice;
+    } else {
+      const r = raw as SpecifyVersionNeg<['legacy', 'eip2930']>;
+      // maxFeePerGas is absolute limit, you never pay more than that
+      // maxFeePerGas = baseFeePerGas[*2] + maxPriorityFeePerGas
+      gasFee = r.maxFeePerGas;
+    }
+    // TODO: how to calculate 4844 fee?
+    return raw.gasLimit * gasFee;
+  }
+  clone(): Transaction<T> {
+    return new Transaction(this.type, cloneDeep(this.raw));
+  }
+  verifySignature(): boolean {
+    this.assertIsSigned();
+    const { r, s } = this.raw;
+    return verify(
+      new secp256k1.Signature(r!, s!).toBytes(),
+      this.calcHash(false),
+      hexToBytes(this.recoverSender().publicKey)
+    );
+  }
+  removeSignature(): Transaction<T> {
+    return new Transaction(this.type, removeSig(cloneDeep(this.raw)));
+  }
+  /**
+   * Signs transaction with a private key.
+   * @param privateKey key in hex or Uint8Array format
+   * @param opts extraEntropy will increase security of sig by mixing rfc6979 randomness
+   * @returns new "same" transaction, but signed
+   */
+  signBy(
+    privateKey: string | Uint8Array,
+    extraEntropy: boolean | Uint8Array = true
+  ): Transaction<T> {
+    if (this.isSigned) throw new Error('expected unsigned transaction');
+    const priv = isBytes(privateKey) ? privateKey : hexToBytes(strip0x(privateKey));
+    const hash = this.calcHash(false);
+    const sig = sign(hash, priv, extraEntropy);
+    const { r, s, recovery } = sig;
+    const sraw = Object.assign(cloneDeep(this.raw), { r, s, yParity: recovery });
+    // The copied result is validated in non-strict way, strict is only for user input.
+    return new Transaction(this.type, sraw, false);
+  }
+  /** Calculates public key and address from signed transaction's signature. */
+  recoverSender(): { publicKey: string; address: string } {
+    this.assertIsSigned();
+    const { r, s, yParity } = this.raw;
+    const sig = initSig({ r: r!, s: s! }, yParity!);
+    // Will crash on 'chainstart' hardfork
+    if (sig.hasHighS()) throw new Error('invalid s');
+    const publicKey = secp256k1.recoverPublicKey(sig.toBytes('recovered'), this.calcHash(false), {
+      prehash: false,
+    });
+    // const point = sig.recoverPublicKey(this.calcHash(false));
+    return { publicKey: bytesToHex(publicKey), address: addr.fromPublicKey(publicKey) };
+  }
+}

package/src/deps/jsr.io/@paulmillr/micro-eth-signer/0.18.1/src/core/typed-data.ts

@@ -0,0 +1,391 @@
+import { secp256k1 } from '../../../../../@noble/curves/2.0.1/src/secp256k1.js';
+import { keccak_256 } from '../../../../../@noble/hashes/2.0.1/src/sha3.js';
+import { concatBytes, hexToBytes, utf8ToBytes } from '../../../../../@noble/hashes/2.0.1/src/utils.js';
+import { mapComponent, type GetType as AbiGetType } from '../advanced/abi-mapper.js';
+import { add0x, astr, ethHex, initSig, isObject, sign, strip0x, verify } from '../utils.js';
+import { addr } from './address.js';
+
+// EIP-191 signed data (https://eips.ethereum.org/EIPS/eip-191)
+export type Hex = string | Uint8Array;
+export interface TypedSigner<T> {
+  _getHash: (message: T) => string;
+  sign(message: T, privateKey: Hex, extraEntropy?: boolean | Uint8Array): string;
+  recoverPublicKey(signature: string, message: T): string;
+  verify(signature: string, message: T, address: string): boolean;
+}
+// 0x19 <1 byte version> <version specific data> <data to sign>.
+// VERSIONS:
+// - 0x19 <0x00> <intended validator address> <data to sign>
+// - 0x19 <0x01> domainSeparator hashStruct(message)
+// - 0x19 <0x45 (E)> <thereum Signed Message:\n" + len(message)> <data to sign>
+function getSigner<T>(version: number, msgFn: (message: T) => Uint8Array): TypedSigner<T> {
+  if (version < 0 || version >= 256 || !Number.isSafeInteger(version))
+    throw new Error('Wrong version byte');
+  //     bytes32 hash = keccak256(abi.encodePacked(byte(0x19), byte(0), address(this), msg.value, nonce, payload));
+  const getHash = (message: T) =>
+    keccak_256(concatBytes(new Uint8Array([0x19, version]), msgFn(message)));
+  // TODO: 'v' can contain non-undefined chainId, but not sure if it is used. If used, we need to check it with EIP-712 domain
+  return {
+    _getHash: (message: T) => ethHex.encode(getHash(message)),
+    sign(message: T, privateKey: Hex, extraEntropy: boolean | Uint8Array = true) {
+      const hash = getHash(message);
+      if (typeof privateKey === 'string') privateKey = ethHex.decode(privateKey);
+      const sig = sign(hash, privateKey, extraEntropy);
+      const end = sig.recovery === 0 ? '1b' : '1c';
+      return add0x(sig.toHex('compact') + end);
+    },
+    recoverPublicKey(signature: string, message: T) {
+      astr(signature);
+      const hash = getHash(message);
+      signature = strip0x(signature);
+      if (signature.length !== 65 * 2) throw new Error('invalid signature length');
+      const sigh = signature.slice(0, -2);
+      const end = signature.slice(-2);
+      if (!['1b', '1c'].includes(end)) throw new Error('invalid recovery bit');
+      const sig = initSig(hexToBytes(sigh), end === '1b' ? 0 : 1);
+      const publicKey = secp256k1.recoverPublicKey(sig.toBytes('recovered'), hash, {
+        prehash: false,
+      });
+      // const pub = sig.recoverPublicKey(hash).toBytes(false);
+      if (!verify(sig.toBytes('compact'), hash, publicKey)) throw new Error('invalid signature');
+      return addr.fromPublicKey(publicKey);
+    },
+    verify(signature: string, message: T, address: string): boolean {
+      const recAddr = this.recoverPublicKey(signature, message);
+      const low = recAddr.toLowerCase();
+      const upp = recAddr.toUpperCase();
+      if (address === low || address === upp) return true; // non-checksummed
+      return recAddr === address; // checksummed
+    },
+  };
+}
+
+// EIP-191/EIP-7749: 0x19 <0x00> <intended validator address> <data to sign>
+// export const intendedValidator = getSigner(
+//   0x00,
+//   ({ message, validator }: { message: Uint8Array; validator: string }) => {
+//     const { data } = addr.parse(validator);
+//     return concatBytes(hexToBytes(data), message);
+//   }
+// );
+
+// EIP-191: 0x19 <0x45 (E)> <thereum Signed Message:\n" + len(message)> <data to sign>
+export const eip191Signer: TypedSigner<string | Uint8Array> = getSigner(
+  0x45,
+  (msg: string | Uint8Array) => {
+    if (typeof msg === 'string') msg = utf8ToBytes(msg);
+    return concatBytes(utf8ToBytes(`thereum Signed Message:\n${msg.length}`), msg);
+  }
+);
+
+// eip712 typed signed data on top of signed data (https://eips.ethereum.org/EIPS/eip-712)
+// - V1: no domain, {name: string, type: string, value: any}[] - NOT IMPLEMENTED
+// - V3: basic (no arrays and recursive stuff)
+// - V4: V3 + support of arrays and recursive stuff
+// TODO:
+// https://eips.ethereum.org/EIPS/eip-4361: Off-chain authentication for Ethereum accounts to establish sessions
+
+// There is two API for different usage-cases:
+// - encodeData/signTyped, verifyTyped -> wallet like application, when we sign already constructed stuff ('web3.eth.personal.signTypedData')
+// - encoder(type).encodeData/sign/verify -> if we construct data and want re-use types for different requests + type safety for static types.
+
+// TODO: type is ABI type, but restricted
+export type EIP712Component = { name: string; type: string };
+export type EIP712Types = Record<string, readonly EIP712Component[]>;
+
+// This makes 'bytes' -> Uint8Array, 'uint' -> bigint. However, we support 'string' for them (JSON in wallets),
+// but for static types it is actually better to use strict types, since otherwise everything is 'string'. Address is string,
+// but sending it in uint field can be mistake. Please open issue if you have use case where this behavior causes problems.
+// prettier-ignore
+type ProcessType<T extends string, Types extends EIP712Types> =
+  T extends `${infer Base}[]${infer Rest}` ? ProcessType<`${Base}${Rest}`, Types>[] : // 'string[]' -> 'string'[]
+  T extends `${infer Base}[${number}]${infer Rest}` ? ProcessType<`${Base}${Rest}`, Types>[] : // 'string[3]' -> 'string'[]
+  T extends keyof Types ? GetType<Types, T> | undefined : // recursive
+  AbiGetType<T>;
+
+export type GetType<Types extends EIP712Types, K extends keyof Types & string> = {
+  [C in Types[K][number] as C['name']]: ProcessType<C['type'], Types>;
+};
+type Key<T extends EIP712Types> = keyof T & string;
+
+// TODO: merge with abi somehow?
+function parseType(s: string): {
+  base: string;
+  item: string;
+  type: string;
+  arrayLen: number | undefined;
+  isArray: boolean;
+} {
+  let m = s.match(/^([^\[]+)(?:.*\[(.*?)\])?$/);
+  if (!m) throw new Error(`parseType: wrong type: ${s}`);
+  const base = m[1];
+  const isArray = m[2] !== undefined;
+  // TODO: check for safe integer
+  const arrayLen = m[2] !== undefined && m[2] !== '' ? Number(m[2]) : undefined;
+  if (arrayLen !== undefined && (!Number.isSafeInteger(arrayLen) || arrayLen.toString() !== m[2]))
+    throw new Error(`parseType: wrong array length: ${s}`);
+  let type = 'struct';
+  if (['string', 'bytes'].includes(base)) type = 'dynamic';
+  else if (['bool', 'address'].includes(base)) type = 'atomic';
+  else if ((m = /^(u?)int([0-9]+)?$/.exec(base))) {
+    const bits = m[2] ? +m[2] : 256;
+    if (!Number.isSafeInteger(bits) || bits <= 0 || bits % 8 !== 0 || bits > 256)
+      throw new Error('parseType: invalid numeric type');
+    type = 'atomic';
+  } else if ((m = /^bytes([0-9]{1,2})$/.exec(base))) {
+    const bytes = +m[1];
+    if (!bytes || bytes > 32) throw new Error(`parseType: wrong bytes<N=${bytes}> type`);
+    type = 'atomic';
+  }
+  const item = s.replace(/\[[^\]]*\]$/, '');
+  return { base, item, type, arrayLen, isArray };
+}
+
+// traverse dependency graph, find all transitive dependencies. Also, basic sanity check
+function getDependencies(types: EIP712Types): Record<string, Set<string>> {
+  if (typeof types !== 'object' || types === null) throw new Error('wrong types object');
+  // Collect non-basic dependencies & sanity
+  const res: Record<string, Set<string>> = {};
+  for (const [name, fields] of Object.entries(types)) {
+    const cur: Set<string> = new Set(); // type may appear multiple times in struct
+    for (const { type } of fields) {
+      const p = parseType(type);
+      if (p.type !== 'struct') continue; // skip basic fields
+      if (p.base === name) continue; // self reference
+      if (!types[p.base]) throw new Error(`getDependencies: wrong struct type name=${type}`);
+      cur.add(p.base);
+    }
+    res[name] = cur;
+  }
+  // This should be more efficient with toposort + cycle detection, but I've already spent too much time here
+  // and for most cases there won't be a lot of types here anyway.
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const [name, curDeps] of Object.entries(res)) {
+      // Map here, because curDeps will change
+      const trDeps = Array.from(curDeps).map((i) => res[i]);
+      for (const d of trDeps) {
+        for (const td of d) {
+          if (td === name || curDeps.has(td)) continue;
+          curDeps.add(td);
+          changed = true;
+        }
+      }
+    }
+  }
+  return res;
+}
+
+function getTypes(types: EIP712Types) {
+  const deps = getDependencies(types);
+  const names: Record<string, string> = {};
+  // Build names
+  for (const type in types)
+    names[type] = `${type}(${types[type].map(({ name, type }) => `${type} ${name}`).join(',')})`;
+  const fullNames: Record<string, string> = {};
+  for (const [name, curDeps] of Object.entries(deps)) {
+    const n = [name].concat(Array.from(curDeps).sort());
+    fullNames[name] = n.map((i) => names[i]).join('');
+  }
+  const hashes = Object.fromEntries(
+    Object.entries(fullNames).map(([k, v]) => [k, keccak_256(utf8ToBytes(v))])
+  );
+  // fields
+  const fields: Record<string, Set<string>> = {};
+  for (const type in types) {
+    const res: Set<string> = new Set();
+    for (const { name } of types[type]) {
+      if (res.has(name)) throw new Error(`field ${name} included multiple times in type ${type}`);
+      res.add(name);
+    }
+    fields[type] = res;
+  }
+  return { names, fullNames, hashes, fields };
+}
+
+// This re-uses domain per multiple requests, which is based on assumption that domain is static for different requests with
+// different types. Please raise issue if you have different use case.
+export function encoder<T extends EIP712Types>(types: T, domain: GetType<T, 'EIP712Domain'>) {
+  if (!isObject(domain)) throw Error(`wrong domain=${domain}`);
+  if (!isObject(types)) throw Error(`wrong types=${types}`);
+  const info = getTypes(types);
+  const encodeField = (type: string, data: any, withHash = true): Uint8Array => {
+    const p = parseType(type);
+    if (p.isArray) {
+      if (!Array.isArray(data)) throw new Error(`expected array, got: ${data}`);
+      if (p.arrayLen !== undefined && data.length !== p.arrayLen)
+        throw new Error(`wrong array length: expected ${p.arrayLen}, got ${data}`);
+      return keccak_256(concatBytes(...data.map((i) => encodeField(p.item, i))));
+    }
+    if (p.type === 'struct') {
+      const def = types[type];
+      if (!def) throw new Error(`wrong type: ${type}`);
+      const fieldNames = info.fields[type];
+      if (!isObject(data)) throw new Error(`encoding non-object as custom type ${type}`);
+      for (const k in data)
+        if (!fieldNames.has(k)) throw new Error(`unexpected field ${k} in ${type}`);
+      // TODO: use correct concatBytes (need to export from P?). This will easily crash with stackoverflow if too much fields.
+      const fields = [];
+      for (const { name, type } of def) {
+        // This is not mentioned in spec, but used in eth-sig-util
+        // Since there is no 'optional' fields inside eip712, it makes impossible to encode circular structure without arrays,
+        // but seems like other project use this.
+        // NOTE: this is V4 only stuff. If you need V3 behavior, please open issue.
+        if (types[type] && data[name] === undefined) {
+          fields.push(new Uint8Array(32));
+          continue;
+        }
+        fields.push(encodeField(type, data[name]));
+      }
+      const res = concatBytes(info.hashes[p.base], ...fields);
+      return withHash ? keccak_256(res) : res;
+    }
+    if (type === 'string' || type === 'bytes') {
+      if (type === 'bytes' && typeof data === 'string') data = ethHex.decode(data);
+      return keccak_256(typeof data === 'string' ? utf8ToBytes(data) : data); // hashed as is!
+    }
+    // Type conversion is neccessary here, because we can get data from JSON (no Uint8Arrays/bigints).
+    if (type.startsWith('bytes') && typeof data === 'string') data = ethHex.decode(data);
+    if ((type.startsWith('int') || type.startsWith('uint')) && typeof data === 'string')
+      data = BigInt(data);
+    return mapComponent({ type }).encode(data);
+  };
+  const encodeData = <K extends Key<T>>(type: K, data: GetType<T, K>) => {
+    astr(type);
+    if (!types[type]) throw new Error(`Unknown type: ${type}`);
+    if (!isObject(data)) throw new Error('wrong data object');
+    return encodeField(type, data, false);
+  };
+  const structHash = (type: Key<T>, data: any) => keccak_256(encodeData(type, data));
+  const domainHash = structHash('EIP712Domain', domain);
+  // NOTE: we cannot use Msg here, since its already parametrized and everything will break.
+  const signer = getSigner(0x01, (msg: { primaryType: string; message: any }) => {
+    if (typeof msg.primaryType !== 'string') throw Error(`wrong primaryType=${msg.primaryType}`);
+    if (!isObject(msg.message)) throw Error(`wrong message=${msg.message}`);
+    if (msg.primaryType === 'EIP712Domain') return domainHash;
+    return concatBytes(domainHash, structHash(msg.primaryType, msg.message));
+  });
+  return {
+    encodeData: <K extends Key<T>>(type: K, message: GetType<T, K>): string =>
+      ethHex.encode(encodeData(type, message)),
+    structHash: <K extends Key<T>>(type: K, message: GetType<T, K>): string =>
+      ethHex.encode(structHash(type, message)),
+    // Signer
+    _getHash: <K extends Key<T>>(primaryType: K, message: GetType<T, K>): string =>
+      signer._getHash({ primaryType, message }),
+    sign: <K extends Key<T>>(
+      primaryType: K,
+      message: GetType<T, K>,
+      privateKey: Hex,
+      extraEntropy?: boolean | Uint8Array
+    ): string => signer.sign({ primaryType, message }, privateKey, extraEntropy),
+    verify: <K extends Key<T>>(
+      primaryType: K,
+      signature: string,
+      message: GetType<T, K>,
+      address: string
+    ): boolean => signer.verify(signature, { primaryType, message }, address),
+    recoverPublicKey: <K extends Key<T>>(
+      primaryType: K,
+      signature: string,
+      message: GetType<T, K>
+    ): string => signer.recoverPublicKey(signature, { primaryType, message }),
+  };
+}
+
+export const EIP712Domain = [
+  { name: 'name', type: 'string' }, // the user readable name of signing domain, i.e. the name of the DApp or the protocol.
+  { name: 'version', type: 'string' }, // the current major version of the signing domain. Signatures from different versions are not compatible.
+  { name: 'chainId', type: 'uint256' }, // the EIP-155 chain id. The user-agent should refuse signing if it does not match the currently active chain.
+  { name: 'verifyingContract', type: 'address' }, // the address of the contract that will verify the signature. The user-agent may do contract specific phishing prevention.
+  { name: 'salt', type: 'bytes32' }, // an disambiguating salt for the protocol. This can be used as a domain separator of last resort.
+] as const;
+export type DomainParams = typeof EIP712Domain;
+
+const domainTypes = { EIP712Domain: EIP712Domain as DomainParams };
+export type EIP712Domain = GetType<typeof domainTypes, 'EIP712Domain'>;
+
+// Filter unused domain fields from type
+export function getDomainType(domain: EIP712Domain) {
+  return EIP712Domain.filter(({ name }) => domain[name] !== undefined);
+}
+// Additional API without type safety for wallet-like applications
+export type TypedData<T extends EIP712Types, K extends Key<T>> = {
+  types: T;
+  primaryType: K;
+  domain: GetType<T, 'EIP712Domain'>;
+  message: GetType<T, K>;
+};
+
+const getTypedTypes = <T extends EIP712Types, K extends Key<T>>(typed: TypedData<T, K>) => ({
+  EIP712Domain: getDomainType(typed.domain as any),
+  ...typed.types,
+});
+
+function validateTyped<T extends EIP712Types, K extends Key<T>>(t: TypedData<T, K>) {
+  if (!isObject(t.message)) throw new Error('wrong message');
+  if (!isObject(t.domain)) throw new Error('wrong domain');
+  if (!isObject(t.types)) throw new Error('wrong types');
+  if (typeof t.primaryType !== 'string' || !t.types[t.primaryType])
+    throw new Error('wrong primaryType');
+}
+
+export function encodeData<T extends EIP712Types, K extends Key<T>>(
+  typed: TypedData<T, K>
+): string {
+  validateTyped(typed);
+  return encoder(getTypedTypes(typed) as T, typed.domain).encodeData(
+    typed.primaryType,
+    typed.message
+  );
+}
+
+export function sigHash<T extends EIP712Types, K extends Key<T>>(typed: TypedData<T, K>): string {
+  validateTyped(typed);
+  return encoder(getTypedTypes(typed) as T, typed.domain)._getHash(
+    typed.primaryType,
+    typed.message
+  );
+}
+
+export function signTyped<T extends EIP712Types, K extends Key<T>>(
+  typed: TypedData<T, K>,
+  privateKey: Hex,
+  extraEntropy?: boolean | Uint8Array
+): string {
+  validateTyped(typed);
+  return encoder(getTypedTypes(typed) as T, typed.domain).sign(
+    typed.primaryType,
+    typed.message,
+    privateKey,
+    extraEntropy
+  );
+}
+
+export function verifyTyped<T extends EIP712Types, K extends Key<T>>(
+  signature: string,
+  typed: TypedData<T, K>,
+  address: string
+): boolean {
+  validateTyped(typed);
+  return encoder(getTypedTypes(typed) as T, typed.domain).verify(
+    typed.primaryType,
+    signature,
+    typed.message,
+    address
+  );
+}
+
+export function recoverPublicKeyTyped<T extends EIP712Types, K extends Key<T>>(
+  signature: string,
+  typed: TypedData<T, K>
+): string {
+  return encoder(getTypedTypes(typed) as T, typed.domain).recoverPublicKey(
+    typed.primaryType,
+    signature,
+    typed.message
+  );
+}
+
+// Internal methods for test purposes only
+export const _TEST: any = /* @__PURE__ */ { parseType, getDependencies, getTypes, encoder };

package/src/deps/jsr.io/@paulmillr/micro-eth-signer/0.18.1/src/index.ts

@@ -0,0 +1,12 @@
+export { addr } from './core/address.js';
+export { authorization } from './core/tx-internal.js';
+export { Transaction } from './core/tx.js';
+export {
+  eip191Signer,
+  recoverPublicKeyTyped,
+  signTyped,
+  verifyTyped,
+  type EIP712Domain,
+  type TypedData,
+} from './core/typed-data.js';
+export { amounts, ethHex, ethHexNoLeadingZero, weieth, weigwei } from './utils.js';