@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-internal.ts

@@ -0,0 +1,626 @@
+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 } from '../../../../../@noble/hashes/2.0.1/src/utils.js';
+import * as P from '../../../../micro-packed/0.8.0/src/index.js';
+import { amounts, astr, ethHex, initSig, isBytes, isObject, sign, type Bytes } from '../utils.js';
+import { addr } from './address.js';
+import { RLP } from './rlp.js';
+
+// Transaction parsers
+
+const _0n = BigInt(0);
+
+export type AnyCoder = Record<string, P.Coder<any, any>>;
+export type AnyCoderStream = Record<string, P.CoderType<any>>;
+
+// EIP-2718 (very ambigious)
+// new tx: [0, 0x7f]
+// legacy: [0xc0, 0xfe]
+// reserved: 0xff
+type VersionType<V extends AnyCoderStream> = {
+  [K in keyof V]: { type: K; data: P.UnwrapCoder<V[K]> };
+}[keyof V];
+
+export type TxCoder<T extends TxType> = P.UnwrapCoder<(typeof TxVersions)[T]>;
+
+const createTxMap = <T extends AnyCoderStream>(versions: T): P.CoderType<VersionType<T>> => {
+  const ent = Object.entries(versions);
+  // 'legacy' => {type, ver, coder}
+  const typeMap = Object.fromEntries(ent.map(([type, coder], ver) => [type, { type, ver, coder }]));
+  // '0' => {type, ver, coder}
+  const verMap = Object.fromEntries(ent.map(([type, coder], ver) => [ver, { type, ver, coder }]));
+  return P.wrap({
+    encodeStream(w: P.Writer, value: VersionType<T>) {
+      const t = value.type as string;
+      if (!typeMap.hasOwnProperty(t)) throw new Error(`txVersion: wrong type=${t}`);
+      const curr = typeMap[t];
+      if (t !== 'legacy') w.byte(curr.ver);
+      curr.coder.encodeStream(w, value.data);
+    },
+    decodeStream(r: P.Reader) {
+      const v = r.byte(true);
+      if (v === 0xff) throw new Error('reserved version 0xff');
+      // TODO: version=0 is legacy, but it is never wrapped in test vectors
+      if (v === 0x00) throw new Error('version=0 unsupported');
+      if (0 <= v && v <= 0x7f) {
+        if (!verMap.hasOwnProperty(v.toString())) throw new Error(`wrong version=${v}`);
+        const curr = verMap[v];
+        r.byte(false); // skip first byte
+        const d = curr.coder.decodeStream(r);
+        return { type: curr.type, data: d };
+      }
+      return { type: 'legacy', data: typeMap.legacy.coder.decodeStream(r) };
+    },
+  });
+};
+
+/**
+ * Static struct could have been extracted into micro-packed, but we need a specific behavior:
+ * - optional fields maybe either all present or all absent, enforced by type
+ * - optional fields change the length of underlying array
+ */
+const isOptBig = (a: unknown) => a === undefined || typeof a === 'bigint';
+const isNullOr0 = (a: unknown) => a === undefined || a === BigInt(0);
+
+function assertYParityValid(elm: number) {
+  // TODO: is this correct? elm = 0 default?
+  if (elm === undefined) elm = 0;
+  if (elm !== 0 && elm !== 1) throw new Error(`yParity wrong value=${elm} (${typeof elm})`);
+}
+// We don't know chainId when specific field coded yet.
+const addrCoder = ethHex;
+// Bytes32: VersionedHash, AccessListKey
+function ensure32(b: Uint8Array): Uint8Array {
+  if (!isBytes(b) || b.length !== 32) throw new Error('expected 32 bytes');
+  return b;
+}
+const Bytes32: P.Coder<Bytes, string> = {
+  encode: (from) => ethHex.encode(ensure32(from)),
+  decode: (to) => ensure32(ethHex.decode(to)),
+};
+
+type VRS = Partial<{ v: bigint; r: bigint; s: bigint }>;
+type YRS = Partial<{ chainId: bigint; yParity: number; r: bigint; s: bigint }>;
+
+// Process v as (chainId, yParity) pair. Ethers.js-inspired logic:
+//   - v=27/28 -> no chainId (pre eip155)
+//   - r & s == 0 -> v = chainId
+// Non-standard, but there is no other way to save chainId for unsignedTx.
+// Case: unsigned tx for cold wallet for different chains, like mainnet & testnet.
+//   - otherwise v = yParity + 2*chainId + 35
+//   - allows to keep legacy logic here, instead of copying to Transaction
+export const legacySig = {
+  encode: (data: VRS) => {
+    const { v, r, s } = data;
+    if (v === undefined) return { chainId: undefined };
+    // TODO: handle (invalid?) negative v
+    if (typeof v !== 'bigint') throw new Error(`invalid v type=${typeof v}`);
+    if ((r === undefined && s === undefined) || (r === _0n && s === _0n)) return { chainId: v };
+    if (v === BigInt(27)) return { yParity: 0, chainId: undefined, r, s };
+    if (v === BigInt(28)) return { yParity: 1, chainId: undefined, r, s };
+    if (v < BigInt(35)) throw new Error(`wrong v=${v}`);
+    const v2 = v - BigInt(35);
+    return { chainId: v2 >> BigInt(1), yParity: Number(v2 & BigInt(1)), r, s };
+  },
+  decode: (data: YRS) => {
+    aobj(data);
+    const { chainId, yParity, r, s } = data;
+    if (!isOptBig(chainId)) throw new Error(`wrong chainId type=${typeof chainId}`);
+    if (!isOptBig(r)) throw new Error(`wrong r type=${typeof r}`);
+    if (!isOptBig(s)) throw new Error(`wrong s type=${typeof s}`);
+    if (yParity !== undefined && typeof yParity !== 'number')
+      throw new Error(`wrong yParity type=${typeof chainId}`);
+    if (yParity === undefined) {
+      if (chainId !== undefined) {
+        if ((r !== undefined && r !== _0n) || (s !== undefined && s !== _0n))
+          throw new Error(`wrong unsigned legacy r=${r} s=${s}`);
+        return { v: chainId, r: _0n, s: _0n };
+      }
+      // no parity, chainId, but r, s exists
+      if ((r !== undefined && r !== _0n) || (s !== undefined && s !== _0n))
+        throw new Error(`wrong unsigned legacy r=${r} s=${s}`);
+      return {};
+    }
+    // parity exists, which means r & s should exist too!
+    if (isNullOr0(r) || isNullOr0(s)) throw new Error(`wrong unsigned legacy r=${r} s=${s}`);
+    assertYParityValid(yParity);
+    const v =
+      chainId !== undefined
+        ? BigInt(yParity) + (chainId * BigInt(2) + BigInt(35))
+        : BigInt(yParity) + BigInt(27);
+    return { v, r, s };
+  },
+} as P.Coder<VRS, YRS>;
+
+const U64BE = P.coders.reverse(P.bigint(8, false, false, false));
+const U256BE = P.coders.reverse(P.bigint(32, false, false, false));
+
+// Small coder utils
+// TODO: seems generic enought for packed? or RLP (seems useful for structured encoding/decoding of RLP stuff)
+// Basic array coder
+const array = <F, T>(coder: P.Coder<F, T>): P.Coder<F[], T[]> => ({
+  encode(from: F[]) {
+    if (!Array.isArray(from)) throw new Error('expected array');
+    return from.map((i) => coder.encode(i));
+  },
+  decode(to: T[]) {
+    if (!Array.isArray(to)) throw new Error('expected array');
+    return to.map((i) => coder.decode(i));
+  },
+});
+// tuple -> struct
+const struct = <
+  Fields extends Record<string, P.Coder<any, any>>,
+  FromTuple extends {
+    [K in keyof Fields]: Fields[K] extends P.Coder<infer F, any> ? F : never;
+  }[keyof Fields][],
+  ToObject extends { [K in keyof Fields]: Fields[K] extends P.Coder<any, infer T> ? T : never },
+>(
+  fields: Fields
+): P.Coder<FromTuple, ToObject> => ({
+  encode(from: FromTuple) {
+    if (!Array.isArray(from)) throw new Error('expected array');
+    const fNames = Object.keys(fields);
+    if (from.length !== fNames.length) throw new Error('wrong array length');
+    return Object.fromEntries(fNames.map((f, i) => [f, fields[f].encode(from[i])])) as ToObject;
+  },
+  decode(to: ToObject): FromTuple {
+    const fNames = Object.keys(fields);
+    if (!isObject(to)) throw new Error('wrong struct object');
+    return fNames.map((i) => fields[i].decode(to[i])) as FromTuple;
+  },
+});
+
+// U256BE in geth. But it is either 0 or 1. TODO: is this good enough?
+const yParityCoder = P.coders.reverse(
+  P.validate(P.int(1, false, false, false), (elm) => {
+    assertYParityValid(elm);
+    return elm;
+  })
+);
+type CoderOutput<F> = F extends P.Coder<any, infer T> ? T : never;
+
+const accessListItem: P.Coder<
+  (Bytes | Bytes[])[],
+  {
+    address: string;
+    storageKeys: string[];
+  }
+> = struct({ address: addrCoder, storageKeys: array(Bytes32) });
+export type AccessList = CoderOutput<typeof accessListItem>[];
+
+export const authorizationRequest: P.Coder<
+  Bytes[],
+  {
+    chainId: bigint;
+    address: string;
+    nonce: bigint;
+  }
+> = struct({
+  chainId: U256BE,
+  address: addrCoder,
+  nonce: U64BE,
+});
+// [chain_id, address, nonce, y_parity, r, s]
+const authorizationItem: P.Coder<
+  Bytes[],
+  {
+    chainId: bigint;
+    address: string;
+    nonce: bigint;
+    yParity: number;
+    r: bigint;
+    s: bigint;
+  }
+> = struct({
+  chainId: U256BE,
+  address: addrCoder,
+  nonce: U64BE,
+  yParity: yParityCoder,
+  r: U256BE,
+  s: U256BE,
+});
+export type AuthorizationItem = CoderOutput<typeof authorizationItem>;
+export type AuthorizationRequest = CoderOutput<typeof authorizationRequest>;
+
+/**
+ * Field types, matching geth. Either u64 or u256.
+ */
+const coders = {
+  chainId: U256BE, // Can fit into u64 (curr max is 0x57a238f93bf), but geth uses bigint
+  nonce: U64BE,
+  gasPrice: U256BE,
+  maxPriorityFeePerGas: U256BE,
+  maxFeePerGas: U256BE,
+  gasLimit: U64BE,
+  to: addrCoder,
+  value: U256BE, // "Decimal" coder can be used, but it's harder to work with
+  data: ethHex,
+  accessList: array(accessListItem),
+  maxFeePerBlobGas: U256BE,
+  blobVersionedHashes: array(Bytes32),
+  yParity: yParityCoder,
+  v: U256BE,
+  r: U256BE,
+  s: U256BE,
+  authorizationList: array(authorizationItem),
+};
+type Coders = typeof coders;
+type CoderName = keyof Coders;
+const signatureFields = new Set(['v', 'yParity', 'r', 's'] as const);
+
+type FieldType<T> = T extends P.Coder<any, infer U> ? U : T;
+// Could be 'T | (T & O)', to make sure all partial fields either present or absent together
+// But it would make accesing them impossible, because of typescript stuff:
+type OptFields<T, O> = T & Partial<O>;
+type FieldCoder<C> = P.CoderType<C> & {
+  fields: CoderName[];
+  optionalFields: CoderName[];
+  setOfAllFields: Set<CoderName | 'type'>;
+};
+
+// Mutates raw. Make sure to copy it in advance
+export function removeSig(raw: TxCoder<any>): TxCoder<any> {
+  signatureFields.forEach((k) => {
+    delete raw[k];
+  });
+  return raw;
+}
+
+/**
+ * Defines RLP transaction with fields taken from `coders`.
+ * @example
+ *   const tx = txStruct(['nonce', 'gasPrice', 'value'] as const, ['v', 'r', 's'] as const)
+ *   tx.nonce.decode(...);
+ */
+const txStruct = <T extends readonly CoderName[], ST extends readonly CoderName[]>(
+  reqf: T,
+  optf: ST
+): FieldCoder<
+  OptFields<{ [K in T[number]]: FieldType<Coders[K]> }, { [K in ST[number]]: FieldType<Coders[K]> }>
+> => {
+  const allFields = reqf.concat(optf);
+  // Check that all fields have known coders
+  allFields.forEach((f) => {
+    if (!coders.hasOwnProperty(f)) throw new Error(`coder for field ${f} is not defined`);
+  });
+  const reqS = struct(Object.fromEntries(reqf.map((i) => [i, coders[i]])));
+  const allS = struct(Object.fromEntries(allFields.map((i) => [i, coders[i]])));
+  // e.g. eip1559 txs have valid lengths of 9 or 12 (unsigned / signed)
+  const reql = reqf.length;
+  const optl = reql + optf.length;
+  const optFieldAt = (i: number) => reql + i;
+  const isEmpty = (item: any & { length: number }) => item.length === 0;
+  // TX is a bunch of fields in specific order. Field like nonce must always be at the same index.
+  // We walk through all indexes in proper order.
+  const fcoder: any = P.wrap({
+    encodeStream(w, raw: Record<string, any>) {
+      // If at least one optional key is present, we add whole optional block
+      const hasOptional = optf.some((f) => raw.hasOwnProperty(f));
+      const sCoder = hasOptional ? allS : reqS;
+      RLP.encodeStream(w, sCoder.decode(raw));
+    },
+    decodeStream(r): Record<string, any> {
+      const decoded = RLP.decodeStream(r);
+      if (!Array.isArray(decoded)) throw new Error('txStruct: expected array from inner coder');
+      const length = decoded.length;
+      if (length !== reql && length !== optl)
+        throw new Error(`txStruct: wrong inner length=${length}`);
+      const sCoder = length === optl ? allS : reqS;
+      if (length === optl && optf.every((_, i) => isEmpty(decoded[optFieldAt(i)])))
+        throw new Error('all optional fields empty');
+      // @ts-ignore TODO: fix type (there can be null in RLP)
+      return sCoder.encode(decoded);
+    },
+  });
+
+  fcoder.fields = reqf;
+  fcoder.optionalFields = optf;
+  fcoder.setOfAllFields = new Set(allFields.concat(['type'] as any));
+  return fcoder;
+};
+
+// prettier-ignore
+const legacyInternal: FieldCoder<OptFields<{
+  nonce: bigint;
+  gasPrice: bigint;
+  gasLimit: bigint;
+  to: string;
+  value: bigint;
+  data: string;
+}, {
+  r: bigint;
+  s: bigint;
+  v: bigint;
+}>> = txStruct([
+  'nonce', 'gasPrice', 'gasLimit', 'to', 'value', 'data'] as const,
+  ['v', 'r', 's'] as const);
+
+type LegacyInternal = P.UnwrapCoder<typeof legacyInternal>;
+type Legacy = Omit<LegacyInternal, 'v'> & { chainId?: bigint; yParity?: number };
+
+const legacy = (() => {
+  const res = P.apply(legacyInternal, {
+    decode: (data: Legacy) => Object.assign({}, data, legacySig.decode(data)),
+    encode: (data: LegacyInternal) => {
+      const res = Object.assign({}, data);
+      (res as any).chainId = undefined;
+      if (data.v) {
+        const newV = legacySig.encode(data);
+        removeSig(res);
+        Object.assign(res, newV);
+      }
+      return res as Legacy;
+    },
+  }) as FieldCoder<Legacy>;
+  res.fields = legacyInternal.fields.concat(['chainId'] as const);
+  // v, r, s -> yParity, r, s
+  // TODO: what about chainId?
+  res.optionalFields = ['yParity', 'r', 's'];
+  res.setOfAllFields = new Set(res.fields.concat(res.optionalFields, ['type'] as any));
+  return res;
+})();
+
+// prettier-ignore
+const eip2930 = txStruct([
+  'chainId', 'nonce', 'gasPrice', 'gasLimit', 'to', 'value', 'data', 'accessList'] as const,
+  ['yParity', 'r', 's'] as const);
+
+// prettier-ignore
+const eip1559 = txStruct([
+  'chainId', 'nonce', 'maxPriorityFeePerGas', 'maxFeePerGas', 'gasLimit', 'to', 'value', 'data', 'accessList'] as const,
+  ['yParity', 'r', 's'] as const);
+// prettier-ignore
+const eip4844 = txStruct([
+  'chainId', 'nonce', 'maxPriorityFeePerGas', 'maxFeePerGas', 'gasLimit', 'to', 'value', 'data', 'accessList',
+  'maxFeePerBlobGas', 'blobVersionedHashes'] as const,
+  ['yParity', 'r', 's'] as const);
+// prettier-ignore
+const eip7702 = txStruct([
+  'chainId', 'nonce', 'maxPriorityFeePerGas', 'maxFeePerGas', 'gasLimit', 'to', 'value', 'data', 'accessList',
+  'authorizationList'] as const,
+  ['yParity', 'r', 's'] as const);
+
+export const TxVersions = {
+  legacy, // 0x00 (kinda)
+  eip2930, // 0x01
+  eip1559, // 0x02
+  eip4844, // 0x03
+  eip7702, // 0x04
+};
+
+export const RawTx = P.apply(createTxMap(TxVersions), {
+  // NOTE: we apply checksum to addresses here, since chainId is not available inside coders
+  // By construction 'to' field is decoded before anything about chainId is known
+  encode: (data) => {
+    data.data.to = addr.addChecksum(data.data.to, true);
+    if (data.type !== 'legacy' && data.data.accessList) {
+      for (const item of data.data.accessList) {
+        item.address = addr.addChecksum(item.address);
+      }
+    }
+    if (data.type === 'eip7702' && data.data.authorizationList) {
+      for (const item of data.data.authorizationList) {
+        item.address = addr.addChecksum(item.address);
+      }
+    }
+    return data;
+  },
+  // Nothing to check here, is validated in validator
+  decode: (data) => data,
+});
+
+/**
+ * Unchecked TX for debugging. Returns raw Uint8Array-s.
+ * Handles versions - plain RLP will crash on it.
+ */
+export const RlpTx: P.CoderType<{
+  type: string;
+  data: import('./rlp.js').RLPInput;
+}> = createTxMap(Object.fromEntries(Object.keys(TxVersions).map((k) => [k, RLP])));
+
+// Field-related utils
+export type TxType = keyof typeof TxVersions;
+
+// prettier-ignore
+// Basically all numbers. Can be useful if we decide to do converter from hex here
+// const knownFieldsNoLeading0 = [
+//   'nonce', 'maxPriorityFeePerGas', 'maxFeePerGas', 'gasLimit', 'value', 'yParity', 'r', 's'
+// ] as const;
+
+function abig(val: bigint) {
+  if (typeof val !== 'bigint') throw new Error('value must be bigint');
+}
+function aobj(val: Record<string, any>) {
+  if (typeof val !== 'object' || val == null) throw new Error('object expected');
+}
+function minmax(val: bigint, min: bigint, max: bigint, err?: string): void;
+function minmax(val: number, min: number, max: number, err?: string): void;
+function minmax(
+  val: number | bigint,
+  min: number | bigint,
+  max: number | bigint,
+  err?: string
+): void {
+  if (!err) err = `>= ${min} and <= ${max}`;
+  if (Number.isNaN(val) || val < min || val > max) throw new Error(`must be ${err}, not ${val}`);
+}
+
+// strict=true validates if human-entered value in UI is "sort of" valid
+// for some new TX. For example, it's unlikely that the nonce would be 14 million.
+// strict=false validates if machine-entered value, or something historical is valid.
+
+type ValidationOpts = { strict: boolean; type: TxType; data: Record<string, any> };
+// NOTE: non-strict validators can be removed (RawTx will handle that), but errors will be less user-friendly.
+// On other hand, we twice per sig because tx is immutable
+// data passed for composite checks (gasLimit * maxFeePerGas overflow and stuff) [not implemented yet]
+const validators: Record<string, (num: any, { strict, type, data }: ValidationOpts) => void> = {
+  nonce(num: bigint, { strict }: ValidationOpts) {
+    abig(num);
+    if (strict) minmax(num, _0n, amounts.maxNonce);
+    else minmax(BigInt(num), _0n, BigInt(Number.MAX_SAFE_INTEGER)); // amounts.maxUint64
+  },
+  maxFeePerGas(num: bigint, { strict }: ValidationOpts) {
+    abig(num);
+    if (strict) minmax(num, BigInt(1), amounts.maxGasPrice, '>= 1 wei and < 10000 gwei');
+    else minmax(num, _0n, amounts.maxUint64);
+  },
+  maxPriorityFeePerGas(num: bigint, { strict, data }: ValidationOpts) {
+    abig(num);
+    if (strict) minmax(num, _0n, amounts.maxGasPrice, '>= 1 wei and < 10000 gwei');
+    else minmax(num, _0n, amounts.maxUint64, '>= 1 wei and < 10000 gwei');
+    if (strict && data && typeof data.maxFeePerGas === 'bigint' && data.maxFeePerGas < num) {
+      throw new Error(`cannot be bigger than maxFeePerGas=${data.maxFeePerGas}`);
+    }
+  },
+  gasLimit(num: bigint, { strict }: ValidationOpts) {
+    abig(num);
+    if (strict) minmax(num, amounts.minGasLimit, amounts.maxGasLimit);
+    else minmax(num, _0n, amounts.maxUint64);
+  },
+  to(address: string, { strict, data }: ValidationOpts) {
+    if (!addr.isValid(address, true)) throw new Error('address checksum does not match');
+    if (strict && address === '0x' && !data.data)
+      throw new Error('Empty address (0x) without contract deployment code');
+  },
+  value(num: bigint, { strict }: ValidationOpts) {
+    abig(num);
+    if (strict) minmax(num, _0n, amounts.maxAmount, '>= 0 and < 1M eth');
+  },
+  data(val: string, { strict, data }: ValidationOpts) {
+    if (typeof val !== 'string') throw new Error('data must be string');
+    if (strict) {
+      if (val.length > amounts.maxDataSize) throw new Error('data is too big: ' + val.length);
+    }
+    // NOTE: data is hex here
+    if (data.to === '0x' && val.length > 2 * amounts.maxInitDataSize)
+      throw new Error(`initcode is too big: ${val.length}`);
+  },
+  chainId(num: bigint, { strict, type }: ValidationOpts) {
+    // chainId is optional for legacy transactions
+    if (type === 'legacy' && num === undefined) return;
+    abig(num);
+    if (strict) minmax(num, BigInt(1), amounts.maxChainId, '>= 1 and <= 2**32-1');
+  },
+  accessList(list: AccessList) {
+    // NOTE: we cannot handle this validation in coder, since it requires chainId to calculate correct checksum
+    for (const { address } of list) {
+      if (!addr.isValid(address)) throw new Error('address checksum does not match');
+    }
+  },
+  authorizationList(list: AuthorizationItem[], opts: ValidationOpts) {
+    for (const { address, nonce, chainId } of list) {
+      if (!addr.isValid(address)) throw new Error('address checksum does not match');
+      // chainId in authorization list can be zero (==allow any chain)
+      abig(chainId);
+      if (opts.strict) minmax(chainId, _0n, amounts.maxChainId, '>= 0 and <= 2**32-1');
+      this.nonce(nonce, opts);
+    }
+  },
+};
+
+// Validation
+type ErrObj = { field: string; error: string };
+export class AggregatedError extends Error {
+  message: string;
+  errors: ErrObj[];
+  constructor(message: string, errors: ErrObj[]) {
+    super();
+    this.message = message;
+    this.errors = errors;
+  }
+}
+
+export function validateFields(
+  type: TxType,
+  data: Record<string, any>,
+  strict = true,
+  allowSignatureFields = true
+): void {
+  aobj(data);
+  if (!TxVersions.hasOwnProperty(type)) throw new Error(`unknown tx type=${type}`);
+  const txType = TxVersions[type];
+  const dataFields = new Set(Object.keys(data));
+  const dataHas = (field: string) => dataFields.has(field);
+  function checkField(field: CoderName) {
+    if (!dataHas(field))
+      return { field, error: `field "${field}" must be present for tx type=${type}` };
+    const val = data[field];
+    try {
+      if (validators.hasOwnProperty(field)) validators[field](val, { data, strict, type });
+      if (field === 'chainId') return; // chainId is validated, but can't be decoded
+      coders[field].decode(val as never); // decoding may throw an error
+    } catch (error) {
+      // No early-return: when multiple fields have error, we should show them all.
+      return { field, error: (error as Error).message };
+    }
+    return undefined;
+  }
+  // All fields are required.
+  const reqErrs = txType.fields.map(checkField);
+  // Signature fields should be all present or all missing
+  const optErrs = txType.optionalFields.some(dataHas) ? txType.optionalFields.map(checkField) : [];
+
+  // Check if user data has unexpected fields
+  const unexpErrs = Object.keys(data).map((field) => {
+    if (!txType.setOfAllFields.has(field as any))
+      return { field, error: `unknown field "${field}" for tx type=${type}` };
+    if (!allowSignatureFields && signatureFields.has(field as any))
+      return {
+        field,
+        error: `field "${field}" is sig-related and must not be user-specified`,
+      };
+    return;
+  });
+  const errors = (reqErrs as (ErrObj | undefined)[])
+    .concat(optErrs, unexpErrs)
+    .filter((val) => val !== undefined) as ErrObj[];
+  if (errors.length > 0) throw new AggregatedError('fields had validation errors', errors);
+}
+
+// prettier-ignore
+const sortedFieldOrder = [
+  'to', 'value', 'nonce',
+  'maxFeePerGas', 'maxFeePerBlobGas', 'maxPriorityFeePerGas', 'gasPrice', 'gasLimit',
+  'accessList', 'authorizationList', 'blobVersionedHashes', 'chainId', 'data', 'type',
+  'r', 's', 'yParity', 'v'
+] as const;
+
+// TODO: remove any
+export function sortRawData(raw: TxCoder<any>): any {
+  const sortedRaw: Record<string, any> = {};
+  sortedFieldOrder
+    .filter((field) => raw.hasOwnProperty(field))
+    .forEach((field) => {
+      sortedRaw[field] = raw[field];
+    });
+  return sortedRaw;
+}
+
+export function decodeLegacyV(raw: TxCoder<any>): bigint | undefined {
+  return legacySig.decode(raw).v;
+}
+
+/** EIP-7702 Authorizations. */
+export const authorization = {
+  _getHash(req: AuthorizationRequest): Uint8Array {
+    const msg = RLP.encode(authorizationRequest.decode(req));
+    return keccak_256(concatBytes(new Uint8Array([0x05]), msg));
+  },
+  sign(req: AuthorizationRequest, privateKey: string): AuthorizationItem {
+    astr(privateKey);
+    const sig = sign(this._getHash(req), ethHex.decode(privateKey));
+    return { ...req, r: sig.r, s: sig.s, yParity: sig.recovery! };
+  },
+  getAuthority(item: AuthorizationItem): string {
+    const { r, s, yParity, ...req } = item;
+    const hash = this._getHash(req);
+    const sig = initSig({ r, s }, yParity);
+    // const point = sig.recoverPublicKey(hash);
+    const bytes = secp256k1.recoverPublicKey(sig.toBytes('recovered'), hash, { prehash: false });
+    return addr.fromPublicKey(bytes);
+  },
+};
+
+// NOTE: for tests only, don't use
+export const __tests: any = { legacySig, TxVersions };