@hfunlabs/hyperliquid 0.29.1-hfunlabs.1 → 0.30.0-hfunlabs.1

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

@@ -1,274 +0,0 @@
-/*! 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

@@ -1,391 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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';