genlayer-js 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 
 
+## 0.2.0 (2024-10-17)
+
+
+### Features
+
+* implement genvm calldata ([#14](https://github.com/yeagerai/genlayer-js/issues/14)) ([d9a1abd](https://github.com/yeagerai/genlayer-js/commit/d9a1abdfb5eef13e5c77433db546953369087e04))
+
+## 0.1.2 (2024-10-03)
+
 ## 0.1.1 (2024-10-03)
 
 ## 0.1.0 (2024-10-01)

package/README.md

@@ -85,7 +85,7 @@ _* under development_
 
 ## 📖 Documentation
 
-For detailed information on how to use GenLayerJS SDK, please refer to our [documentation](https://docs.genlayer.io/).
+For detailed information on how to use GenLayerJS SDK, please refer to our [documentation](https://docs.genlayer.com/).
 
 
 
@@ -95,4 +95,4 @@ We welcome contributions to GenLayerJS SDK! Whether it's new features, improved
 
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/{chunk-VQTD5PMI.js → chunk-M7SA3INM.js}

@@ -1,3 +1,14 @@
+// src/types/calldata.ts
+var Address = class {
+  bytes;
+  constructor(addr) {
+    if (addr.length != 32) {
+      throw new Error(`invalid address length ${addr}`);
+    }
+    this.bytes = addr;
+  }
+};
+
 // src/types/transactions.ts
 var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
   TransactionStatus2["PENDING"] = "PENDING";
@@ -12,5 +23,6 @@ var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
 })(TransactionStatus || {});
 
 export {
+  Address,
   TransactionStatus
 };

package/dist/{chunk-AR7OM4HI.cjs → chunk-YI62SDKV.cjs}

@@ -1,4 +1,15 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/types/transactions.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/types/calldata.ts
+var Address = class {
+  
+  constructor(addr) {
+    if (addr.length != 32) {
+      throw new Error(`invalid address length ${addr}`);
+    }
+    this.bytes = addr;
+  }
+};
+
+// src/types/transactions.ts
 var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
   TransactionStatus2["PENDING"] = "PENDING";
   TransactionStatus2["CANCELED"] = "CANCELED";
@@ -13,4 +24,5 @@ var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
 
 
 
-exports.TransactionStatus = TransactionStatus;
+
+exports.Address = Address; exports.TransactionStatus = TransactionStatus;

package/dist/{clients-CL75M8Ma.d.cts → clients-B1y56AIF.d.cts}

@@ -34,6 +34,7 @@ type GenLayerTransaction = {
     s?: number;
     v?: number;
 };
+type TransactionDataElement = string | number | bigint | boolean | Uint8Array;
 
 type GenLayerMethod = {
     method: "sim_fundAccount";
@@ -53,6 +54,9 @@ type GenLayerMethod = {
 } | {
     method: "gen_getContractSchemaForCode";
     params: [contractCode: string];
+} | {
+    method: "eth_getTransactionCount";
+    params: [address: string];
 };
 type GenLayerClient<TTransport extends Transport, TSimulatorChain extends SimulatorChain, TAccount extends Account> = Client<TTransport, TSimulatorChain, TAccount> & {
     request: Client<TTransport, TSimulatorChain, TAccount>["request"] & {
@@ -76,6 +80,9 @@ type GenLayerClient<TTransport extends Transport, TSimulatorChain extends Simula
     getTransaction: (args: {
         hash: TransactionHash;
     }) => Promise<GenLayerTransaction>;
+    getCurrentNonce: (args: {
+        address: string;
+    }) => Promise<number>;
 };
 
-export { type Address as A, type GenLayerClient as G, type TransactionHash as T, type GenLayerMethod as a, TransactionStatus as b, type GenLayerTransaction as c };
+export { type Address as A, type GenLayerClient as G, type TransactionHash as T, type GenLayerMethod as a, TransactionStatus as b, type GenLayerTransaction as c, type TransactionDataElement as d };

package/dist/{clients-Bt_8fb_v.d.ts → clients-C-WgCMQF.d.ts}

@@ -34,6 +34,7 @@ type GenLayerTransaction = {
     s?: number;
     v?: number;
 };
+type TransactionDataElement = string | number | bigint | boolean | Uint8Array;
 
 type GenLayerMethod = {
     method: "sim_fundAccount";
@@ -53,6 +54,9 @@ type GenLayerMethod = {
 } | {
     method: "gen_getContractSchemaForCode";
     params: [contractCode: string];
+} | {
+    method: "eth_getTransactionCount";
+    params: [address: string];
 };
 type GenLayerClient<TTransport extends Transport, TSimulatorChain extends SimulatorChain, TAccount extends Account> = Client<TTransport, TSimulatorChain, TAccount> & {
     request: Client<TTransport, TSimulatorChain, TAccount>["request"] & {
@@ -76,6 +80,9 @@ type GenLayerClient<TTransport extends Transport, TSimulatorChain extends Simula
     getTransaction: (args: {
         hash: TransactionHash;
     }) => Promise<GenLayerTransaction>;
+    getCurrentNonce: (args: {
+        address: string;
+    }) => Promise<number>;
 };
 
-export { type Address as A, type GenLayerClient as G, type TransactionHash as T, type GenLayerMethod as a, TransactionStatus as b, type GenLayerTransaction as c };
+export { type Address as A, type GenLayerClient as G, type TransactionHash as T, type GenLayerMethod as a, TransactionStatus as b, type GenLayerTransaction as c, type TransactionDataElement as d };

package/dist/index.cjs

@@ -2,7 +2,9 @@
 
 
 var _chunkBAGFDCQEcjs = require('./chunk-BAGFDCQE.cjs');
-require('./chunk-AR7OM4HI.cjs');
+
+
+var _chunkYI62SDKVcjs = require('./chunk-YI62SDKV.cjs');
 require('./chunk-75ZPJI57.cjs');
 
 // src/client/client.ts
@@ -19,12 +21,164 @@ function accountActions(client) {
         method: "sim_fundAccount",
         params: [address, amount]
       });
+    },
+    getCurrentNonce: async ({ address }) => {
+      return client.request({
+        method: "eth_getTransactionCount",
+        params: [address || _optionalChain([client, 'access', _3 => _3.account, 'optionalAccess', _4 => _4.address])]
+      });
     }
   };
 }
 
-// src/contracts/actions.ts
+// src/abi/calldata/encoder.ts
+
+var BITS_IN_TYPE = 3;
+var TYPE_SPECIAL = 0;
+var TYPE_PINT = 1;
+var TYPE_NINT = 2;
+var TYPE_BYTES = 3;
+var TYPE_STR = 4;
+var TYPE_ARR = 5;
+var TYPE_MAP = 6;
+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;
+function reportError(msg, data) {
+  throw new Error(`invalid calldata input '${data}'`);
+}
+function writeNum(to, data) {
+  if (data === 0n) {
+    to.push(0);
+    return;
+  }
+  while (data > 0) {
+    let cur = Number(data & 0x7fn);
+    data >>= 7n;
+    if (data > 0) {
+      cur |= 128;
+    }
+    to.push(cur);
+  }
+}
+function encodeNumWithType(to, data, type) {
+  const res = data << BigInt(BITS_IN_TYPE) | BigInt(type);
+  writeNum(to, res);
+}
+function encodeNum(to, data) {
+  if (data >= 0n) {
+    encodeNumWithType(to, data, TYPE_PINT);
+  } else {
+    encodeNumWithType(to, -data - 1n, TYPE_NINT);
+  }
+}
+function compareString(l, r) {
+  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, arr) {
+  const newEntries = Array.from(
+    arr,
+    ([k, v]) => [
+      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), TYPE_MAP);
+  for (const [_k, k, v] of newEntries) {
+    writeNum(to, BigInt(k.length));
+    for (const c of k) {
+      to.push(c);
+    }
+    encodeImpl(to, v);
+  }
+}
+function encodeImpl(to, data) {
+  if (data === null || data === void 0) {
+    to.push(SPECIAL_NULL);
+    return;
+  }
+  if (data === true) {
+    to.push(SPECIAL_TRUE);
+    return;
+  }
+  if (data === false) {
+    to.push(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), TYPE_STR);
+      for (const c of str) {
+        to.push(c);
+      }
+      return;
+    }
+    case "object": {
+      if (data instanceof Uint8Array) {
+        encodeNumWithType(to, BigInt(data.length), TYPE_BYTES);
+        for (const c of data) {
+          to.push(c);
+        }
+      } else if (data instanceof Array) {
+        encodeNumWithType(to, BigInt(data.length), TYPE_ARR);
+        for (const c of data) {
+          encodeImpl(to, c);
+        }
+      } else if (data instanceof Map) {
+        encodeMap(to, data);
+      } else if (data instanceof _chunkYI62SDKVcjs.Address) {
+        to.push(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) => [k, data[k]])
+        );
+      } else {
+        reportError("unknown object type", data);
+      }
+      return;
+    }
+    default:
+      reportError("unknown base type", data);
+  }
+}
+function encode(data) {
+  const arr = [];
+  encodeImpl(arr, data);
+  const encodedData = new Uint8Array(arr);
+  return _viem.toRlp.call(void 0, [encodedData].map((param) => _viem.toHex.call(void 0, param)));
+}
 
+// src/contracts/actions.ts
 var contractActions = (client) => {
   return {
     getContractSchema: async (address) => {
@@ -46,12 +200,10 @@ var contractActions = (client) => {
 var overrideContractActions = (client) => {
   client.readContract = async (args) => {
     const { account, address, functionName, args: params } = args;
-    const methodParamsAsString = JSON.stringify(params);
-    const data = [functionName, methodParamsAsString];
-    const encodedData = _viem.toRlp.call(void 0, data.map((param) => _viem.toHex.call(void 0, param)));
+    const encodedData = encode({ method: functionName, args: params });
     const requestParams = {
       to: address,
-      from: _optionalChain([account, 'optionalAccess', _3 => _3.address]) || _optionalChain([client, 'access', _4 => _4.account, 'optionalAccess', _5 => _5.address]),
+      from: _optionalChain([account, 'optionalAccess', _5 => _5.address]) || _optionalChain([client, 'access', _6 => _6.account, 'optionalAccess', _7 => _7.address]),
       data: encodedData
     };
     const result = await client.request({
@@ -62,23 +214,23 @@ var overrideContractActions = (client) => {
   };
   client.writeContract = async (args) => {
     const { account, address, functionName, args: params, value = 0n } = args;
-    const methodParamsAsString = JSON.stringify(params);
-    const data = [functionName, methodParamsAsString];
-    const encodedData = _viem.toRlp.call(void 0, data.map((param) => _viem.toHex.call(void 0, param)));
+    const encodedData = encode({ method: functionName, args: params });
     const senderAccount = account || client.account;
     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', _6 => _6.signTransaction])) {
+    if (!_optionalChain([senderAccount, 'optionalAccess', _8 => _8.signTransaction])) {
       throw new Error("Account does not support signTransaction");
     }
+    const nonce = await client.getCurrentNonce({ address: senderAccount.address });
     const signedTransaction = await senderAccount.signTransaction({
       data: encodedData,
       to: address,
       value,
-      type: "legacy"
+      type: "legacy",
+      nonce
     });
     const result = await client.request({
       method: "eth_sendRawTransaction",

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Transport, Account } from 'viem';
 import { S as SimulatorChain } from './chains-CtZJFz4Q.cjs';
-import { G as GenLayerClient } from './clients-CL75M8Ma.cjs';
+import { G as GenLayerClient } from './clients-B1y56AIF.cjs';
 import * as abitype from 'abitype';
 import * as viem__types_experimental_eip7702_types_authorization from 'viem/_types/experimental/eip7702/types/authorization';
 import * as viem_accounts from 'viem/accounts';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Transport, Account } from 'viem';
 import { S as SimulatorChain } from './chains-CtZJFz4Q.js';
-import { G as GenLayerClient } from './clients-Bt_8fb_v.js';
+import { G as GenLayerClient } from './clients-C-WgCMQF.js';
 import * as abitype from 'abitype';
 import * as viem__types_experimental_eip7702_types_authorization from 'viem/_types/experimental/eip7702/types/authorization';
 import * as viem_accounts from 'viem/accounts';

package/dist/index.js

@@ -2,7 +2,9 @@ import {
   chains_exports,
   simulator
 } from "./chunk-D7VZGQ4K.js";
-import "./chunk-VQTD5PMI.js";
+import {
+  Address
+} from "./chunk-M7SA3INM.js";
 import "./chunk-MLKGABMK.js";
 
 // src/client/client.ts
@@ -19,12 +21,164 @@ function accountActions(client) {
         method: "sim_fundAccount",
         params: [address, amount]
       });
+    },
+    getCurrentNonce: async ({ address }) => {
+      return client.request({
+        method: "eth_getTransactionCount",
+        params: [address || client.account?.address]
+      });
     }
   };
 }
 
+// src/abi/calldata/encoder.ts
+import { toHex, toRlp } from "viem";
+var BITS_IN_TYPE = 3;
+var TYPE_SPECIAL = 0;
+var TYPE_PINT = 1;
+var TYPE_NINT = 2;
+var TYPE_BYTES = 3;
+var TYPE_STR = 4;
+var TYPE_ARR = 5;
+var TYPE_MAP = 6;
+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;
+function reportError(msg, data) {
+  throw new Error(`invalid calldata input '${data}'`);
+}
+function writeNum(to, data) {
+  if (data === 0n) {
+    to.push(0);
+    return;
+  }
+  while (data > 0) {
+    let cur = Number(data & 0x7fn);
+    data >>= 7n;
+    if (data > 0) {
+      cur |= 128;
+    }
+    to.push(cur);
+  }
+}
+function encodeNumWithType(to, data, type) {
+  const res = data << BigInt(BITS_IN_TYPE) | BigInt(type);
+  writeNum(to, res);
+}
+function encodeNum(to, data) {
+  if (data >= 0n) {
+    encodeNumWithType(to, data, TYPE_PINT);
+  } else {
+    encodeNumWithType(to, -data - 1n, TYPE_NINT);
+  }
+}
+function compareString(l, r) {
+  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, arr) {
+  const newEntries = Array.from(
+    arr,
+    ([k, v]) => [
+      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), TYPE_MAP);
+  for (const [_k, k, v] of newEntries) {
+    writeNum(to, BigInt(k.length));
+    for (const c of k) {
+      to.push(c);
+    }
+    encodeImpl(to, v);
+  }
+}
+function encodeImpl(to, data) {
+  if (data === null || data === void 0) {
+    to.push(SPECIAL_NULL);
+    return;
+  }
+  if (data === true) {
+    to.push(SPECIAL_TRUE);
+    return;
+  }
+  if (data === false) {
+    to.push(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), TYPE_STR);
+      for (const c of str) {
+        to.push(c);
+      }
+      return;
+    }
+    case "object": {
+      if (data instanceof Uint8Array) {
+        encodeNumWithType(to, BigInt(data.length), TYPE_BYTES);
+        for (const c of data) {
+          to.push(c);
+        }
+      } else if (data instanceof Array) {
+        encodeNumWithType(to, BigInt(data.length), 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);
+        for (const c of data.bytes) {
+          to.push(c);
+        }
+      } else if (Object.getPrototypeOf(data) === Object.prototype) {
+        encodeMap(
+          to,
+          Object.keys(data).map((k) => [k, data[k]])
+        );
+      } else {
+        reportError("unknown object type", data);
+      }
+      return;
+    }
+    default:
+      reportError("unknown base type", data);
+  }
+}
+function encode(data) {
+  const arr = [];
+  encodeImpl(arr, data);
+  const encodedData = new Uint8Array(arr);
+  return toRlp([encodedData].map((param) => toHex(param)));
+}
+
 // src/contracts/actions.ts
-import { toRlp, toHex } from "viem";
 var contractActions = (client) => {
   return {
     getContractSchema: async (address) => {
@@ -46,9 +200,7 @@ var contractActions = (client) => {
 var overrideContractActions = (client) => {
   client.readContract = async (args) => {
     const { account, address, functionName, args: params } = args;
-    const methodParamsAsString = JSON.stringify(params);
-    const data = [functionName, methodParamsAsString];
-    const encodedData = toRlp(data.map((param) => toHex(param)));
+    const encodedData = encode({ method: functionName, args: params });
     const requestParams = {
       to: address,
       from: account?.address || client.account?.address,
@@ -62,9 +214,7 @@ var overrideContractActions = (client) => {
   };
   client.writeContract = async (args) => {
     const { account, address, functionName, args: params, value = 0n } = args;
-    const methodParamsAsString = JSON.stringify(params);
-    const data = [functionName, methodParamsAsString];
-    const encodedData = toRlp(data.map((param) => toHex(param)));
+    const encodedData = encode({ method: functionName, args: params });
     const senderAccount = account || client.account;
     if (!senderAccount) {
       throw new Error(
@@ -74,11 +224,13 @@ var overrideContractActions = (client) => {
     if (!senderAccount?.signTransaction) {
       throw new Error("Account does not support signTransaction");
     }
+    const nonce = await client.getCurrentNonce({ address: senderAccount.address });
     const signedTransaction = await senderAccount.signTransaction({
       data: encodedData,
       to: address,
       value,
-      type: "legacy"
+      type: "legacy",
+      nonce
     });
     const result = await client.request({
       method: "eth_sendRawTransaction",

package/dist/types/index.cjs

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkAR7OM4HIcjs = require('../chunk-AR7OM4HI.cjs');
+var _chunkYI62SDKVcjs = require('../chunk-YI62SDKV.cjs');
 require('../chunk-75ZPJI57.cjs');
 
 // src/types/accounts.ts
@@ -8,4 +8,4 @@ var _viem = require('viem');
 
 
 
-exports.Account = _viem.Account; exports.TransactionStatus = _chunkAR7OM4HIcjs.TransactionStatus;
+exports.Account = _viem.Account; exports.TransactionStatus = _chunkYI62SDKVcjs.TransactionStatus;

package/dist/types/index.d.cts

@@ -1,7 +1,23 @@
-export { A as Address, G as GenLayerClient, a as GenLayerMethod, c as GenLayerTransaction, T as TransactionHash, b as TransactionStatus } from '../clients-CL75M8Ma.cjs';
+export { A as Address, G as GenLayerClient, a as GenLayerMethod, c as GenLayerTransaction, d as TransactionDataElement, T as TransactionHash, b as TransactionStatus } from '../clients-B1y56AIF.cjs';
 export { S as SimulatorChain } from '../chains-CtZJFz4Q.cjs';
 export { Account } from 'viem';
 
+declare class Address {
+    bytes: Uint8Array;
+    constructor(addr: Uint8Array);
+}
+type CalldataEncodable = null | boolean | Address | number | bigint | string | Uint8Array | Address | Array<CalldataEncodable> | Map<string, CalldataEncodable> | {
+    [key: string]: CalldataEncodable;
+};
+type MethodDescription = {
+    method: string;
+    args: Array<CalldataEncodable>;
+};
+type TransactionData = {
+    method: string;
+    args: CalldataEncodable[];
+};
+
 type ContractSchema = {
     abi: Array<{
         inputs?: Array<{
@@ -18,4 +34,4 @@ type ContractSchema = {
     class: string;
 };
 
-export type { ContractSchema };
+export type { CalldataEncodable, ContractSchema, MethodDescription, TransactionData };

package/dist/types/index.d.ts

@@ -1,7 +1,23 @@
-export { A as Address, G as GenLayerClient, a as GenLayerMethod, c as GenLayerTransaction, T as TransactionHash, b as TransactionStatus } from '../clients-Bt_8fb_v.js';
+export { A as Address, G as GenLayerClient, a as GenLayerMethod, c as GenLayerTransaction, d as TransactionDataElement, T as TransactionHash, b as TransactionStatus } from '../clients-C-WgCMQF.js';
 export { S as SimulatorChain } from '../chains-CtZJFz4Q.js';
 export { Account } from 'viem';
 
+declare class Address {
+    bytes: Uint8Array;
+    constructor(addr: Uint8Array);
+}
+type CalldataEncodable = null | boolean | Address | number | bigint | string | Uint8Array | Address | Array<CalldataEncodable> | Map<string, CalldataEncodable> | {
+    [key: string]: CalldataEncodable;
+};
+type MethodDescription = {
+    method: string;
+    args: Array<CalldataEncodable>;
+};
+type TransactionData = {
+    method: string;
+    args: CalldataEncodable[];
+};
+
 type ContractSchema = {
     abi: Array<{
         inputs?: Array<{
@@ -18,4 +34,4 @@ type ContractSchema = {
     class: string;
 };
 
-export type { ContractSchema };
+export type { CalldataEncodable, ContractSchema, MethodDescription, TransactionData };

package/dist/types/index.js

@@ -1,6 +1,6 @@
 import {
   TransactionStatus
-} from "../chunk-VQTD5PMI.js";
+} from "../chunk-M7SA3INM.js";
 import "../chunk-MLKGABMK.js";
 
 // src/types/accounts.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "genlayer-js",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "GenLayer JavaScript SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,6 +49,7 @@
   },
   "dependencies": {
     "eslint-plugin-import": "^2.30.0",
+    "typescript-parsec": "^0.3.4",
     "viem": "^2.21.7"
   }
 }

package/src/abi/calldata/encoder.ts

@@ -0,0 +1,161 @@
+import {toHex, toRlp} from "viem";
+import type {CalldataEncodable} 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;
+
+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(BITS_IN_TYPE)) | BigInt(type);
+  writeNum(to, res);
+}
+
+function encodeNum(to: number[], data: bigint) {
+  if (data >= 0n) {
+    encodeNumWithType(to, data, TYPE_PINT);
+  } else {
+    encodeNumWithType(to, -data - 1n, 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), TYPE_MAP);
+  for (const [_k, 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(SPECIAL_NULL);
+    return;
+  }
+  if (data === true) {
+    to.push(SPECIAL_TRUE);
+    return;
+  }
+  if (data === false) {
+    to.push(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), TYPE_STR);
+      for (const c of str) {
+        to.push(c);
+      }
+      return;
+    }
+    case "object": {
+      if (data instanceof Uint8Array) {
+        encodeNumWithType(to, BigInt(data.length), TYPE_BYTES);
+        for (const c of data) {
+          to.push(c);
+        }
+      } else if (data instanceof Array) {
+        encodeNumWithType(to, BigInt(data.length), 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);
+        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]]),
+        );
+      } else {
+        reportError("unknown object type", data);
+      }
+      return;
+    }
+    default:
+      reportError("unknown base type", data);
+  }
+}
+
+export function encode(data: CalldataEncodable): `0x${string}` {
+  // FIXME: find a better growable type
+  const arr: number[] = [];
+  encodeImpl(arr, data);
+  const encodedData = new Uint8Array(arr);
+  return toRlp([encodedData].map(param => toHex(param)));
+}

package/src/abi/index.ts

@@ -0,0 +1,2 @@
+export * from "./calldata/encoder";
+export * from "./calldata/parser";

package/src/accounts/actions.ts

@@ -18,5 +18,11 @@ export function accountActions<
         params: [address, amount],
       }) as Promise<TransactionHash>;
     },
+    getCurrentNonce: async ({address}: {address: string}): Promise<number> => {
+      return client.request({
+        method: "eth_getTransactionCount",
+        params: [address || client.account?.address],
+      }) as Promise<number>;
+    },
   };
 }

package/src/contracts/actions.ts

@@ -1,7 +1,7 @@
-import {toRlp, toHex, Transport, Account, Address} from "viem";
+import {Transport, Account, Address} from "viem";
 
-import {ContractSchema, SimulatorChain, GenLayerClient} from "@/types";
-import {createAccount} from "@/accounts/account";
+import {encode} from "@/abi/calldata/encoder";
+import {ContractSchema, SimulatorChain, GenLayerClient, CalldataEncodable} from "@/types";
 
 export const contractActions = (client: GenLayerClient<Transport, SimulatorChain, Account>) => {
   return {
@@ -27,12 +27,10 @@ export const overrideContractActions = (client: GenLayerClient<Transport, Simula
     account: Account;
     address: Address;
     functionName: string;
-    args: any[];
+    args: CalldataEncodable[];
   }): Promise<any> => {
     const {account, address, functionName, args: params} = args;
-    const methodParamsAsString = JSON.stringify(params);
-    const data = [functionName, methodParamsAsString];
-    const encodedData = toRlp(data.map(param => toHex(param)));
+    const encodedData = encode({method: functionName, args: params});
 
     const requestParams = {
       to: address,
@@ -50,13 +48,11 @@ export const overrideContractActions = (client: GenLayerClient<Transport, Simula
     account: Account;
     address: Address;
     functionName: string;
-    args: any[];
+    args: CalldataEncodable[];
     value: bigint;
   }): Promise<any> => {
     const {account, address, functionName, args: params, value = 0n} = args;
-    const methodParamsAsString = JSON.stringify(params);
-    const data = [functionName, methodParamsAsString];
-    const encodedData = toRlp(data.map(param => toHex(param)));
+    const encodedData = encode({method: functionName, args: params});
 
     const senderAccount = account || client.account;
     if (!senderAccount) {
@@ -69,11 +65,14 @@ export const overrideContractActions = (client: GenLayerClient<Transport, Simula
       throw new Error("Account does not support signTransaction");
     }
 
+    const nonce = await client.getCurrentNonce({address: senderAccount.address});
+
     const signedTransaction = await senderAccount.signTransaction({
       data: encodedData,
       to: address,
       value,
       type: "legacy",
+      nonce,
     });
     const result = await client.request({
       method: "eth_sendRawTransaction",

package/src/types/calldata.ts

@@ -0,0 +1,36 @@
+export class Address {
+  bytes: Uint8Array;
+
+  constructor(addr: Uint8Array) {
+    if (addr.length != 32) {
+      throw new Error(`invalid address length ${addr}`);
+    }
+
+    this.bytes = addr;
+  }
+}
+
+export type CalldataEncodable =
+  | null
+  | boolean
+  | Address
+  | number
+  | bigint
+  | string
+  | Uint8Array /// bytes
+  | Address
+  | Array<CalldataEncodable>
+  | Map<string, CalldataEncodable>
+  | {[key: string]: CalldataEncodable}; /// also a "map"
+
+export type MethodDescription = {
+  method: string;
+
+  args: Array<CalldataEncodable>;
+};
+
+export type TransactionData = {
+  method: string;
+
+  args: CalldataEncodable[];
+};

package/src/types/clients.ts

@@ -9,7 +9,8 @@ export type GenLayerMethod =
   | {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: "gen_getContractSchemaForCode"; params: [contractCode: string]}
+  | {method: "eth_getTransactionCount"; params: [address: string]};
 
 export type GenLayerClient<
   TTransport extends Transport,
@@ -35,4 +36,5 @@ export type GenLayerClient<
     value: bigint;
   }) => Promise<any>;
   getTransaction: (args: {hash: TransactionHash}) => Promise<GenLayerTransaction>;
+  getCurrentNonce: (args: {address: string}) => Promise<number>;
 };

package/src/types/index.ts

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

package/src/types/transactions.ts

@@ -27,3 +27,5 @@ export type GenLayerTransaction = {
   s?: number;
   v?: number;
 };
+
+export type TransactionDataElement = string | number | bigint | boolean | Uint8Array;