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

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

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

@@ -1,104 +0,0 @@
-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');
-    }
-  },
-});