genlayer-js 0.6.0 → 0.6.2

package/dist/types/index.d.ts

@@ -1,166 +1,3 @@
-import { S as SimulatorChain } from '../chains-BV4Glo-M.js';
-import { Client, Transport, PublicActions, Account } from 'viem';
+export { A as Address, a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, G as GenLayerClient, b as GenLayerMethod, j as GenLayerTransaction, M as MethodDescription, k as TransactionDataElement, h as TransactionHash, i as TransactionStatus } from '../index-B1ZR98OZ.js';
+export { S as SimulatorChain } from '../chains-BV4Glo-M.js';
 export { Account } from 'viem';
-
-type Address$1 = `0x${string}` & {
-    length: 42;
-};
-
-declare class Address {
-    bytes: Uint8Array;
-    constructor(addr: Uint8Array);
-}
-type CalldataEncodable = null | boolean | Address | number | bigint | string | Uint8Array | Array<CalldataEncodable> | Map<string, CalldataEncodable> | {
-    [key: string]: CalldataEncodable;
-};
-type MethodDescription = {
-    method: string;
-    args: Array<CalldataEncodable>;
-};
-type TransactionData = {
-    method: string;
-    args: CalldataEncodable[];
-};
-
-type TransactionHash = `0x${string}` & {
-    length: 66;
-};
-declare enum TransactionStatus {
-    PENDING = "PENDING",
-    CANCELED = "CANCELED",
-    PROPOSING = "PROPOSING",
-    COMMITTING = "COMMITTING",
-    REVEALING = "REVEALING",
-    ACCEPTED = "ACCEPTED",
-    FINALIZED = "FINALIZED",
-    UNDETERMINED = "UNDETERMINED"
-}
-type GenLayerTransaction = {
-    hash: TransactionHash;
-    status: TransactionStatus;
-    from_address?: string;
-    to_address?: string;
-    data?: Record<string, unknown>;
-    consensus_data?: {
-        final: boolean;
-        leader_receipt?: {
-            calldata: string;
-            class_name: string;
-            contract_state: string;
-            eq_outputs: Record<string, unknown>;
-            error: string | null;
-            execution_result: string;
-            gas_used: number;
-            mode: string;
-            node_config: Record<string, unknown>;
-            pending_transactions: unknown[];
-            vote: string;
-        };
-        validators?: Record<string, unknown>[];
-        votes?: Record<string, string>;
-    };
-    nonce?: number;
-    value?: number;
-    type?: number;
-    gaslimit?: bigint;
-    created_at?: Date;
-    r?: number;
-    s?: number;
-    v?: number;
-};
-type TransactionDataElement = string | number | bigint | boolean | Uint8Array;
-
-type ContractParamsArraySchemaElement = ContractParamsSchema | {
-    $rep: ContractParamsSchema;
-};
-type ContractParamsSchema = "null" | "bool" | "int" | "address" | "string" | "bytes" | "any" | "array" | "dict" | {
-    $or: ContractParamsSchema[];
-} | {
-    $dict: ContractParamsSchema;
-} | {
-    [key: string]: ContractParamsSchema;
-} | ContractParamsArraySchemaElement[];
-interface ContractMethodBase {
-    params: [string, ContractParamsSchema][];
-    kwparams: {
-        [key: string]: ContractParamsSchema;
-    };
-}
-interface ContractMethod extends ContractMethodBase {
-    ret: ContractParamsSchema;
-    readonly: boolean;
-}
-type ContractSchema = {
-    ctor: ContractMethodBase;
-    methods: ContractMethod[];
-};
-
-type GenLayerMethod = {
-    method: "sim_fundAccount";
-    params: [address: string, amount: number];
-} | {
-    method: "eth_getTransactionByHash";
-    params: [hash: TransactionHash];
-} | {
-    method: "eth_call";
-    params: [requestParams: any, blockNumberOrHash: string];
-} | {
-    method: "eth_sedRawTransaction";
-    params: [signedTransaction: string];
-} | {
-    method: "gen_getContractSchema";
-    params: [address: string];
-} | {
-    method: "gen_getContractSchemaForCode";
-    params: [contractCode: string];
-} | {
-    method: "sim_getTransactionsForAddress";
-    params: [address: string, filter?: "all" | "from" | "to"];
-} | {
-    method: "eth_getTransactionCount";
-    params: [address: string, block: string];
-};
-type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transport, TSimulatorChain>, "transport" | "getTransaction" | "readContract"> & Omit<PublicActions<Transport, TSimulatorChain>, "readContract" | "getTransaction" | "waitForTransactionReceipt"> & {
-    request: Client<Transport, TSimulatorChain>["request"] & {
-        <TMethod extends GenLayerMethod>(args: Extract<GenLayerMethod, {
-            method: TMethod["method"];
-        }>): Promise<unknown>;
-    };
-    readContract: (args: {
-        account?: Account;
-        address: Address$1;
-        functionName: string;
-        args: CalldataEncodable[];
-        stateStatus?: TransactionStatus;
-    }) => Promise<unknown>;
-    writeContract: (args: {
-        account?: Account;
-        address: Address$1;
-        functionName: string;
-        args: CalldataEncodable[];
-        value: bigint;
-        leaderOnly?: boolean;
-    }) => Promise<any>;
-    deployContract: (args: {
-        account?: Account;
-        code: string;
-        args: CalldataEncodable[];
-        leaderOnly?: boolean;
-    }) => Promise<`0x${string}`>;
-    getTransaction: (args: {
-        hash: TransactionHash;
-    }) => Promise<GenLayerTransaction>;
-    getCurrentNonce: (args: {
-        address: string;
-    }) => Promise<number>;
-    waitForTransactionReceipt: (args: {
-        hash: TransactionHash;
-        status?: TransactionStatus;
-        interval?: number;
-        retries?: number;
-    }) => Promise<GenLayerTransaction>;
-    getContractSchema: (address: string) => Promise<ContractSchema>;
-    getContractSchemaForCode: (contractCode: string) => Promise<ContractSchema>;
-};
-
-export { type Address$1 as Address, type CalldataEncodable, type ContractMethod, type ContractMethodBase, type ContractParamsArraySchemaElement, type ContractParamsSchema, type ContractSchema, type GenLayerClient, type GenLayerMethod, type GenLayerTransaction, type MethodDescription, SimulatorChain, type TransactionData, type TransactionDataElement, type TransactionHash, TransactionStatus };

package/dist/types/index.js

@@ -1,7 +1,9 @@
 import {
+  CalldataAddress,
   TransactionStatus
-} from "../chunk-G7EQ6KPE.js";
+} from "../chunk-2EJVFGKU.js";
 import "../chunk-MLKGABMK.js";
 export {
+  CalldataAddress,
   TransactionStatus
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "genlayer-js",
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "GenLayer JavaScript SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/renovate.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": ["config:recommended", "group:recommended", "group:allNonMajor", "group:githubArtifactActions"],
+  "packageRules": [
+    {
+      "matchUpdateTypes": ["minor", "patch", "pin", "digest"],
+      "automerge": true
+    }
+  ],
+  "vulnerabilityAlerts": {
+    "enabled": true
+  },
+  "osvVulnerabilityAlerts": true,
+  "dependencyDashboard": true,
+  "npm": {
+    "minimumReleaseAge": "3 days"
+  },
+  "reviewers": ["denishacquin", "epsjunior", "cristiam86"],
+  "baseBranches": ["staging"]
+}

package/src/abi/calldata/decoder.ts

@@ -1,5 +1,5 @@
 import type {CalldataEncodable} from "../../types/calldata";
-import {Address} from "../../types/calldata";
+import {CalldataAddress} from "../../types/calldata";
 import * as consts from "./consts";
 
 function readULeb128(data: Uint8Array, index: {i: number}): bigint {
@@ -29,7 +29,7 @@ function decodeImpl(data: Uint8Array, index: {i: number}): CalldataEncodable {
     case BigInt(consts.SPECIAL_ADDR): {
       const res = data.slice(index.i, index.i + 20);
       index.i += 20;
-      return new Address(res);
+      return new CalldataAddress(res);
     }
   }
   const type = Number(cur & 0xffn) & ((1 << consts.BITS_IN_TYPE) - 1);

package/src/abi/calldata/encoder.ts

@@ -1,7 +1,5 @@
-import {toHex} from "viem";
-import {toRlp} from "viem";
-import type {CalldataEncodable, TransactionDataElement} from "../../types/calldata";
-import {Address} from "../../types/calldata";
+import type {CalldataEncodable} from "../../types/calldata";
+import {CalldataAddress} from "../../types/calldata";
 import * as consts from "./consts";
 
 function reportError(msg: string, data: CalldataEncodable): never {
@@ -119,7 +117,7 @@ function encodeImpl(to: number[], data: CalldataEncodable) {
         }
       } else if (data instanceof Map) {
         encodeMap(to, data);
-      } else if (data instanceof Address) {
+      } else if (data instanceof CalldataAddress) {
         to.push(consts.SPECIAL_ADDR);
         for (const c of data.bytes) {
           to.push(c);
@@ -142,88 +140,3 @@ export function encode(data: CalldataEncodable): Uint8Array {
   encodeImpl(arr, data);
   return new Uint8Array(arr);
 }
-
-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 Address) {
-        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("");
-}
-
-export function serialize(data: TransactionDataElement[]): `0x${string}` {
-  return toRlp(data.map(param => toHex(param)));
-}
-
-export function encodeAndSerialize(data: CalldataEncodable): `0x${string}` {
-  return serialize([encode(data)]);
-}

package/src/abi/calldata/index.ts

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

package/src/abi/calldata/string.ts

@@ -0,0 +1,83 @@
+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 +1,5 @@
-export * from "./calldata/encoder";
+import * as cd from "./calldata"
+import * as tx from "./transactions"
+
+export const calldata = cd;
+export const transactions = tx;

package/src/abi/transactions.ts

@@ -0,0 +1,11 @@
+import {toHex, toRlp} from "viem";
+
+import type {TransactionDataElement} from "../types/calldata";
+
+export function serializeOne(data: TransactionDataElement): `0x${string}` {
+    return toHex(data)
+}
+
+export function serialize(data: TransactionDataElement[]): `0x${string}` {
+    return toRlp(data.map(serializeOne));
+}

package/src/contracts/actions.ts

@@ -1,5 +1,5 @@
-import {decode} from "@/abi/calldata/decoder";
-import {encode, serialize} from "@/abi/calldata/encoder";
+import * as calldata from "@/abi/calldata";
+import {serialize, serializeOne} from "@/abi/transactions";
 import {
   Account,
   ContractSchema,
@@ -9,6 +9,40 @@ import {
   Address,
   TransactionStatus,
 } from "@/types";
+import { fromHex, toHex } from "viem";
+
+function makeCalldataObject(method: string | undefined, args: CalldataEncodable[] | undefined, kwargs: {[key: string]: CalldataEncodable} | Map<string, CalldataEncodable> | undefined): CalldataEncodable {
+  // this method omits args or kwargs if they are empty
+  // it reduces transaction size
+  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
+}
 
 export const contractActions = (client: GenLayerClient<SimulatorChain>) => {
   return {
@@ -19,10 +53,10 @@ export const contractActions = (client: GenLayerClient<SimulatorChain>) => {
       })) as string;
       return schema as unknown as ContractSchema;
     },
-    getContractSchemaForCode: async (contractCode: string): Promise<ContractSchema> => {
+    getContractSchemaForCode: async (contractCode: string | Uint8Array): Promise<ContractSchema> => {
       const schema = (await client.request({
         method: "gen_getContractSchemaForCode",
-        params: [contractCode],
+        params: [toHex(contractCode)],
       })) as string;
       return schema as unknown as ContractSchema;
     },
@@ -30,16 +64,18 @@ export const contractActions = (client: GenLayerClient<SimulatorChain>) => {
 };
 
 export const overrideContractActions = (client: GenLayerClient<SimulatorChain>) => {
-  client.readContract = async (args: {
+  client.readContract = async <RawReturn extends boolean | undefined>(args: {
     account?: Account;
     address: Address;
     functionName: string;
-    args: CalldataEncodable[];
+    args?: CalldataEncodable[];
+    kwargs?: Map<string, CalldataEncodable> | { [key: string]: CalldataEncodable }
     stateStatus?: TransactionStatus;
-  }): Promise<unknown> => {
-    const {account, address, functionName, args: params, stateStatus = TransactionStatus.ACCEPTED} = args;
-    const encodedData = [encode({method: functionName, args: params}), stateStatus];
-    const serializedData = serialize(encodedData);
+    rawReturn?: RawReturn;
+  }): Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable> => {
+    const {account, address, functionName, args: callArgs, kwargs, stateStatus = TransactionStatus.ACCEPTED} = args;
+    const encodedData = calldata.encode(makeCalldataObject(functionName, callArgs, kwargs));
+    const serializedData = serializeOne(encodedData);
 
     const senderAddress = account?.address ?? client.account?.address;
 
@@ -50,27 +86,27 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     };
     const result = await client.request({
       method: "eth_call",
-      params: [requestParams, "latest"],
+      params: [requestParams, stateStatus == TransactionStatus.FINALIZED ? "finalized" : "latest"],
     });
 
-    if (typeof result === "string") {
-      const val = Uint8Array.from(atob(result), c => c.charCodeAt(0));
-      return decode(val);
-    } else {
-      return "<unknown>";
+    if (args.rawReturn) {
+      return result
     }
+    const resultBinary = fromHex(result, "bytes")
+    return calldata.decode(resultBinary) as any;
   };
 
   client.writeContract = async (args: {
     account?: Account;
     address: Address;
     functionName: string;
-    args: CalldataEncodable[];
+    args?: CalldataEncodable[];
+    kwargs?: Map<string, CalldataEncodable> | { [key: string]: CalldataEncodable }
     value: bigint;
     leaderOnly?: boolean;
   }): Promise<`0x${string}`> => {
-    const {account, address, functionName, args: params, value = 0n, leaderOnly = false} = args;
-    const data = [encode({method: functionName, args: params}), leaderOnly];
+    const {account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false} = args;
+    const data = [calldata.encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
     const senderAccount = account || client.account;
 
@@ -116,12 +152,13 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
 
   client.deployContract = async (args: {
     account?: Account;
-    code: string;
-    args: CalldataEncodable[];
+    code: string | Uint8Array;
+    args?: CalldataEncodable[];
+    kwargs?: Map<string, CalldataEncodable> | { [key: string]: CalldataEncodable }
     leaderOnly?: boolean;
   }) => {
-    const {account, code, args: constructorArgs, leaderOnly = false} = args;
-    const data = [code, encode({args: constructorArgs}), leaderOnly];
+    const {account, code, args: constructorArgs, kwargs, leaderOnly = false} = args;
+    const data = [code, calldata.encode(makeCalldataObject(undefined, constructorArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
     const senderAccount = account || client.account;
 

package/src/index.ts

@@ -2,3 +2,4 @@
 export {createClient} from "./client/client";
 export {createAccount, generatePrivateKey} from "./accounts/account";
 export * as chains from "./chains";
+export * as abi from "./abi";

package/src/types/calldata.ts

@@ -1,8 +1,8 @@
-export class Address {
+export class CalldataAddress {
   bytes: Uint8Array;
 
   constructor(addr: Uint8Array) {
-    if (addr.length != 32) {
+    if (addr.length != 20) {
       throw new Error(`invalid address length ${addr}`);
     }
 
@@ -13,7 +13,7 @@ export class Address {
 export type CalldataEncodable =
   | null
   | boolean
-  | Address
+  | CalldataAddress
   | number
   | bigint
   | string
@@ -28,10 +28,4 @@ export type MethodDescription = {
   args: Array<CalldataEncodable>;
 };
 
-export type TransactionData = {
-  method: string;
-
-  args: CalldataEncodable[];
-};
-
 export type TransactionDataElement = string | number | bigint | boolean | Uint8Array;

package/src/types/clients.ts

@@ -9,7 +9,7 @@ export type GenLayerMethod =
   | {method: "sim_fundAccount"; params: [address: string, amount: number]}
   | {method: "eth_getTransactionByHash"; params: [hash: TransactionHash]}
   | {method: "eth_call"; params: [requestParams: any, blockNumberOrHash: string]}
-  | {method: "eth_sedRawTransaction"; params: [signedTransaction: string]}
+  | {method: "eth_sendRawTransaction"; params: [signedTransaction: string]}
   | {method: "gen_getContractSchema"; params: [address: string]}
   | {method: "gen_getContractSchemaForCode"; params: [contractCode: string]}
   | {method: "sim_getTransactionsForAddress"; params: [address: string, filter?: "all" | "from" | "to"]}
@@ -34,25 +34,29 @@ export type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<
         args: Extract<GenLayerMethod, {method: TMethod["method"]}>,
       ): Promise<unknown>;
     };
-    readContract: (args: {
+    readContract: <RawReturn extends boolean | undefined>(args: {
       account?: Account;
       address: Address;
       functionName: string;
-      args: CalldataEncodable[];
       stateStatus?: TransactionStatus;
-    }) => Promise<unknown>;
+      args?: CalldataEncodable[];
+      kwargs?: Map<string, CalldataEncodable> | { [key: string]: CalldataEncodable };
+      rawReturn?: RawReturn;
+    }) => Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable>;
     writeContract: (args: {
       account?: Account;
       address: Address;
       functionName: string;
-      args: CalldataEncodable[];
+      args?: CalldataEncodable[];
+      kwargs?: Map<string, CalldataEncodable> | { [key: string]: CalldataEncodable };
       value: bigint;
       leaderOnly?: boolean;
     }) => Promise<any>;
     deployContract: (args: {
       account?: Account;
-      code: string;
-      args: CalldataEncodable[];
+      code: string | Uint8Array;
+      args?: CalldataEncodable[];
+      kwargs?: Map<string, CalldataEncodable> | { [key: string]: CalldataEncodable };
       leaderOnly?: boolean;
     }) => Promise<`0x${string}`>;
     getTransaction: (args: {hash: TransactionHash}) => Promise<GenLayerTransaction>;
@@ -64,5 +68,5 @@ export type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<
       retries?: number;
     }) => Promise<GenLayerTransaction>;
     getContractSchema: (address: string) => Promise<ContractSchema>;
-    getContractSchemaForCode: (contractCode: string) => Promise<ContractSchema>;
+    getContractSchemaForCode: (contractCode: string | Uint8Array) => Promise<ContractSchema>;
   };

package/src/types/index.ts

@@ -1,5 +1,5 @@
 export * from "./accounts";
-export {CalldataEncodable, MethodDescription, TransactionData} from "./calldata";
+export {CalldataEncodable, MethodDescription, CalldataAddress} from "./calldata";
 export * from "./chains";
 export * from "./clients";
 export * from "./contracts";