@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/advanced/abi-mapper.ts

@@ -0,0 +1,212 @@
+import * as P from '../../../../micro-packed/0.8.0/src/index.js';
+
+// prettier-ignore
+type IntIdxType = ''    | '8'   | '16'  | '24'  | '32'  | '40'  | '48'  | '56'  |
+  '64'  | '72'  | '80'  | '88'  | '96'  | '104' | '112' | '120' | '128' | '136' |
+  '144' | '152' | '160' | '168' | '176' | '184' | '192' | '200' | '208' | '216' |
+  '224' | '232' | '240' | '248' | '256';
+type UintType = `uint${IntIdxType}`;
+type IntType = `int${IntIdxType}`;
+type NumberType = UintType | IntType;
+// Basic type support
+// int<M>: two’s complement signed integer type of M bits, 0 < M <= 256, M % 8 == 0.
+// prettier-ignore
+// bytes<M>: binary type of M bytes, 0 < M <= 32.
+// prettier-ignore
+type ByteIdxType = '' | '1' | '2'  | '3'  | '4'  | '5'  | '6'  | '7'  | '8'  | '9'  |
+  '10' | '11' | '12' | '13' | '14' | '15' | '16' | '17' | '18' | '19' | '20' | '21' |
+  '22' | '23' | '24' | '25' | '26' | '27' | '28' | '29' | '30' | '31' | '32';
+type ByteType = `bytes${ByteIdxType}`;
+
+export type Writable<T> = T extends {}
+  ? {
+      -readonly [P in keyof T]: Writable<T[P]>;
+    }
+  : T;
+export type IsEmptyArray<T> =
+  T extends ReadonlyArray<any> ? (T['length'] extends 0 ? true : false) : true;
+export type ArrLike<T> = Array<T> | ReadonlyArray<T>;
+
+export type Component<T extends string> = {
+  readonly name?: string;
+  readonly type: T;
+};
+export type NamedComponent<T extends string> = Component<T> & { readonly name: string };
+export type BaseComponent = Component<string>;
+export type Tuple<TC extends ArrLike<Component<string>>> = {
+  readonly name?: string;
+  readonly type: 'tuple';
+  readonly components: TC;
+};
+
+// [{name: 'a', type: 'string'}, {name: 'b', type: 'uint'}] -> {a: string, b: bigint};
+export type MapTuple<T> =
+  T extends ArrLike<Component<string> & { name: string }>
+    ? {
+        [K in T[number] as K['name']]: MapType<K>;
+      }
+    : T extends ArrLike<Component<string>>
+      ? // [{name: 'a', type: 'string'}, {type: 'uint'}] -> [string, bigint];
+        {
+          [K in keyof T]: T[K] extends BaseComponent ? MapType<T[K]> : unknown;
+        }
+      : unknown;
+// prettier-ignore
+export type MapType<T extends BaseComponent> =
+  T extends Tuple<Array<Component<string>>> ? MapTuple<T['components']> :
+  T extends { readonly type: 'tuple[]'; readonly components: infer C extends Array<Component<string>> } ? MapTuple<C>[] :
+  T extends Component<infer Type> ? GetType<Type> :
+  unknown; // default
+export type UnmapType<T> = T extends MapType<infer U> ? U : never;
+// If only one arg -- use as is, otherwise construct tuple by tuple rules
+export type ArgsType<T extends ReadonlyArray<any> | undefined> =
+  IsEmptyArray<T> extends true
+    ? undefined // empty arr
+    : T extends ReadonlyArray<any>
+      ? T['length'] extends 1 // single elm
+        ? MapType<T[0]>
+        : MapTuple<T>
+      : MapTuple<T>;
+
+// prettier-ignore
+export type GetType<T extends string> =
+  T extends `${infer Base}[]${infer Rest}` ? GetType<`${Base}${Rest}`>[] : // 'string[]' -> 'string'[]
+  T extends `${infer Base}[${number}]${infer Rest}` ? GetType<`${Base}${Rest}`>[] : // 'string[3]' -> 'string'[]
+  T extends 'address' ? string :
+  T extends 'string' ? string :
+  T extends 'bool' ? boolean :
+  T extends NumberType ? bigint :
+  T extends ByteType ? Uint8Array :
+  unknown; // default
+
+export const ARRAY_RE = /(.+)(\[(\d+)?\])$/; // TODO: is this correct?
+
+function EPad<T>(p: P.CoderType<T>) {
+  return P.padLeft(32, p, P.ZeroPad);
+}
+const PTR = EPad(P.U32BE);
+const U256BE_LEN = PTR;
+
+// Main difference between regular array: length stored outside and offsets calculated without length
+function ethArray<T>(inner: P.CoderType<T>): P.CoderType<T[]> {
+  return P.wrap({
+    size: undefined,
+    encodeStream: (w: P.Writer, value: T[]) => {
+      U256BE_LEN.encodeStream(w, value.length);
+      w.bytes(P.array(value.length, inner).encode(value));
+    },
+    decodeStream: (r: P.Reader): T[] =>
+      P.array(U256BE_LEN.decodeStream(r), inner).decodeStream(r.offsetReader(r.pos)),
+  });
+}
+
+// Because u32 in eth is not real u32, just U256BE with limits...
+const ethInt = (bits: number, signed = false) => {
+  if (!Number.isSafeInteger(bits) || bits <= 0 || bits % 8 !== 0 || bits > 256)
+    throw new Error('ethInt: invalid numeric type');
+  const _bits = BigInt(bits);
+  const inner = P.bigint(32, false, signed);
+  return P.validate(
+    P.wrap({
+      size: inner.size,
+      encodeStream: (w: P.Writer, value: bigint) => inner.encodeStream(w, value),
+      decodeStream: (r: P.Reader): bigint => inner.decodeStream(r),
+    }),
+    (value) => {
+      // TODO: validate useful for narrowing types, need to add support in types?
+      if (typeof value === 'number') value = BigInt(value);
+      P.utils.checkBounds(value, _bits, !!signed);
+      return value;
+    }
+  );
+};
+
+// Ugly hack, because tuple of pointers considered "dynamic" without any reason.
+function isDyn<T>(args: P.CoderType<T>[] | Record<string, P.CoderType<T>>) {
+  let res = false;
+  if (Array.isArray(args)) {
+    for (let arg of args) if (arg.size === undefined) res = true;
+  } else {
+    for (let arg in args) if (args[arg].size === undefined) res = true;
+  }
+  return res;
+}
+
+// NOTE: we need as const if we want to access string as values inside types :(
+export function mapComponent<T extends BaseComponent>(c: T): P.CoderType<MapType<Writable<T>>> {
+  // Arrays (should be first one, since recursive)
+  let m;
+  if ((m = ARRAY_RE.exec(c.type))) {
+    const inner = mapComponent({ ...c, type: m[1] });
+    if (inner.size === 0)
+      throw new Error('mapComponent: arrays of zero-size elements disabled (possible DoS attack)');
+    // Static array
+    if (m[3] !== undefined) {
+      const m3 = Number.parseInt(m[3]);
+      if (!Number.isSafeInteger(m3)) throw new Error(`mapComponent: wrong array size=${m[3]}`);
+      let out = P.array(m3, inner);
+      // Static array of dynamic values should be behind pointer too, again without reason.
+      if (inner.size === undefined) out = P.pointer(PTR, out);
+      return out as any;
+    } else {
+      // Dynamic array
+      return P.pointer(PTR, ethArray(inner)) as any;
+    }
+  }
+  if (c.type === 'tuple') {
+    const components: (Component<string> & { name?: string })[] = (c as any).components;
+    let hasNames = true;
+    const args: P.CoderType<any>[] = [];
+    for (let comp of components) {
+      if (!comp.name) hasNames = false;
+      args.push(mapComponent(comp));
+    }
+    let out: any;
+    // If there is names for all fields -- return struct, otherwise tuple
+    if (hasNames) {
+      const struct: Record<string, P.CoderType<unknown>> = {};
+      for (const arg of components) {
+        if (struct[arg.name!]) throw new Error(`mapType: same field name=${arg.name}`);
+        struct[arg.name!] = mapComponent(arg);
+      }
+      out = P.struct(struct);
+    } else out = P.tuple(args);
+    // If tuple has dynamic elements it becomes dynamic too, without reason.
+    if (isDyn(args)) out = P.pointer(PTR, out);
+    return out;
+  }
+  if (c.type === 'string')
+    return P.pointer(PTR, P.padRight(32, P.string(U256BE_LEN), P.ZeroPad)) as any;
+  if (c.type === 'bytes')
+    return P.pointer(PTR, P.padRight(32, P.bytes(U256BE_LEN), P.ZeroPad)) as any;
+  if (c.type === 'address') return EPad(P.hex(20, { isLE: false, with0x: true })) as any;
+  if (c.type === 'bool') return EPad(P.bool) as any;
+  if ((m = /^(u?)int([0-9]+)?$/.exec(c.type)))
+    return ethInt(m[2] ? +m[2] : 256, m[1] !== 'u') as any;
+  if ((m = /^bytes([0-9]{1,2})$/.exec(c.type))) {
+    const parsed = +m[1];
+    if (!parsed || parsed > 32) throw new Error('wrong bytes<N> type');
+    return P.padRight(32, P.bytes(parsed), P.ZeroPad) as any;
+  }
+  throw new Error(`mapComponent: unknown component=${c}`);
+}
+
+// Because args and output are not tuple
+// TODO: try merge with mapComponent
+export function mapArgs<T extends ArrLike<Component<string>>>(
+  args: T
+): P.CoderType<ArgsType<Writable<T>>> {
+  // More ergonomic input/output
+  if (args.length === 1) return mapComponent(args[0] as any) as any;
+  let hasNames = true;
+  for (const arg of args) if (!arg.name) hasNames = false;
+  if (hasNames) {
+    const out: Record<string, P.CoderType<unknown>> = {};
+    for (const arg of args) {
+      const name = (arg as any).name;
+      if (out[name]) throw new Error(`mapArgs: same field name=${name}`);
+      out[name] = mapComponent(arg as any) as any;
+    }
+    return P.struct(out) as any;
+  } else return P.tuple(args.map(mapComponent)) as any;
+}

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

@@ -0,0 +1,100 @@
+/*! micro-eth-signer - MIT License (c) 2021 Paul Miller (paulmillr.com) */
+import { secp256k1 } from '../../../../../@noble/curves/2.0.1/src/secp256k1.js';
+import { keccak_256 } from '../../../../../@noble/hashes/2.0.1/src/sha3.js';
+import { bytesToHex, hexToBytes, utf8ToBytes } from '../../../../../@noble/hashes/2.0.1/src/utils.js';
+import { add0x, astr, ethHex, strip0x } from '../utils.js';
+
+export const addr = {
+  RE: /^(0[xX])?([0-9a-fA-F]{40})?$/ satisfies RegExp as RegExp,
+  parse: (
+    address: string,
+    allowEmpty = false
+  ): {
+    hasPrefix: boolean;
+    data: string;
+  } => {
+    astr(address);
+    // NOTE: empty address allowed for 'to', but would be mistake for other address fields.
+    // '0x' instead of null/undefined because we don't want to send contract creation tx if user
+    // accidentally missed 'to' field.
+    if (allowEmpty && address === '0x') return { hasPrefix: true, data: '' };
+    const res = address.match(addr.RE) || [];
+    const hasPrefix = res[1] != null;
+    const data = res[2];
+    if (!data) {
+      const len = hasPrefix ? 42 : 40;
+      throw new Error(`address must be ${len}-char hex, got ${address.length}-char ${address}`);
+    }
+    return { hasPrefix, data };
+  },
+
+  /**
+   * Address checksum is calculated by hashing with keccak_256.
+   * It hashes *string*, not a bytearray: keccak('beef') not keccak([0xbe, 0xef])
+   * @param nonChecksummedAddress
+   * @param allowEmpty - allows '0x'
+   * @returns checksummed address
+   */
+  addChecksum: (nonChecksummedAddress: string, allowEmpty = false): string => {
+    const low = addr.parse(nonChecksummedAddress, allowEmpty).data.toLowerCase();
+    const hash = bytesToHex(keccak_256(utf8ToBytes(low)));
+    let checksummed = '';
+    for (let i = 0; i < low.length; i++) {
+      const hi = Number.parseInt(hash[i], 16);
+      const li = low[i];
+      checksummed += hi <= 7 ? li : li.toUpperCase(); // if char is 9-f, upcase it
+    }
+    return add0x(checksummed);
+  },
+
+  /**
+   * Creates address from secp256k1 public key.
+   */
+  fromPublicKey: (key: string | Uint8Array): string => {
+    if (!key) throw new Error('invalid public key: ' + key);
+    if (typeof key === 'string') key = hexToBytes(strip0x(key));
+    const pub65b = secp256k1.Point.fromBytes(key).toBytes(false);
+    const hashed = keccak_256(pub65b.subarray(1, 65));
+    const address = bytesToHex(hashed).slice(24); // slice 24..64
+    return addr.addChecksum(address);
+  },
+
+  /**
+   * Creates address from ETH private key in hex or ui8a format.
+   */
+  fromSecretKey: (key: string | Uint8Array): string => {
+    if (typeof key === 'string') key = hexToBytes(strip0x(key));
+    return addr.fromPublicKey(secp256k1.getPublicKey(key, false));
+  },
+  fromPrivateKey: (key: string | Uint8Array): string => {
+    return addr.fromSecretKey(key);
+  },
+
+  /**
+   * Generates hex string with new random private key and address. Uses CSPRNG internally.
+   */
+  random(): { privateKey: string; address: string } {
+    const privateKey = ethHex.encode(secp256k1.utils.randomSecretKey());
+    return { privateKey: privateKey, address: addr.fromSecretKey(privateKey) };
+  },
+
+  /**
+   * Verifies checksum if the address is checksummed.
+   * Always returns true when the address is not checksummed.
+   * @param allowEmpty - allows '0x'
+   */
+  isValid: (checksummedAddress: string, allowEmpty = false): boolean => {
+    let parsed: { hasPrefix: boolean; data: string };
+    try {
+      parsed = addr.parse(checksummedAddress, allowEmpty);
+    } catch (error) {
+      return false;
+    }
+    const { data: address, hasPrefix } = parsed;
+    if (!hasPrefix) return false;
+    const low = address.toLowerCase();
+    const upp = address.toUpperCase();
+    if (address === low || address === upp) return true;
+    return addr.addChecksum(low, allowEmpty) === checksummedAddress;
+  },
+};

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

@@ -0,0 +1,104 @@
+import { numberToVarBytesBE } from '../../../../../@noble/curves/2.0.1/src/utils.js';
+import * as P from '../../../../micro-packed/0.8.0/src/index.js';
+import { isBytes, type Bytes } from '../utils.js';
+
+// Spec-compliant RLP in 100 lines of code.
+export type RLPInput = string | number | Bytes | bigint | RLPInput[] | null;
+// length: first 3 bit !== 111 ? 6 bit length : 3bit lenlen
+const RLPLength = P.wrap({
+  encodeStream(w: P.Writer, value: number) {
+    if (value < 56) return w.bits(value, 6);
+    w.bits(0b111, 3);
+    const length = P.U32BE.encode(value);
+    let pos = 0;
+    for (; pos < length.length; pos++) if (length[pos] !== 0) break;
+    w.bits(4 - pos - 1, 3);
+    w.bytes(length.slice(pos));
+  },
+  decodeStream(r: P.Reader): number {
+    const start = r.bits(3);
+    if (start !== 0b111) return (start << 3) | r.bits(3);
+    const len = r.bytes(r.bits(3) + 1);
+    for (let i = 0; i < len.length; i++) {
+      if (len[i]) break;
+      throw new Error('Wrong length encoding with leading zeros');
+    }
+    const res = P.int(len.length).decode(len);
+    if (res <= 55) throw new Error('RLPLength: less than 55, but used multi-byte flag');
+    return res;
+  },
+});
+
+// Recursive struct definition
+export type InternalRLP =
+  | { TAG: 'byte'; data: number }
+  | {
+      TAG: 'complex';
+      data: { TAG: 'string'; data: Uint8Array } | { TAG: 'list'; data: InternalRLP[] };
+    };
+
+const rlpInner = P.tag(P.map(P.bits(1), { byte: 0, complex: 1 }), {
+  byte: P.bits(7),
+  complex: P.tag(P.map(P.bits(1), { string: 0, list: 1 }), {
+    string: P.bytes(RLPLength),
+    list: P.prefix(
+      RLPLength,
+      P.array(
+        null,
+        P.lazy((): P.CoderType<InternalRLP> => rlpInner)
+      )
+    ),
+  }),
+});
+
+const phex = P.hex(null);
+const pstr = P.string(null);
+const empty = Uint8Array.of();
+
+/**
+ * RLP parser.
+ * Real type of rlp is `Item = Uint8Array | Item[]`.
+ * Strings/number encoded to Uint8Array, but not decoded back: type information is lost.
+ */
+export const RLP: P.CoderType<RLPInput> = P.apply(rlpInner, {
+  encode(from: InternalRLP): RLPInput {
+    if (from.TAG === 'byte') return new Uint8Array([from.data]);
+    if (from.TAG !== 'complex') throw new Error('RLP.encode: unexpected type');
+    const complex = from.data;
+    if (complex.TAG === 'string') {
+      if (complex.data.length === 1 && complex.data[0] < 128)
+        throw new Error('RLP.encode: wrong string length encoding, should use single byte mode');
+      return complex.data;
+    }
+    if (complex.TAG === 'list') return complex.data.map((i) => this.encode(i));
+    throw new Error('RLP.encode: unknown TAG');
+  },
+  decode(data: RLPInput): InternalRLP {
+    if (data == null) return this.decode(empty);
+    switch (typeof data) {
+      case 'object':
+        if (isBytes(data)) {
+          if (data.length === 1) {
+            const head = data[0];
+            if (head < 128) return { TAG: 'byte', data: head };
+          }
+          return { TAG: 'complex', data: { TAG: 'string', data: data } };
+        }
+        if (Array.isArray(data))
+          return { TAG: 'complex', data: { TAG: 'list', data: data.map((i) => this.decode(i)) } };
+        throw new Error('RLP.encode: unknown type');
+      case 'number':
+        if (data < 0) throw new Error('RLP.encode: invalid integer as argument, must be unsigned');
+        if (data === 0) return this.decode(empty);
+        return this.decode(numberToVarBytesBE(data));
+      case 'bigint':
+        if (data < BigInt(0))
+          throw new Error('RLP.encode: invalid integer as argument, must be unsigned');
+        return this.decode(numberToVarBytesBE(data));
+      case 'string':
+        return this.decode(data.startsWith('0x') ? phex.encode(data) : pstr.encode(data));
+      default:
+        throw new Error('RLP.encode: unknown type');
+    }
+  },
+});