genlayer-js 0.18.10 → 0.18.12

package/src/abi/calldata/decoder.ts

@@ -1,86 +0,0 @@
-import type {CalldataEncodable} from "../../types/calldata";
-import {CalldataAddress} from "../../types/calldata";
-import * as consts from "./consts";
-
-function readULeb128(data: Uint8Array, index: {i: number}): bigint {
-  let res: bigint = 0n;
-  let accum = 0n;
-  let shouldContinue = true;
-  while (shouldContinue) {
-    const byte = data[index.i];
-    index.i++;
-    const rest = byte & 0x7f;
-    res += BigInt(rest) * (1n << accum);
-    accum += 7n;
-    shouldContinue = byte >= 128;
-  }
-  return res;
-}
-
-function decodeImpl(data: Uint8Array, index: {i: number}): CalldataEncodable {
-  const cur = readULeb128(data, index);
-  switch (cur) {
-    case BigInt(consts.SPECIAL_NULL):
-      return null;
-    case BigInt(consts.SPECIAL_TRUE):
-      return true;
-    case BigInt(consts.SPECIAL_FALSE):
-      return false;
-    case BigInt(consts.SPECIAL_ADDR): {
-      const res = data.slice(index.i, index.i + 20);
-      index.i += 20;
-      return new CalldataAddress(res);
-    }
-  }
-  const type = Number(cur & 0xffn) & ((1 << consts.BITS_IN_TYPE) - 1);
-  const rest = cur >> BigInt(consts.BITS_IN_TYPE);
-  switch (type) {
-    case consts.TYPE_BYTES: {
-      const ret = data.slice(index.i, index.i + Number(rest));
-      index.i += Number(rest);
-      return ret;
-    }
-    case consts.TYPE_PINT:
-      return rest;
-    case consts.TYPE_NINT:
-      return -1n - rest;
-    case consts.TYPE_STR: {
-      const ret = data.slice(index.i, index.i + Number(rest));
-      index.i += Number(rest);
-      return new TextDecoder("utf-8").decode(ret);
-    }
-    case consts.TYPE_ARR: {
-      const ret = [] as CalldataEncodable[];
-      let elems = rest;
-      while (elems > 0) {
-        elems--;
-        ret.push(decodeImpl(data, index));
-      }
-      return ret;
-    }
-    case consts.TYPE_MAP: {
-      const ret = new Map<string, CalldataEncodable>();
-      let elems = rest;
-      while (elems > 0) {
-        elems--;
-        const strLen = Number(readULeb128(data, index));
-        const key = data.slice(index.i, index.i + strLen);
-        index.i += strLen;
-        const keyStr = new TextDecoder("utf-8").decode(key);
-        ret.set(keyStr, decodeImpl(data, index));
-      }
-      return ret;
-    }
-    default:
-      throw new Error(`can't decode type from ${type} rest is ${rest} at pos ${index.i}`);
-  }
-}
-
-export function decode(data: Uint8Array): CalldataEncodable {
-  const index = {i: 0};
-  const res = decodeImpl(data, index);
-  if (index.i !== data.length) {
-    throw new Error("some data left");
-  }
-  return res;
-}

package/src/abi/calldata/encoder.ts

@@ -1,178 +0,0 @@
-import type {CalldataEncodable} from "../../types/calldata";
-import {CalldataAddress} from "../../types/calldata";
-import * as consts from "./consts";
-
-function reportError(msg: string, data: CalldataEncodable): never {
-  throw new Error(`invalid calldata input '${data}'`);
-}
-
-function writeNum(to: number[], data: bigint) {
-  if (data === 0n) {
-    to.push(0);
-    return;
-  }
-  while (data > 0) {
-    let cur = Number(data & 0x7fn);
-    data >>= 7n;
-    if (data > 0) {
-      cur |= 0x80;
-    }
-    to.push(cur);
-  }
-}
-
-function encodeNumWithType(to: number[], data: bigint, type: number) {
-  const res = (data << BigInt(consts.BITS_IN_TYPE)) | BigInt(type);
-  writeNum(to, res);
-}
-
-function encodeNum(to: number[], data: bigint) {
-  if (data >= 0n) {
-    encodeNumWithType(to, data, consts.TYPE_PINT);
-  } else {
-    encodeNumWithType(to, -data - 1n, consts.TYPE_NINT);
-  }
-}
-
-function compareString(l: number[], r: number[]): number {
-  for (let index = 0; index < l.length && index < r.length; index++) {
-    const cur = l[index] - r[index];
-    if (cur !== 0) {
-      return cur;
-    }
-  }
-  return l.length - r.length;
-}
-
-function encodeMap(to: number[], arr: Iterable<[string, CalldataEncodable]>) {
-  // unicode code points array, utf8 encoded array, item
-  const newEntries: [number[], Uint8Array, CalldataEncodable][] = Array.from(
-    arr,
-    ([k, v]): [number[], Uint8Array, CalldataEncodable] => [
-      Array.from(k, x => x.codePointAt(0)!),
-      new TextEncoder().encode(k),
-      v,
-    ],
-  );
-  newEntries.sort((v1, v2) => compareString(v1[0], v2[0]));
-  for (let i = 1; i < newEntries.length; i++) {
-    if (compareString(newEntries[i - 1][0], newEntries[i][0]) === 0) {
-      throw new Error(`duplicate key '${new TextDecoder().decode(newEntries[i][1])}'`);
-    }
-  }
-
-  encodeNumWithType(to, BigInt(newEntries.length), consts.TYPE_MAP);
-  for (const [, k, v] of newEntries) {
-    writeNum(to, BigInt(k.length));
-    for (const c of k) {
-      to.push(c);
-    }
-    encodeImpl(to, v);
-  }
-}
-
-function encodeImpl(to: number[], data: CalldataEncodable) {
-  if (data === null || data === undefined) {
-    to.push(consts.SPECIAL_NULL);
-    return;
-  }
-  if (data === true) {
-    to.push(consts.SPECIAL_TRUE);
-    return;
-  }
-  if (data === false) {
-    to.push(consts.SPECIAL_FALSE);
-    return;
-  }
-  switch (typeof data) {
-    case "number": {
-      if (!Number.isInteger(data)) {
-        reportError("floats are not supported", data);
-      }
-      encodeNum(to, BigInt(data));
-      return;
-    }
-    case "bigint": {
-      encodeNum(to, data);
-      return;
-    }
-    case "string": {
-      const str = new TextEncoder().encode(data);
-      encodeNumWithType(to, BigInt(str.length), consts.TYPE_STR);
-      for (const c of str) {
-        to.push(c);
-      }
-      return;
-    }
-    case "object": {
-      if (data instanceof Uint8Array) {
-        encodeNumWithType(to, BigInt(data.length), consts.TYPE_BYTES);
-        for (const c of data) {
-          to.push(c);
-        }
-      } else if (data instanceof Array) {
-        encodeNumWithType(to, BigInt(data.length), consts.TYPE_ARR);
-        for (const c of data) {
-          encodeImpl(to, c);
-        }
-      } else if (data instanceof Map) {
-        encodeMap(to, data);
-      } else if (data instanceof CalldataAddress) {
-        to.push(consts.SPECIAL_ADDR);
-        for (const c of data.bytes) {
-          to.push(c);
-        }
-      } else if (Object.getPrototypeOf(data) === Object.prototype) {
-        encodeMap(to, Object.entries(data));
-      } else {
-        reportError("unknown object type", data);
-      }
-      return;
-    }
-    default:
-      reportError("unknown base type", data);
-  }
-}
-
-export function encode(data: CalldataEncodable): Uint8Array {
-  // FIXME: find a better growable type
-  const arr: number[] = [];
-  encodeImpl(arr, data);
-  return new Uint8Array(arr);
-}
-
-// Constructs a calldata object for contract calls, omitting empty args/kwargs for compactness.
-export function makeCalldataObject(
-  method: string | undefined,
-  args: CalldataEncodable[] | undefined,
-  kwargs: {[key: string]: CalldataEncodable} | Map<string, CalldataEncodable> | undefined,
-): CalldataEncodable {
-  let ret: {[key: string]: CalldataEncodable} = {};
-
-  if (method) {
-    ret["method"] = method;
-  }
-
-  if (args && args.length > 0) {
-    ret["args"] = args;
-  }
-
-  if (kwargs) {
-    if (kwargs instanceof Map) {
-      if (kwargs.size > 0) {
-        ret["kwargs"] = kwargs;
-      }
-    } else {
-      let hasVal = false;
-      for (const _k in kwargs) {
-        hasVal = true;
-        break;
-      }
-      if (hasVal) {
-        ret["kwargs"] = kwargs;
-      }
-    }
-  }
-
-  return ret;
-}

package/src/abi/calldata/index.ts

@@ -1,3 +0,0 @@
-export * from "./encoder";
-export * from "./decoder";
-export * from "./string";

package/src/abi/calldata/string.ts

@@ -1,83 +0,0 @@
-import type {CalldataEncodable} from "../../types/calldata";
-import {CalldataAddress} from "../../types/calldata";
-
-function reportError(msg: string, data: CalldataEncodable): never {
-    throw new Error(`invalid calldata input '${data}'`);
-}
-
-function toStringImplMap(data: Iterable<[string, CalldataEncodable]>, to: string[]) {
-    to.push("{");
-    for (const [k, v] of data) {
-      to.push(JSON.stringify(k));
-      to.push(":");
-      toStringImpl(v, to);
-    }
-    to.push("}");
-  }
-
-  function toStringImpl(data: CalldataEncodable, to: string[]) {
-    if (data === null || data === undefined) {
-      to.push("null");
-      return;
-    }
-    if (data === true) {
-      to.push("true");
-      return;
-    }
-    if (data === false) {
-      to.push("false");
-      return;
-    }
-    switch (typeof data) {
-      case "number": {
-        if (!Number.isInteger(data)) {
-          reportError("floats are not supported", data);
-        }
-        to.push(data.toString());
-        return;
-      }
-      case "bigint": {
-        to.push(data.toString());
-        return;
-      }
-      case "string": {
-        to.push(JSON.stringify(data));
-        return;
-      }
-      case "object": {
-        if (data instanceof Uint8Array) {
-          to.push("b#");
-          for (const b of data) {
-            to.push(b.toString(16));
-          }
-        } else if (data instanceof Array) {
-          to.push("[");
-          for (const c of data) {
-            toStringImpl(c, to);
-            to.push(",");
-          }
-          to.push("]");
-        } else if (data instanceof Map) {
-          toStringImplMap(data.entries(), to);
-        } else if (data instanceof CalldataAddress) {
-          to.push("addr#");
-          for (const c of data.bytes) {
-            to.push(c.toString(16));
-          }
-        } else if (Object.getPrototypeOf(data) === Object.prototype) {
-          toStringImplMap(Object.entries(data), to);
-        } else {
-          reportError("unknown object type", data);
-        }
-        return;
-      }
-      default:
-        reportError("unknown base type", data);
-    }
-  }
-
-  export function toString(data: CalldataEncodable): string {
-    const to: string[] = [];
-    toStringImpl(data, to);
-    return to.join("");
-  }

package/src/abi/index.ts

@@ -1,6 +0,0 @@
-import * as cd from "./calldata"
-import * as tx from "./transactions"
-
-export const calldata = cd;
-export const transactions = tx;
-export {STAKING_ABI, VALIDATOR_WALLET_ABI} from "./staking";