genlayer-js 0.1.2 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 
 
+## 0.3.0 (2024-10-25)
+
+
+### Features
+
+* add deploy contract action ([#17](https://github.com/yeagerai/genlayer-js/issues/17)) ([23d5bc2](https://github.com/yeagerai/genlayer-js/commit/23d5bc28fb58c73d64b1fd629185a0565d84cb91))
+
+## 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)

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-BamlAEcy.d.cts}

@@ -1,10 +1,26 @@
 import { Transport, Account, Client } from 'viem';
 import { S as SimulatorChain } from './chains-CtZJFz4Q.cjs';
 
-type Address = `0x${string}` & {
+type Address$1 = `0x${string}` & {
     length: 42;
 };
 
+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 TransactionHash = `0x${string}` & {
     length: 66;
 };
@@ -34,6 +50,7 @@ type GenLayerTransaction = {
     s?: number;
     v?: number;
 };
+type TransactionDataElement = string | number | bigint | boolean | Uint8Array;
 
 type GenLayerMethod = {
     method: "sim_fundAccount";
@@ -53,6 +70,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"] & {
@@ -62,20 +82,28 @@ type GenLayerClient<TTransport extends Transport, TSimulatorChain extends Simula
     };
     readContract: (args: {
         account: Account;
-        address: Address;
+        address: Address$1;
         functionName: string;
         args: any[];
     }) => Promise<any>;
     writeContract: (args: {
         account: Account;
-        address: Address;
+        address: Address$1;
         functionName: string;
         args: any[];
         value: bigint;
     }) => Promise<any>;
+    deployContract: (args: {
+        account: Account;
+        code: string;
+        args: CalldataEncodable[];
+    }) => Promise<any>;
     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$1 as A, type CalldataEncodable as C, type GenLayerClient as G, type MethodDescription as M, type TransactionData as T, type GenLayerMethod as a, type TransactionHash as b, TransactionStatus as c, type GenLayerTransaction as d, type TransactionDataElement as e };

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

@@ -1,10 +1,26 @@
 import { Transport, Account, Client } from 'viem';
 import { S as SimulatorChain } from './chains-CtZJFz4Q.js';
 
-type Address = `0x${string}` & {
+type Address$1 = `0x${string}` & {
     length: 42;
 };
 
+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 TransactionHash = `0x${string}` & {
     length: 66;
 };
@@ -34,6 +50,7 @@ type GenLayerTransaction = {
     s?: number;
     v?: number;
 };
+type TransactionDataElement = string | number | bigint | boolean | Uint8Array;
 
 type GenLayerMethod = {
     method: "sim_fundAccount";
@@ -53,6 +70,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"] & {
@@ -62,20 +82,28 @@ type GenLayerClient<TTransport extends Transport, TSimulatorChain extends Simula
     };
     readContract: (args: {
         account: Account;
-        address: Address;
+        address: Address$1;
         functionName: string;
         args: any[];
     }) => Promise<any>;
     writeContract: (args: {
         account: Account;
-        address: Address;
+        address: Address$1;
         functionName: string;
         args: any[];
         value: bigint;
     }) => Promise<any>;
+    deployContract: (args: {
+        account: Account;
+        code: string;
+        args: CalldataEncodable[];
+    }) => Promise<any>;
     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$1 as A, type CalldataEncodable as C, type GenLayerClient as G, type MethodDescription as M, type TransactionData as T, type GenLayerMethod as a, type TransactionHash as b, TransactionStatus as c, type GenLayerTransaction as d, type TransactionDataElement as e };

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,169 @@ 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);
+  return new Uint8Array(arr);
+}
+function serialize(data) {
+  return _viem.toRlp.call(void 0, data.map((param) => _viem.toHex.call(void 0, param)));
+}
+function encodeAndSerialize(data) {
+  return serialize([encode(data)]);
+}
 
+// src/contracts/actions.ts
 var contractActions = (client) => {
   return {
     getContractSchema: async (address) => {
@@ -46,12 +205,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 = encodeAndSerialize({ 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 +219,48 @@ 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 = encodeAndSerialize({ 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",
+      params: [signedTransaction]
+    });
+    return result;
+  };
+  client.deployContract = async (args) => {
+    const { account, code, args: constructorArgs } = args;
+    const data = [code, encode({ args: constructorArgs })];
+    const serializedData = serialize(data);
+    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', _9 => _9.signTransaction])) {
+      throw new Error("Account does not support signTransaction");
+    }
+    const nonce = await client.getCurrentNonce({ address: senderAccount.address });
+    const signedTransaction = await senderAccount.signTransaction({
+      data: serializedData,
+      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-BamlAEcy.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-CJ820ePR.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,169 @@ 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);
+  return new Uint8Array(arr);
+}
+function serialize(data) {
+  return toRlp(data.map((param) => toHex(param)));
+}
+function encodeAndSerialize(data) {
+  return serialize([encode(data)]);
+}
+
 // src/contracts/actions.ts
-import { toRlp, toHex } from "viem";
 var contractActions = (client) => {
   return {
     getContractSchema: async (address) => {
@@ -46,9 +205,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 = encodeAndSerialize({ method: functionName, args: params });
     const requestParams = {
       to: address,
       from: account?.address || client.account?.address,
@@ -62,9 +219,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 = encodeAndSerialize({ method: functionName, args: params });
     const senderAccount = account || client.account;
     if (!senderAccount) {
       throw new Error(
@@ -74,11 +229,38 @@ 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",
+      params: [signedTransaction]
+    });
+    return result;
+  };
+  client.deployContract = async (args) => {
+    const { account, code, args: constructorArgs } = args;
+    const data = [code, encode({ args: constructorArgs })];
+    const serializedData = serialize(data);
+    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 (!senderAccount?.signTransaction) {
+      throw new Error("Account does not support signTransaction");
+    }
+    const nonce = await client.getCurrentNonce({ address: senderAccount.address });
+    const signedTransaction = await senderAccount.signTransaction({
+      data: serializedData,
+      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,4 +1,4 @@
-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, C as CalldataEncodable, G as GenLayerClient, a as GenLayerMethod, d as GenLayerTransaction, M as MethodDescription, T as TransactionData, e as TransactionDataElement, b as TransactionHash, c as TransactionStatus } from '../clients-BamlAEcy.cjs';
 export { S as SimulatorChain } from '../chains-CtZJFz4Q.cjs';
 export { Account } from 'viem';
 

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-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, C as CalldataEncodable, G as GenLayerClient, a as GenLayerMethod, d as GenLayerTransaction, M as MethodDescription, T as TransactionData, e as TransactionDataElement, b as TransactionHash, c as TransactionStatus } from '../clients-CJ820ePR.js';
 export { S as SimulatorChain } from '../chains-CtZJFz4Q.js';
 export { Account } from 'viem';
 

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.2",
+  "version": "0.3.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,168 @@
+import {toHex, 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;
+
+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): Uint8Array {
+  // FIXME: find a better growable type
+  const arr: number[] = [];
+  encodeImpl(arr, data);
+  return new Uint8Array(arr);
+}
+
+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/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, serialize, encodeAndSerialize} 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 = encodeAndSerialize({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 = encodeAndSerialize({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",
@@ -82,5 +81,36 @@ export const overrideContractActions = (client: GenLayerClient<Transport, Simula
     return result;
   };
 
+  client.deployContract = async (args: {account: Account; code: string; args: CalldataEncodable[]}) => {
+    const {account, code, args: constructorArgs} = args;
+    const data = [code, encode({args: constructorArgs})];
+    const serializedData = serialize(data);
+
+    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 (!senderAccount?.signTransaction) {
+      throw new Error("Account does not support signTransaction");
+    }
+
+    const nonce = await client.getCurrentNonce({address: senderAccount.address});
+
+    const signedTransaction = await senderAccount.signTransaction({
+      data: serializedData,
+      type: "legacy",
+      nonce,
+    });
+
+    const result = await client.request({
+      method: "eth_sendRawTransaction",
+      params: [signedTransaction],
+    });
+    return result;
+  };
+
   return client;
 };

package/src/types/calldata.ts

@@ -0,0 +1,38 @@
+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[];
+};
+
+export type TransactionDataElement = string | number | bigint | boolean | Uint8Array;

package/src/types/clients.ts

@@ -2,6 +2,7 @@ import {Account, Transport, Client} from "viem";
 import {GenLayerTransaction, TransactionHash} from "./transactions";
 import {SimulatorChain} from "./chains";
 import {Address} from "./accounts";
+import {CalldataEncodable} from "./calldata";
 
 export type GenLayerMethod =
   | {method: "sim_fundAccount"; params: [address: string, amount: number]}
@@ -9,7 +10,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,
@@ -34,5 +36,7 @@ export type GenLayerClient<
     args: any[];
     value: bigint;
   }) => Promise<any>;
+  deployContract: (args: {account: Account; code: string; args: CalldataEncodable[]}) => 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;