genlayer-js 0.4.7 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 
 
+## 0.5.0 (2025-01-08)
+
+
+### Features
+
+* add customtransport to use both wallet and local private keys ([#48](https://github.com/yeagerai/genlayer-js/issues/48)) ([905a123](https://github.com/yeagerai/genlayer-js/commit/905a12358c154e6ae865773b809952c8cc9c75b9))
+
+## 0.4.8 (2024-12-18)
+
+
+### Bug Fixes
+
+* added GenVM decoder to readContract method ([#42](https://github.com/yeagerai/genlayer-js/issues/42)) ([096d36d](https://github.com/yeagerai/genlayer-js/commit/096d36de06d3f4d341f6532ddead694c1882651d))
+
 ## 0.4.7 (2024-12-03)
 
 ## 0.4.6 (2024-12-02)

package/dist/index.cjs

@@ -22,21 +22,20 @@ function accountActions(client) {
         params: [address, amount]
       });
     },
-    getCurrentNonce: async ({ address }) => {
+    getCurrentNonce: async ({ address, block = "latest" }) => {
       const addressToUse = address || _optionalChain([client, 'access', _3 => _3.account, 'optionalAccess', _4 => _4.address]);
       if (!addressToUse) {
         throw new Error("No address provided and no account is connected");
       }
       return client.request({
         method: "eth_getTransactionCount",
-        params: [addressToUse]
+        params: [addressToUse, block]
       });
     }
   };
 }
 
-// src/abi/calldata/encoder.ts
-
+// src/abi/calldata/consts.ts
 var BITS_IN_TYPE = 3;
 var TYPE_SPECIAL = 0;
 var TYPE_PINT = 1;
@@ -49,6 +48,92 @@ var SPECIAL_NULL = 0 << BITS_IN_TYPE | TYPE_SPECIAL;
 var SPECIAL_FALSE = 1 << BITS_IN_TYPE | TYPE_SPECIAL;
 var SPECIAL_TRUE = 2 << BITS_IN_TYPE | TYPE_SPECIAL;
 var SPECIAL_ADDR = 3 << BITS_IN_TYPE | TYPE_SPECIAL;
+
+// src/abi/calldata/decoder.ts
+function readULeb128(data, index) {
+  let res = 0n;
+  let accum = 0n;
+  let shouldContinue = true;
+  while (shouldContinue) {
+    const byte = data[index.i];
+    index.i++;
+    const rest = byte & 127;
+    res += BigInt(rest) * (1n << accum);
+    accum += 7n;
+    shouldContinue = byte >= 128;
+  }
+  return res;
+}
+function decodeImpl(data, index) {
+  const cur = readULeb128(data, index);
+  switch (cur) {
+    case BigInt(SPECIAL_NULL):
+      return null;
+    case BigInt(SPECIAL_TRUE):
+      return true;
+    case BigInt(SPECIAL_FALSE):
+      return false;
+    case BigInt(SPECIAL_ADDR): {
+      const res = data.slice(index.i, index.i + 20);
+      index.i += 20;
+      return new (0, _chunkYI62SDKVcjs.Address)(res);
+    }
+  }
+  const type = Number(cur & 0xffn) & (1 << BITS_IN_TYPE) - 1;
+  const rest = cur >> BigInt(BITS_IN_TYPE);
+  switch (type) {
+    case TYPE_BYTES: {
+      const ret = data.slice(index.i, index.i + Number(rest));
+      index.i += Number(rest);
+      return ret;
+    }
+    case TYPE_PINT:
+      return rest;
+    case TYPE_NINT:
+      return -1n - rest;
+    case TYPE_STR: {
+      const ret = data.slice(index.i, index.i + Number(rest));
+      index.i += Number(rest);
+      return new TextDecoder("utf-8").decode(ret);
+    }
+    case TYPE_ARR: {
+      const ret = [];
+      let elems = rest;
+      while (elems > 0) {
+        elems--;
+        ret.push(decodeImpl(data, index));
+      }
+      return ret;
+    }
+    case TYPE_MAP: {
+      const ret = /* @__PURE__ */ new Map();
+      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}`);
+  }
+}
+function decode(data) {
+  const index = { i: 0 };
+  const res = decodeImpl(data, index);
+  if (index.i !== data.length) {
+    throw new Error("some data left");
+  }
+  return res;
+}
+
+// src/abi/calldata/encoder.ts
+
+
 function reportError(msg, data) {
   throw new Error(`invalid calldata input '${data}'`);
 }
@@ -162,10 +247,7 @@ function encodeImpl(to, data) {
           to.push(c);
         }
       } else if (Object.getPrototypeOf(data) === Object.prototype) {
-        encodeMap(
-          to,
-          Object.keys(data).map((k) => [k, data[k]])
-        );
+        encodeMap(to, Object.entries(data));
       } else {
         reportError("unknown object type", data);
       }
@@ -210,28 +292,46 @@ var overrideContractActions = (client) => {
   client.readContract = async (args) => {
     const { account, address, functionName, args: params } = args;
     const encodedData = encodeAndSerialize({ method: functionName, args: params });
+    let senderAddress = _nullishCoalesce(_optionalChain([account, 'optionalAccess', _5 => _5.address]), () => ( _optionalChain([client, 'access', _6 => _6.account, 'optionalAccess', _7 => _7.address])));
     const requestParams = {
       to: address,
-      from: _nullishCoalesce(_optionalChain([account, 'optionalAccess', _5 => _5.address]), () => ( _optionalChain([client, 'access', _6 => _6.account, 'optionalAccess', _7 => _7.address]))),
+      from: senderAddress,
       data: encodedData
     };
     const result = await client.request({
       method: "eth_call",
       params: [requestParams, "latest"]
     });
-    return result;
+    if (typeof result === "string") {
+      const val = Uint8Array.from(atob(result), (c) => c.charCodeAt(0));
+      return decode(val);
+    } else {
+      return "<unknown>";
+    }
   };
   client.writeContract = async (args) => {
     const { account, address, functionName, args: params, value = 0n, leaderOnly = false } = args;
     const data = [encode({ method: functionName, args: params }), leaderOnly];
     const serializedData = serialize(data);
     const senderAccount = account || client.account;
+    if (_optionalChain([senderAccount, 'optionalAccess', _8 => _8.type]) !== "local") {
+      const transaction = {
+        from: _optionalChain([senderAccount, 'optionalAccess', _9 => _9.address]),
+        to: address,
+        data: serializedData,
+        value: `0x${value.toString(16)}`
+      };
+      return await client.request({
+        method: "eth_sendTransaction",
+        params: [transaction]
+      });
+    }
     if (!senderAccount) {
       throw new Error(
         "No account set. Configure the client with an account or pass an account to this function."
       );
     }
-    if (!_optionalChain([senderAccount, 'optionalAccess', _8 => _8.signTransaction])) {
+    if (!_optionalChain([senderAccount, 'optionalAccess', _10 => _10.signTransaction])) {
       throw new Error("Account does not support signTransaction");
     }
     const nonce = await client.getCurrentNonce({ address: senderAccount.address });
@@ -242,23 +342,34 @@ var overrideContractActions = (client) => {
       type: "legacy",
       nonce
     });
-    const result = await client.request({
+    return await client.request({
       method: "eth_sendRawTransaction",
       params: [signedTransaction]
     });
-    return result;
   };
   client.deployContract = async (args) => {
     const { account, code, args: constructorArgs, leaderOnly = false } = args;
     const data = [code, encode({ args: constructorArgs }), leaderOnly];
     const serializedData = serialize(data);
     const senderAccount = account || client.account;
+    if (_optionalChain([senderAccount, 'optionalAccess', _11 => _11.type]) !== "local") {
+      const transaction = {
+        from: _optionalChain([senderAccount, 'optionalAccess', _12 => _12.address]),
+        to: null,
+        data: serializedData,
+        value: "0x0"
+      };
+      return await client.request({
+        method: "eth_sendTransaction",
+        params: [transaction]
+      });
+    }
     if (!senderAccount) {
       throw new Error(
         "No account set. Configure the client with an account or pass an account to this function."
       );
     }
-    if (!_optionalChain([senderAccount, 'optionalAccess', _9 => _9.signTransaction])) {
+    if (!_optionalChain([senderAccount, 'optionalAccess', _13 => _13.signTransaction])) {
       throw new Error("Account does not support signTransaction");
     }
     const nonce = await client.getCurrentNonce({ address: senderAccount.address });
@@ -267,11 +378,10 @@ var overrideContractActions = (client) => {
       type: "legacy",
       nonce
     });
-    const result = await client.request({
+    return await client.request({
       method: "eth_sendRawTransaction",
       params: [signedTransaction]
     });
-    return result;
   };
   return client;
 };
@@ -319,13 +429,48 @@ var transactionActions = (client) => ({
 var createClient = (config = { chain: _chunkIINRDYKFcjs.simulator }) => {
   const chainConfig = config.chain || _chunkIINRDYKFcjs.simulator;
   const rpcUrl = config.endpoint || chainConfig.rpcUrls.default.http[0];
+  const isAddress = typeof config.account !== "object";
+  const customTransport = {
+    async request({ method, params }) {
+      if (method.startsWith("eth_") && isAddress) {
+        try {
+          return await _optionalChain([window, 'access', _14 => _14.ethereum, 'optionalAccess', _15 => _15.request, 'call', _16 => _16({ method, params })]);
+        } catch (err) {
+          console.warn(`Error using window.ethereum for method ${method}:`, err);
+          throw err;
+        }
+      } else {
+        try {
+          const response = await fetch(rpcUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: Date.now(),
+              method,
+              params
+            })
+          });
+          const data = await response.json();
+          if (data.error) {
+            throw new Error(data.error.message);
+          }
+          return data.result;
+        } catch (err) {
+          console.error(`Error fetching ${method} from GenLayer RPC:`, err);
+          throw err;
+        }
+      }
+    }
+  };
   const baseClient = _viem.createClient.call(void 0, {
     chain: chainConfig,
-    transport: _viem.http.call(void 0, rpcUrl),
+    transport: _viem.custom.call(void 0, customTransport),
     ...config.account ? { account: config.account } : {}
   }).extend(_viem.publicActions).extend((client) => accountActions(client)).extend((client) => transactionActions(client)).extend((client) => contractActions(client));
-  const genLayerClient = overrideContractActions(baseClient);
-  return genLayerClient;
+  return overrideContractActions(baseClient);
 };
 
 // src/accounts/account.ts

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import * as viem from 'viem';
-import { Account } from 'viem';
+import { Account, Address } from 'viem';
 import { S as SimulatorChain } from './chains-BV4Glo-M.cjs';
 import { GenLayerClient } from './types/index.cjs';
 import * as abitype from 'abitype';
@@ -29,7 +29,7 @@ interface ClientConfig {
         };
     };
     endpoint?: string;
-    account?: Account;
+    account?: Account | Address;
 }
 declare const createClient: (config?: ClientConfig) => GenLayerClient<SimulatorChain>;
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as viem from 'viem';
-import { Account } from 'viem';
+import { Account, Address } from 'viem';
 import { S as SimulatorChain } from './chains-BV4Glo-M.js';
 import { GenLayerClient } from './types/index.js';
 import * as abitype from 'abitype';
@@ -29,7 +29,7 @@ interface ClientConfig {
         };
     };
     endpoint?: string;
-    account?: Account;
+    account?: Account | Address;
 }
 declare const createClient: (config?: ClientConfig) => GenLayerClient<SimulatorChain>;
 

package/dist/index.js

@@ -8,7 +8,7 @@ import {
 import "./chunk-MLKGABMK.js";
 
 // src/client/client.ts
-import { createClient as createViemClient, http, publicActions } from "viem";
+import { createClient as createViemClient, publicActions, custom } from "viem";
 
 // src/accounts/actions.ts
 function accountActions(client) {
@@ -22,21 +22,20 @@ function accountActions(client) {
         params: [address, amount]
       });
     },
-    getCurrentNonce: async ({ address }) => {
+    getCurrentNonce: async ({ address, block = "latest" }) => {
       const addressToUse = address || client.account?.address;
       if (!addressToUse) {
         throw new Error("No address provided and no account is connected");
       }
       return client.request({
         method: "eth_getTransactionCount",
-        params: [addressToUse]
+        params: [addressToUse, block]
       });
     }
   };
 }
 
-// src/abi/calldata/encoder.ts
-import { toHex, toRlp } from "viem";
+// src/abi/calldata/consts.ts
 var BITS_IN_TYPE = 3;
 var TYPE_SPECIAL = 0;
 var TYPE_PINT = 1;
@@ -49,6 +48,92 @@ var SPECIAL_NULL = 0 << BITS_IN_TYPE | TYPE_SPECIAL;
 var SPECIAL_FALSE = 1 << BITS_IN_TYPE | TYPE_SPECIAL;
 var SPECIAL_TRUE = 2 << BITS_IN_TYPE | TYPE_SPECIAL;
 var SPECIAL_ADDR = 3 << BITS_IN_TYPE | TYPE_SPECIAL;
+
+// src/abi/calldata/decoder.ts
+function readULeb128(data, index) {
+  let res = 0n;
+  let accum = 0n;
+  let shouldContinue = true;
+  while (shouldContinue) {
+    const byte = data[index.i];
+    index.i++;
+    const rest = byte & 127;
+    res += BigInt(rest) * (1n << accum);
+    accum += 7n;
+    shouldContinue = byte >= 128;
+  }
+  return res;
+}
+function decodeImpl(data, index) {
+  const cur = readULeb128(data, index);
+  switch (cur) {
+    case BigInt(SPECIAL_NULL):
+      return null;
+    case BigInt(SPECIAL_TRUE):
+      return true;
+    case BigInt(SPECIAL_FALSE):
+      return false;
+    case BigInt(SPECIAL_ADDR): {
+      const res = data.slice(index.i, index.i + 20);
+      index.i += 20;
+      return new Address(res);
+    }
+  }
+  const type = Number(cur & 0xffn) & (1 << BITS_IN_TYPE) - 1;
+  const rest = cur >> BigInt(BITS_IN_TYPE);
+  switch (type) {
+    case TYPE_BYTES: {
+      const ret = data.slice(index.i, index.i + Number(rest));
+      index.i += Number(rest);
+      return ret;
+    }
+    case TYPE_PINT:
+      return rest;
+    case TYPE_NINT:
+      return -1n - rest;
+    case TYPE_STR: {
+      const ret = data.slice(index.i, index.i + Number(rest));
+      index.i += Number(rest);
+      return new TextDecoder("utf-8").decode(ret);
+    }
+    case TYPE_ARR: {
+      const ret = [];
+      let elems = rest;
+      while (elems > 0) {
+        elems--;
+        ret.push(decodeImpl(data, index));
+      }
+      return ret;
+    }
+    case TYPE_MAP: {
+      const ret = /* @__PURE__ */ new Map();
+      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}`);
+  }
+}
+function decode(data) {
+  const index = { i: 0 };
+  const res = decodeImpl(data, index);
+  if (index.i !== data.length) {
+    throw new Error("some data left");
+  }
+  return res;
+}
+
+// src/abi/calldata/encoder.ts
+import { toHex } from "viem";
+import { toRlp } from "viem";
 function reportError(msg, data) {
   throw new Error(`invalid calldata input '${data}'`);
 }
@@ -162,10 +247,7 @@ function encodeImpl(to, data) {
           to.push(c);
         }
       } else if (Object.getPrototypeOf(data) === Object.prototype) {
-        encodeMap(
-          to,
-          Object.keys(data).map((k) => [k, data[k]])
-        );
+        encodeMap(to, Object.entries(data));
       } else {
         reportError("unknown object type", data);
       }
@@ -210,22 +292,40 @@ var overrideContractActions = (client) => {
   client.readContract = async (args) => {
     const { account, address, functionName, args: params } = args;
     const encodedData = encodeAndSerialize({ method: functionName, args: params });
+    let senderAddress = account?.address ?? client.account?.address;
     const requestParams = {
       to: address,
-      from: account?.address ?? client.account?.address,
+      from: senderAddress,
       data: encodedData
     };
     const result = await client.request({
       method: "eth_call",
       params: [requestParams, "latest"]
     });
-    return result;
+    if (typeof result === "string") {
+      const val = Uint8Array.from(atob(result), (c) => c.charCodeAt(0));
+      return decode(val);
+    } else {
+      return "<unknown>";
+    }
   };
   client.writeContract = async (args) => {
     const { account, address, functionName, args: params, value = 0n, leaderOnly = false } = args;
     const data = [encode({ method: functionName, args: params }), leaderOnly];
     const serializedData = serialize(data);
     const senderAccount = account || client.account;
+    if (senderAccount?.type !== "local") {
+      const transaction = {
+        from: senderAccount?.address,
+        to: address,
+        data: serializedData,
+        value: `0x${value.toString(16)}`
+      };
+      return await client.request({
+        method: "eth_sendTransaction",
+        params: [transaction]
+      });
+    }
     if (!senderAccount) {
       throw new Error(
         "No account set. Configure the client with an account or pass an account to this function."
@@ -242,17 +342,28 @@ var overrideContractActions = (client) => {
       type: "legacy",
       nonce
     });
-    const result = await client.request({
+    return await client.request({
       method: "eth_sendRawTransaction",
       params: [signedTransaction]
     });
-    return result;
   };
   client.deployContract = async (args) => {
     const { account, code, args: constructorArgs, leaderOnly = false } = args;
     const data = [code, encode({ args: constructorArgs }), leaderOnly];
     const serializedData = serialize(data);
     const senderAccount = account || client.account;
+    if (senderAccount?.type !== "local") {
+      const transaction = {
+        from: senderAccount?.address,
+        to: null,
+        data: serializedData,
+        value: "0x0"
+      };
+      return await client.request({
+        method: "eth_sendTransaction",
+        params: [transaction]
+      });
+    }
     if (!senderAccount) {
       throw new Error(
         "No account set. Configure the client with an account or pass an account to this function."
@@ -267,11 +378,10 @@ var overrideContractActions = (client) => {
       type: "legacy",
       nonce
     });
-    const result = await client.request({
+    return await client.request({
       method: "eth_sendRawTransaction",
       params: [signedTransaction]
     });
-    return result;
   };
   return client;
 };
@@ -319,13 +429,48 @@ var transactionActions = (client) => ({
 var createClient = (config = { chain: simulator }) => {
   const chainConfig = config.chain || simulator;
   const rpcUrl = config.endpoint || chainConfig.rpcUrls.default.http[0];
+  const isAddress = typeof config.account !== "object";
+  const customTransport = {
+    async request({ method, params }) {
+      if (method.startsWith("eth_") && isAddress) {
+        try {
+          return await window.ethereum?.request({ method, params });
+        } catch (err) {
+          console.warn(`Error using window.ethereum for method ${method}:`, err);
+          throw err;
+        }
+      } else {
+        try {
+          const response = await fetch(rpcUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: Date.now(),
+              method,
+              params
+            })
+          });
+          const data = await response.json();
+          if (data.error) {
+            throw new Error(data.error.message);
+          }
+          return data.result;
+        } catch (err) {
+          console.error(`Error fetching ${method} from GenLayer RPC:`, err);
+          throw err;
+        }
+      }
+    }
+  };
   const baseClient = createViemClient({
     chain: chainConfig,
-    transport: http(rpcUrl),
+    transport: custom(customTransport),
     ...config.account ? { account: config.account } : {}
   }).extend(publicActions).extend((client) => accountActions(client)).extend((client) => transactionActions(client)).extend((client) => contractActions(client));
-  const genLayerClient = overrideContractActions(baseClient);
-  return genLayerClient;
+  return overrideContractActions(baseClient);
 };
 
 // src/accounts/account.ts

package/dist/types/index.d.cts

@@ -118,7 +118,7 @@ type GenLayerMethod = {
     params: [address: string, filter?: "all" | "from" | "to"];
 } | {
     method: "eth_getTransactionCount";
-    params: [address: string];
+    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"] & {

package/dist/types/index.d.ts

@@ -118,7 +118,7 @@ type GenLayerMethod = {
     params: [address: string, filter?: "all" | "from" | "to"];
 } | {
     method: "eth_getTransactionCount";
-    params: [address: string];
+    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"] & {

package/package.json

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

package/src/abi/calldata/consts.ts

@@ -0,0 +1,14 @@
+export const BITS_IN_TYPE = 3;
+
+export const TYPE_SPECIAL = 0;
+export const TYPE_PINT = 1;
+export const TYPE_NINT = 2;
+export const TYPE_BYTES = 3;
+export const TYPE_STR = 4;
+export const TYPE_ARR = 5;
+export const TYPE_MAP = 6;
+
+export const SPECIAL_NULL = (0 << BITS_IN_TYPE) | TYPE_SPECIAL;
+export const SPECIAL_FALSE = (1 << BITS_IN_TYPE) | TYPE_SPECIAL;
+export const SPECIAL_TRUE = (2 << BITS_IN_TYPE) | TYPE_SPECIAL;
+export const SPECIAL_ADDR = (3 << BITS_IN_TYPE) | TYPE_SPECIAL;

package/src/abi/calldata/decoder.ts

@@ -0,0 +1,86 @@
+import type {CalldataEncodable} from "../../types/calldata";
+import {Address} 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 Address(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,21 +1,8 @@
-import {toHex, toRlp} from "viem";
+import {toHex} from "viem";
+import {toRlp} from "viem";
 import type {CalldataEncodable, TransactionDataElement} from "../../types/calldata";
 import {Address} from "../../types/calldata";
-
-const BITS_IN_TYPE = 3;
-
-const TYPE_SPECIAL = 0;
-const TYPE_PINT = 1;
-const TYPE_NINT = 2;
-const TYPE_BYTES = 3;
-const TYPE_STR = 4;
-const TYPE_ARR = 5;
-const TYPE_MAP = 6;
-
-const SPECIAL_NULL = (0 << BITS_IN_TYPE) | TYPE_SPECIAL;
-const SPECIAL_FALSE = (1 << BITS_IN_TYPE) | TYPE_SPECIAL;
-const SPECIAL_TRUE = (2 << BITS_IN_TYPE) | TYPE_SPECIAL;
-const SPECIAL_ADDR = (3 << BITS_IN_TYPE) | TYPE_SPECIAL;
+import * as consts from "./consts";
 
 function reportError(msg: string, data: CalldataEncodable): never {
   throw new Error(`invalid calldata input '${data}'`);
@@ -37,15 +24,15 @@ function writeNum(to: number[], data: bigint) {
 }
 
 function encodeNumWithType(to: number[], data: bigint, type: number) {
-  const res = (data << BigInt(BITS_IN_TYPE)) | BigInt(type);
+  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, TYPE_PINT);
+    encodeNumWithType(to, data, consts.TYPE_PINT);
   } else {
-    encodeNumWithType(to, -data - 1n, TYPE_NINT);
+    encodeNumWithType(to, -data - 1n, consts.TYPE_NINT);
   }
 }
 
@@ -76,7 +63,7 @@ function encodeMap(to: number[], arr: Iterable<[string, CalldataEncodable]>) {
     }
   }
 
-  encodeNumWithType(to, BigInt(newEntries.length), TYPE_MAP);
+  encodeNumWithType(to, BigInt(newEntries.length), consts.TYPE_MAP);
   for (const [, k, v] of newEntries) {
     writeNum(to, BigInt(k.length));
     for (const c of k) {
@@ -88,15 +75,15 @@ function encodeMap(to: number[], arr: Iterable<[string, CalldataEncodable]>) {
 
 function encodeImpl(to: number[], data: CalldataEncodable) {
   if (data === null || data === undefined) {
-    to.push(SPECIAL_NULL);
+    to.push(consts.SPECIAL_NULL);
     return;
   }
   if (data === true) {
-    to.push(SPECIAL_TRUE);
+    to.push(consts.SPECIAL_TRUE);
     return;
   }
   if (data === false) {
-    to.push(SPECIAL_FALSE);
+    to.push(consts.SPECIAL_FALSE);
     return;
   }
   switch (typeof data) {
@@ -113,7 +100,7 @@ function encodeImpl(to: number[], data: CalldataEncodable) {
     }
     case "string": {
       const str = new TextEncoder().encode(data);
-      encodeNumWithType(to, BigInt(str.length), TYPE_STR);
+      encodeNumWithType(to, BigInt(str.length), consts.TYPE_STR);
       for (const c of str) {
         to.push(c);
       }
@@ -121,27 +108,24 @@ function encodeImpl(to: number[], data: CalldataEncodable) {
     }
     case "object": {
       if (data instanceof Uint8Array) {
-        encodeNumWithType(to, BigInt(data.length), TYPE_BYTES);
+        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), TYPE_ARR);
+        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 Address) {
-        to.push(SPECIAL_ADDR);
+        to.push(consts.SPECIAL_ADDR);
         for (const c of data.bytes) {
           to.push(c);
         }
       } else if (Object.getPrototypeOf(data) === Object.prototype) {
-        encodeMap(
-          to,
-          Object.keys(data).map((k): [string, CalldataEncodable] => [k, data[k]]),
-        );
+        encodeMap(to, Object.entries(data));
       } else {
         reportError("unknown object type", data);
       }
@@ -159,6 +143,83 @@ export function encode(data: CalldataEncodable): Uint8Array {
   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)));
 }

package/src/accounts/actions.ts

@@ -13,16 +13,15 @@ export function accountActions(client: GenLayerClient<SimulatorChain>) {
         params: [address, amount],
       }) as Promise<TransactionHash>;
     },
-    getCurrentNonce: async ({address}: {address: string}): Promise<number> => {
+    getCurrentNonce: async ({address, block = 'latest'}: {address: string, block?: string}): Promise<number> => {
       const addressToUse = address || client.account?.address;
 
       if (!addressToUse) {
         throw new Error("No address provided and no account is connected");
       }
-
       return client.request({
         method: "eth_getTransactionCount",
-        params: [addressToUse],
+        params: [addressToUse, block],
       }) as Promise<number>;
     },
   };

package/src/client/client.ts

@@ -1,4 +1,4 @@
-import {Account, createClient as createViemClient, http, publicActions} from "viem";
+import {Account, createClient as createViemClient, publicActions, custom, Address} from "viem";
 import {simulator} from "../chains/simulator";
 import {accountActions} from "../accounts/actions";
 import {contractActions, overrideContractActions} from "../contracts/actions";
@@ -10,24 +10,62 @@ interface ClientConfig {
   chain?: {
     id: number;
     name: string;
-    rpcUrls: {default: {http: readonly string[]}};
-    nativeCurrency: {name: string; symbol: string; decimals: number};
-    blockExplorers?: {default: {name: string; url: string}};
+    rpcUrls: { default: { http: readonly string[] } };
+    nativeCurrency: { name: string; symbol: string; decimals: number };
+    blockExplorers?: { default: { name: string; url: string } };
   };
-  endpoint?: string; // Optional: Custom RPC endpoint override
-  account?: Account;
+  endpoint?: string; // Custom RPC endpoint
+  account?: Account | Address;
 }
 
-// Extend Viem client to work with GenLayer-specific chains (simulator, testnet, etc.)
-export const createClient = (config: ClientConfig = {chain: simulator}) => {
-  // Determine the RPC URL based on the provided configuration or default to the simulator's RPC UR
+export const createClient = (config: ClientConfig = { chain: simulator }) => {
   const chainConfig = config.chain || simulator;
   const rpcUrl = config.endpoint || chainConfig.rpcUrls.default.http[0];
+  const isAddress = typeof config.account !== "object";
+
+  const customTransport = {
+      async request({method, params}: {method: string; params: any[]}) {
+        if (method.startsWith('eth_') && isAddress) {
+          try {
+            return await window.ethereum?.request({method, params});
+          } catch (err) {
+            console.warn(`Error using window.ethereum for method ${method}:`, err);
+            throw err;
+          }
+        } else {
+          try {
+            const response = await fetch(rpcUrl, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: Date.now(),
+                method,
+                params,
+              }),
+            });
+
+            const data = await response.json();
+
+            if (data.error) {
+              throw new Error(data.error.message);
+            }
+
+            return data.result;
+          } catch (err) {
+            console.error(`Error fetching ${method} from GenLayer RPC:`, err);
+            throw err;
+          }
+        }
+      },
+    }
+
 
-  // Create a Viem client connected to the GenLayer Simulator (or custom chain)
   const baseClient = createViemClient({
     chain: chainConfig,
-    transport: http(rpcUrl),
+    transport: custom(customTransport),
     ...(config.account ? {account: config.account} : {}),
   })
     .extend(publicActions)
@@ -35,7 +73,7 @@ export const createClient = (config: ClientConfig = {chain: simulator}) => {
     .extend(client => transactionActions(client as unknown as GenLayerClient<SimulatorChain>))
     .extend(client => contractActions(client as unknown as GenLayerClient<SimulatorChain>));
 
-  const genLayerClient = overrideContractActions(baseClient as unknown as GenLayerClient<SimulatorChain>);
+  return overrideContractActions(baseClient as unknown as GenLayerClient<SimulatorChain>);
 
-  return genLayerClient;
 };
+

package/src/contracts/actions.ts

@@ -1,3 +1,4 @@
+import {decode} from "@/abi/calldata/decoder";
 import {encode, serialize, encodeAndSerialize} from "@/abi/calldata/encoder";
 import {Account, ContractSchema, SimulatorChain, GenLayerClient, CalldataEncodable, Address} from "@/types";
 
@@ -27,21 +28,30 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     functionName: string;
     args: CalldataEncodable[];
   }): Promise<unknown> => {
-    const {account, address, functionName, args: params} = args;
-    const encodedData = encodeAndSerialize({method: functionName, args: params});
+    const { account, address, functionName, args: params } = args;
+    const encodedData = encodeAndSerialize({ method: functionName, args: params });
+
+    let senderAddress = account?.address ?? client.account?.address;
 
     const requestParams = {
       to: address,
-      from: account?.address ?? client.account?.address,
+      from: senderAddress,
       data: encodedData,
     };
     const result = await client.request({
       method: "eth_call",
       params: [requestParams, "latest"],
     });
-    return result;
+
+    if (typeof result === "string") {
+      const val = Uint8Array.from(atob(result), c => c.charCodeAt(0));
+      return decode(val);
+    } else {
+      return "<unknown>";
+    }
   };
 
+
   client.writeContract = async (args: {
     account?: Account;
     address: Address;
@@ -50,14 +60,30 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     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: params, value = 0n, leaderOnly = false } = args;
+    const data = [encode({ method: functionName, args: params }), leaderOnly];
     const serializedData = serialize(data);
-
     const senderAccount = account || client.account;
+
+
+    if (senderAccount?.type !== "local") {
+
+      const transaction = {
+        from: senderAccount?.address,
+        to: address,
+        data: serializedData,
+        value: `0x${value.toString(16)}`,
+      };
+
+      return await client.request({
+        method: "eth_sendTransaction",
+        params: [transaction as any],
+      });
+    }
+
     if (!senderAccount) {
       throw new Error(
-        "No account set. Configure the client with an account or pass an account to this function.",
+          "No account set. Configure the client with an account or pass an account to this function."
       );
     }
 
@@ -65,7 +91,7 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
       throw new Error("Account does not support signTransaction");
     }
 
-    const nonce = await client.getCurrentNonce({address: senderAccount.address});
+    const nonce = await client.getCurrentNonce({ address: senderAccount.address });
 
     const signedTransaction = await senderAccount.signTransaction({
       data: serializedData,
@@ -74,11 +100,11 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
       type: "legacy",
       nonce,
     });
-    const result = await client.request({
+
+    return await client.request({
       method: "eth_sendRawTransaction",
       params: [signedTransaction],
     });
-    return result;
   };
 
   client.deployContract = async (args: {
@@ -87,14 +113,29 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     args: CalldataEncodable[];
     leaderOnly?: boolean;
   }) => {
-    const {account, code, args: constructorArgs, leaderOnly = false} = args;
-    const data = [code, encode({args: constructorArgs}), leaderOnly];
+    const { account, code, args: constructorArgs, leaderOnly = false } = args;
+    const data = [code, encode({ args: constructorArgs }), leaderOnly];
     const serializedData = serialize(data);
-
     const senderAccount = account || client.account;
+
+    if (senderAccount?.type !== "local") {
+
+      const transaction = {
+        from: senderAccount?.address,
+        to: null,
+        data: serializedData,
+        value: "0x0",
+      };
+
+      return  await client.request({
+        method: "eth_sendTransaction",
+        params: [transaction as any],
+      });
+    }
+
     if (!senderAccount) {
       throw new Error(
-        "No account set. Configure the client with an account or pass an account to this function.",
+          "No account set. Configure the client with an account or pass an account to this function."
       );
     }
 
@@ -102,7 +143,7 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
       throw new Error("Account does not support signTransaction");
     }
 
-    const nonce = await client.getCurrentNonce({address: senderAccount.address});
+    const nonce = await client.getCurrentNonce({ address: senderAccount.address });
 
     const signedTransaction = await senderAccount.signTransaction({
       data: serializedData,
@@ -110,11 +151,10 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
       nonce,
     });
 
-    const result = await client.request({
+    return  await client.request({
       method: "eth_sendRawTransaction",
       params: [signedTransaction],
     });
-    return result;
   };
 
   return client;

package/src/global.d.ts

@@ -0,0 +1,7 @@
+// global.d.ts
+interface Window {
+  ethereum?: {
+    isMetaMask?: boolean;
+    request: (args: { method: string; params?: unknown[] }) => Promise<unknown>;
+  };
+}

package/src/types/clients.ts

@@ -13,7 +13,7 @@ export type GenLayerMethod =
   | {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]};
+  | {method: "eth_getTransactionCount"; params: [address: string, block: string]};
 
 /*
   Take all the properties from PublicActions<Transport, TSimulatorChain>

package/tests/client.test.ts

@@ -18,7 +18,7 @@ describe("Client Overrides", () => {
     const account = createAccount(generatePrivateKey());
     const client = createClient({
       chain: simulator,
-      account,
+      account: account,
     });
 
     // Mock the client.request method
@@ -76,4 +76,34 @@ describe("Client Overrides", () => {
       ],
     });
   });
+  it("should override client account if address is provided", async () => {
+    const account = '0x65e03a3e916CF1dC92d3C8E8186a89CfAB0D2bc2';
+    const client = createClient({
+      chain: simulator,
+      account,
+    });
+
+    // Mock the client.request method
+    vi.spyOn(client, "request").mockResolvedValue(undefined);
+
+    const contractAddress = "0x1234567890123456789012345678901234567890";
+    await client.readContract({
+      address: contractAddress as Address,
+      functionName: "testFunction",
+      args: ["arg1", "arg2"],
+    });
+
+    expect(client.request).toHaveBeenCalledWith({
+      method: "eth_call",
+      params: [
+        {
+          to: contractAddress,
+          from: account,
+          data: expect.any(String),
+        },
+        "latest",
+      ],
+    });
+  });
+
 });

package/tsconfig.json

@@ -115,5 +115,5 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true /* Skip type checking all .d.ts files. */
   },
-  "include": ["src/**/*", "tests/**/*"]
+  "include": ["src/**/*", "tests/**/*", "src/global.d.ts"]
 }