genlayer-js 0.0.1 → 0.0.3

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+
+
+## 0.0.3 (2024-09-30)

package/README.md

@@ -1,4 +1,4 @@
-# [Your Project Name]
+# GenLayerJS
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/license/mit/)
 [![Discord](https://dcbadge.vercel.app/api/server/8Jm4v89VAu?compact=true&style=flat)](https://discord.gg/VpfmXEMN66)

package/dist/chains/index.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkBAGFDCQEcjs = require('../chunk-BAGFDCQE.cjs');
+require('../chunk-75ZPJI57.cjs');
+
+
+exports.simulator = _chunkBAGFDCQEcjs.simulator;

package/dist/chains/index.d.cts

@@ -0,0 +1,3 @@
+export { s as simulator } from '../index-DLN-2YXE.cjs';
+import '../chains-CtZJFz4Q.cjs';
+import 'viem';

package/dist/chains/index.d.ts

@@ -0,0 +1,3 @@
+export { s as simulator } from '../index-vHLY9ggt.js';
+import '../chains-CtZJFz4Q.js';
+import 'viem';

package/dist/chains/index.js

@@ -0,0 +1,7 @@
+import {
+  simulator
+} from "../chunk-D7VZGQ4K.js";
+import "../chunk-MLKGABMK.js";
+export {
+  simulator
+};

package/dist/chains-CtZJFz4Q.d.cts

@@ -0,0 +1,6 @@
+import { Chain } from 'viem';
+
+interface SimulatorChain extends Chain {
+}
+
+export type { SimulatorChain as S };

package/dist/chains-CtZJFz4Q.d.ts

@@ -0,0 +1,6 @@
+import { Chain } from 'viem';
+
+interface SimulatorChain extends Chain {
+}
+
+export type { SimulatorChain as S };

package/dist/chunk-75ZPJI57.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+
+
+exports.__export = __export;

package/dist/chunk-AR7OM4HI.cjs

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/types/transactions.ts
+var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
+  TransactionStatus2["PENDING"] = "PENDING";
+  TransactionStatus2["CANCELED"] = "CANCELED";
+  TransactionStatus2["PROPOSING"] = "PROPOSING";
+  TransactionStatus2["COMMITTING"] = "COMMITTING";
+  TransactionStatus2["REVEALING"] = "REVEALING";
+  TransactionStatus2["ACCEPTED"] = "ACCEPTED";
+  TransactionStatus2["FINALIZED"] = "FINALIZED";
+  TransactionStatus2["UNDETERMINED"] = "UNDETERMINED";
+  return TransactionStatus2;
+})(TransactionStatus || {});
+
+
+
+exports.TransactionStatus = TransactionStatus;

package/dist/chunk-BAGFDCQE.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk75ZPJI57cjs = require('./chunk-75ZPJI57.cjs');
+
+// src/chains/index.ts
+var chains_exports = {};
+_chunk75ZPJI57cjs.__export.call(void 0, chains_exports, {
+  simulator: () => simulator
+});
+
+// src/chains/simulator.ts
+var _viem = require('viem');
+var SIMULATOR_JSON_RPC_URL = "http://127.0.0.1:4000/api";
+var simulator = _viem.defineChain.call(void 0, {
+  id: 61999,
+  name: "GenLayer Simulator",
+  rpcUrls: {
+    default: {
+      http: [SIMULATOR_JSON_RPC_URL]
+    }
+  },
+  nativeCurrency: {
+    name: "GEN Token",
+    symbol: "GEN",
+    decimals: 18
+  },
+  blockExplorers: {
+    default: {
+      name: "GenLayer Explorer",
+      url: "http://127.0.0.1:4000/api"
+    }
+  },
+  testnet: true
+});
+
+
+
+
+exports.simulator = simulator; exports.chains_exports = chains_exports;

package/dist/chunk-D7VZGQ4K.js

@@ -0,0 +1,39 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/chains/index.ts
+var chains_exports = {};
+__export(chains_exports, {
+  simulator: () => simulator
+});
+
+// src/chains/simulator.ts
+import { defineChain } from "viem";
+var SIMULATOR_JSON_RPC_URL = "http://127.0.0.1:4000/api";
+var simulator = defineChain({
+  id: 61999,
+  name: "GenLayer Simulator",
+  rpcUrls: {
+    default: {
+      http: [SIMULATOR_JSON_RPC_URL]
+    }
+  },
+  nativeCurrency: {
+    name: "GEN Token",
+    symbol: "GEN",
+    decimals: 18
+  },
+  blockExplorers: {
+    default: {
+      name: "GenLayer Explorer",
+      url: "http://127.0.0.1:4000/api"
+    }
+  },
+  testnet: true
+});
+
+export {
+  simulator,
+  chains_exports
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-VQTD5PMI.js

@@ -0,0 +1,16 @@
+// src/types/transactions.ts
+var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
+  TransactionStatus2["PENDING"] = "PENDING";
+  TransactionStatus2["CANCELED"] = "CANCELED";
+  TransactionStatus2["PROPOSING"] = "PROPOSING";
+  TransactionStatus2["COMMITTING"] = "COMMITTING";
+  TransactionStatus2["REVEALING"] = "REVEALING";
+  TransactionStatus2["ACCEPTED"] = "ACCEPTED";
+  TransactionStatus2["FINALIZED"] = "FINALIZED";
+  TransactionStatus2["UNDETERMINED"] = "UNDETERMINED";
+  return TransactionStatus2;
+})(TransactionStatus || {});
+
+export {
+  TransactionStatus
+};

package/dist/clients-Bt_8fb_v.d.ts

@@ -0,0 +1,81 @@
+import { Transport, Account, Client } from 'viem';
+import { S as SimulatorChain } from './chains-CtZJFz4Q.js';
+
+type Address = `0x${string}` & {
+    length: 42;
+};
+
+type TransactionHash = `0x${string}` & {
+    length: 66;
+};
+declare enum TransactionStatus {
+    PENDING = "PENDING",
+    CANCELED = "CANCELED",
+    PROPOSING = "PROPOSING",
+    COMMITTING = "COMMITTING",
+    REVEALING = "REVEALING",
+    ACCEPTED = "ACCEPTED",
+    FINALIZED = "FINALIZED",
+    UNDETERMINED = "UNDETERMINED"
+}
+type GenLayerTransaction = {
+    hash: TransactionHash;
+    status: TransactionStatus;
+    from_address?: string;
+    to_address?: string;
+    data?: Record<string, unknown>;
+    consensus_data?: Record<string, unknown>;
+    nonce?: number;
+    value?: number;
+    type?: number;
+    gaslimit?: bigint;
+    created_at?: Date;
+    r?: number;
+    s?: number;
+    v?: number;
+};
+
+type GenLayerMethod = {
+    method: "sim_fundAccount";
+    params: [address: string, amount: number];
+} | {
+    method: "eth_getTransactionByHash";
+    params: [hash: TransactionHash];
+} | {
+    method: "eth_call";
+    params: [requestParams: any, blockNumberOrHash: string];
+} | {
+    method: "eth_sedRawTransaction";
+    params: [signedTransaction: string];
+} | {
+    method: "gen_getContractSchema";
+    params: [address: string];
+} | {
+    method: "gen_getContractSchemaForCode";
+    params: [contractCode: string];
+};
+type GenLayerClient<TTransport extends Transport, TSimulatorChain extends SimulatorChain, TAccount extends Account> = Client<TTransport, TSimulatorChain, TAccount> & {
+    request: Client<TTransport, TSimulatorChain, TAccount>["request"] & {
+        <TMethod extends GenLayerMethod>(args: Extract<GenLayerMethod, {
+            method: TMethod["method"];
+        }>): Promise<unknown>;
+    };
+    readContract: (args: {
+        account: Account;
+        address: Address;
+        functionName: string;
+        args: any[];
+    }) => Promise<any>;
+    writeContract: (args: {
+        account: Account;
+        address: Address;
+        functionName: string;
+        args: any[];
+        value: bigint;
+    }) => Promise<any>;
+    getTransaction: (args: {
+        hash: TransactionHash;
+    }) => Promise<GenLayerTransaction>;
+};
+
+export { type Address as A, type GenLayerClient as G, type TransactionHash as T, type GenLayerMethod as a, TransactionStatus as b, type GenLayerTransaction as c };

package/dist/clients-CL75M8Ma.d.cts

@@ -0,0 +1,81 @@
+import { Transport, Account, Client } from 'viem';
+import { S as SimulatorChain } from './chains-CtZJFz4Q.cjs';
+
+type Address = `0x${string}` & {
+    length: 42;
+};
+
+type TransactionHash = `0x${string}` & {
+    length: 66;
+};
+declare enum TransactionStatus {
+    PENDING = "PENDING",
+    CANCELED = "CANCELED",
+    PROPOSING = "PROPOSING",
+    COMMITTING = "COMMITTING",
+    REVEALING = "REVEALING",
+    ACCEPTED = "ACCEPTED",
+    FINALIZED = "FINALIZED",
+    UNDETERMINED = "UNDETERMINED"
+}
+type GenLayerTransaction = {
+    hash: TransactionHash;
+    status: TransactionStatus;
+    from_address?: string;
+    to_address?: string;
+    data?: Record<string, unknown>;
+    consensus_data?: Record<string, unknown>;
+    nonce?: number;
+    value?: number;
+    type?: number;
+    gaslimit?: bigint;
+    created_at?: Date;
+    r?: number;
+    s?: number;
+    v?: number;
+};
+
+type GenLayerMethod = {
+    method: "sim_fundAccount";
+    params: [address: string, amount: number];
+} | {
+    method: "eth_getTransactionByHash";
+    params: [hash: TransactionHash];
+} | {
+    method: "eth_call";
+    params: [requestParams: any, blockNumberOrHash: string];
+} | {
+    method: "eth_sedRawTransaction";
+    params: [signedTransaction: string];
+} | {
+    method: "gen_getContractSchema";
+    params: [address: string];
+} | {
+    method: "gen_getContractSchemaForCode";
+    params: [contractCode: string];
+};
+type GenLayerClient<TTransport extends Transport, TSimulatorChain extends SimulatorChain, TAccount extends Account> = Client<TTransport, TSimulatorChain, TAccount> & {
+    request: Client<TTransport, TSimulatorChain, TAccount>["request"] & {
+        <TMethod extends GenLayerMethod>(args: Extract<GenLayerMethod, {
+            method: TMethod["method"];
+        }>): Promise<unknown>;
+    };
+    readContract: (args: {
+        account: Account;
+        address: Address;
+        functionName: string;
+        args: any[];
+    }) => Promise<any>;
+    writeContract: (args: {
+        account: Account;
+        address: Address;
+        functionName: string;
+        args: any[];
+        value: bigint;
+    }) => Promise<any>;
+    getTransaction: (args: {
+        hash: TransactionHash;
+    }) => Promise<GenLayerTransaction>;
+};
+
+export { type Address as A, type GenLayerClient as G, type TransactionHash as T, type GenLayerMethod as a, TransactionStatus as b, type GenLayerTransaction as c };

package/dist/index-DLN-2YXE.d.cts

@@ -0,0 +1,10 @@
+import { S as SimulatorChain } from './chains-CtZJFz4Q.cjs';
+
+declare const simulator: SimulatorChain;
+
+declare const index_simulator: typeof simulator;
+declare namespace index {
+  export { index_simulator as simulator };
+}
+
+export { index as i, simulator as s };

package/dist/index-vHLY9ggt.d.ts

@@ -0,0 +1,10 @@
+import { S as SimulatorChain } from './chains-CtZJFz4Q.js';
+
+declare const simulator: SimulatorChain;
+
+declare const index_simulator: typeof simulator;
+declare namespace index {
+  export { index_simulator as simulator };
+}
+
+export { index as i, simulator as s };

package/dist/index.cjs

@@ -0,0 +1,161 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkBAGFDCQEcjs = require('./chunk-BAGFDCQE.cjs');
+require('./chunk-AR7OM4HI.cjs');
+require('./chunk-75ZPJI57.cjs');
+
+// src/client/client.ts
+var _viem = require('viem');
+
+// src/accounts/actions.ts
+function accountActions(client) {
+  return {
+    fundAccount: async ({ address, amount }) => {
+      if (_optionalChain([client, 'access', _ => _.chain, 'optionalAccess', _2 => _2.id]) !== _chunkBAGFDCQEcjs.simulator.id) {
+        throw new Error("Client is not connected to the simulator");
+      }
+      return client.request({
+        method: "sim_fundAccount",
+        params: [address, amount]
+      });
+    }
+  };
+}
+
+// src/contracts/actions.ts
+
+var contractActions = (client) => {
+  return {
+    getContractSchema: async (address) => {
+      const schema = await client.request({
+        method: "gen_getContractSchema",
+        params: [address]
+      });
+      return schema;
+    },
+    getContractSchemaForCode: async (contractCode) => {
+      const schema = await client.request({
+        method: "gen_getContractSchemaForCode",
+        params: [contractCode]
+      });
+      return schema;
+    }
+  };
+};
+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 requestParams = {
+      to: address,
+      from: _optionalChain([account, 'optionalAccess', _3 => _3.address]) || _optionalChain([client, 'access', _4 => _4.account, 'optionalAccess', _5 => _5.address]),
+      data: encodedData
+    };
+    const result = await client.request({
+      method: "eth_call",
+      params: [requestParams, "latest"]
+    });
+    return result;
+  };
+  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 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])) {
+      throw new Error("Account does not support signTransaction");
+    }
+    const signedTransaction = await senderAccount.signTransaction({
+      data: encodedData,
+      to: address,
+      value,
+      type: "legacy"
+    });
+    const result = await client.request({
+      method: "eth_sendRawTransaction",
+      params: [signedTransaction]
+    });
+    return result;
+  };
+  return client;
+};
+
+// src/config/transactions.ts
+var transactionsConfig = {
+  waitInterval: 3e3,
+  retries: 10
+};
+
+// src/utils/async.ts
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/transactions/actions.ts
+var transactionActions = (client) => ({
+  waitForTransactionReceipt: async ({
+    hash,
+    status = "FINALIZED" /* FINALIZED */,
+    interval = transactionsConfig.waitInterval,
+    retries = transactionsConfig.retries
+  }) => {
+    const transaction = await client.getTransaction({ hash });
+    if (!transaction) {
+      throw new Error("Transaction not found");
+    }
+    if (transaction.status === status || status === "ACCEPTED" /* ACCEPTED */ && transaction.status === "FINALIZED" /* FINALIZED */) {
+      return transaction;
+    }
+    if (retries === 0) {
+      throw new Error("Transaction status is not " + status);
+    }
+    await sleep(interval);
+    return transactionActions(client).waitForTransactionReceipt({
+      hash,
+      status,
+      interval,
+      retries: retries - 1
+    });
+  }
+});
+
+// src/client/client.ts
+var createClient = (config = { chain: _chunkBAGFDCQEcjs.simulator }) => {
+  const chainConfig = config.chain || _chunkBAGFDCQEcjs.simulator;
+  const rpcUrl = config.endpoint || chainConfig.rpcUrls.default.http[0];
+  const baseClient = _viem.createClient.call(void 0, {
+    chain: chainConfig,
+    transport: _viem.http.call(void 0, rpcUrl),
+    ...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;
+};
+
+// src/accounts/account.ts
+var _accounts = require('viem/accounts');
+var createAccount = () => {
+  const privateKey = _accounts.generatePrivateKey.call(void 0, );
+  const account = _accounts.privateKeyToAccount.call(void 0, privateKey);
+  return account;
+};
+
+
+
+
+exports.chains = _chunkBAGFDCQEcjs.chains_exports; exports.createAccount = createAccount; exports.createClient = createClient;

package/dist/index.d.cts

@@ -0,0 +1,55 @@
+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 * 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';
+export { i as chains } from './index-DLN-2YXE.cjs';
+
+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;
+            };
+        };
+    };
+    endpoint?: string;
+    account?: Account;
+}
+declare const createClient: (config?: ClientConfig) => GenLayerClient<Transport, SimulatorChain, Account>;
+
+declare const createAccount: () => {
+    address: viem_accounts.Address;
+    nonceManager?: viem_accounts.NonceManager | undefined;
+    sign: (parameters: {
+        hash: viem.Hash;
+    }) => Promise<viem.Hex>;
+    experimental_signAuthorization: (parameters: viem__types_experimental_eip7702_types_authorization.Authorization) => Promise<viem_accounts.SignAuthorizationReturnType>;
+    signMessage: ({ message }: {
+        message: viem.SignableMessage;
+    }) => Promise<viem.Hex>;
+    signTransaction: <serializer extends viem.SerializeTransactionFn<viem.TransactionSerializable> = viem.SerializeTransactionFn<viem.TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<viem.IsNarrowable<viem.TransactionSerialized<viem.GetTransactionType<transaction>>, viem.Hex> extends true ? viem.TransactionSerialized<viem.GetTransactionType<transaction>> : viem.Hex>;
+    signTypedData: <const typedData extends abitype.TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: viem.TypedDataDefinition<typedData, primaryType>) => Promise<viem.Hex>;
+    publicKey: viem.Hex;
+    source: "privateKey";
+    type: "local";
+};
+
+export { createAccount, createClient };

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+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 * 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';
+export { i as chains } from './index-vHLY9ggt.js';
+
+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;
+            };
+        };
+    };
+    endpoint?: string;
+    account?: Account;
+}
+declare const createClient: (config?: ClientConfig) => GenLayerClient<Transport, SimulatorChain, Account>;
+
+declare const createAccount: () => {
+    address: viem_accounts.Address;
+    nonceManager?: viem_accounts.NonceManager | undefined;
+    sign: (parameters: {
+        hash: viem.Hash;
+    }) => Promise<viem.Hex>;
+    experimental_signAuthorization: (parameters: viem__types_experimental_eip7702_types_authorization.Authorization) => Promise<viem_accounts.SignAuthorizationReturnType>;
+    signMessage: ({ message }: {
+        message: viem.SignableMessage;
+    }) => Promise<viem.Hex>;
+    signTransaction: <serializer extends viem.SerializeTransactionFn<viem.TransactionSerializable> = viem.SerializeTransactionFn<viem.TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<viem.IsNarrowable<viem.TransactionSerialized<viem.GetTransactionType<transaction>>, viem.Hex> extends true ? viem.TransactionSerialized<viem.GetTransactionType<transaction>> : viem.Hex>;
+    signTypedData: <const typedData extends abitype.TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: viem.TypedDataDefinition<typedData, primaryType>) => Promise<viem.Hex>;
+    publicKey: viem.Hex;
+    source: "privateKey";
+    type: "local";
+};
+
+export { createAccount, createClient };

package/dist/index.js

@@ -0,0 +1,161 @@
+import {
+  chains_exports,
+  simulator
+} from "./chunk-D7VZGQ4K.js";
+import "./chunk-VQTD5PMI.js";
+import "./chunk-MLKGABMK.js";
+
+// src/client/client.ts
+import { createClient as createViemClient, http, publicActions } from "viem";
+
+// src/accounts/actions.ts
+function accountActions(client) {
+  return {
+    fundAccount: async ({ address, amount }) => {
+      if (client.chain?.id !== simulator.id) {
+        throw new Error("Client is not connected to the simulator");
+      }
+      return client.request({
+        method: "sim_fundAccount",
+        params: [address, amount]
+      });
+    }
+  };
+}
+
+// src/contracts/actions.ts
+import { toRlp, toHex } from "viem";
+var contractActions = (client) => {
+  return {
+    getContractSchema: async (address) => {
+      const schema = await client.request({
+        method: "gen_getContractSchema",
+        params: [address]
+      });
+      return schema;
+    },
+    getContractSchemaForCode: async (contractCode) => {
+      const schema = await client.request({
+        method: "gen_getContractSchemaForCode",
+        params: [contractCode]
+      });
+      return schema;
+    }
+  };
+};
+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 requestParams = {
+      to: address,
+      from: account?.address || client.account?.address,
+      data: encodedData
+    };
+    const result = await client.request({
+      method: "eth_call",
+      params: [requestParams, "latest"]
+    });
+    return result;
+  };
+  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 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 signedTransaction = await senderAccount.signTransaction({
+      data: encodedData,
+      to: address,
+      value,
+      type: "legacy"
+    });
+    const result = await client.request({
+      method: "eth_sendRawTransaction",
+      params: [signedTransaction]
+    });
+    return result;
+  };
+  return client;
+};
+
+// src/config/transactions.ts
+var transactionsConfig = {
+  waitInterval: 3e3,
+  retries: 10
+};
+
+// src/utils/async.ts
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/transactions/actions.ts
+var transactionActions = (client) => ({
+  waitForTransactionReceipt: async ({
+    hash,
+    status = "FINALIZED" /* FINALIZED */,
+    interval = transactionsConfig.waitInterval,
+    retries = transactionsConfig.retries
+  }) => {
+    const transaction = await client.getTransaction({ hash });
+    if (!transaction) {
+      throw new Error("Transaction not found");
+    }
+    if (transaction.status === status || status === "ACCEPTED" /* ACCEPTED */ && transaction.status === "FINALIZED" /* FINALIZED */) {
+      return transaction;
+    }
+    if (retries === 0) {
+      throw new Error("Transaction status is not " + status);
+    }
+    await sleep(interval);
+    return transactionActions(client).waitForTransactionReceipt({
+      hash,
+      status,
+      interval,
+      retries: retries - 1
+    });
+  }
+});
+
+// src/client/client.ts
+var createClient = (config = { chain: simulator }) => {
+  const chainConfig = config.chain || simulator;
+  const rpcUrl = config.endpoint || chainConfig.rpcUrls.default.http[0];
+  const baseClient = createViemClient({
+    chain: chainConfig,
+    transport: http(rpcUrl),
+    ...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;
+};
+
+// src/accounts/account.ts
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+var createAccount = () => {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  return account;
+};
+export {
+  chains_exports as chains,
+  createAccount,
+  createClient
+};

package/dist/types/index.cjs

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

package/dist/types/index.d.cts

@@ -0,0 +1,21 @@
+export { A as Address, G as GenLayerClient, a as GenLayerMethod, c as GenLayerTransaction, T as TransactionHash, b as TransactionStatus } from '../clients-CL75M8Ma.cjs';
+export { S as SimulatorChain } from '../chains-CtZJFz4Q.cjs';
+export { Account } from 'viem';
+
+type ContractSchema = {
+    abi: Array<{
+        inputs?: Array<{
+            name: string;
+            type: string;
+        }>;
+        name?: string;
+        outputs?: Array<{
+            name: string;
+            type: string;
+        }>;
+        type: "constructor" | "function";
+    }>;
+    class: string;
+};
+
+export type { ContractSchema };

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+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 { S as SimulatorChain } from '../chains-CtZJFz4Q.js';
+export { Account } from 'viem';
+
+type ContractSchema = {
+    abi: Array<{
+        inputs?: Array<{
+            name: string;
+            type: string;
+        }>;
+        name?: string;
+        outputs?: Array<{
+            name: string;
+            type: string;
+        }>;
+        type: "constructor" | "function";
+    }>;
+    class: string;
+};
+
+export type { ContractSchema };

package/dist/types/index.js

@@ -0,0 +1,11 @@
+import {
+  TransactionStatus
+} from "../chunk-VQTD5PMI.js";
+import "../chunk-MLKGABMK.js";
+
+// src/types/accounts.ts
+import { Account } from "viem";
+export {
+  Account,
+  TransactionStatus
+};

package/package.json

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

package/src/accounts/actions.ts

@@ -1,5 +1,5 @@
-import {GenLayerClient, TransactionHash, SimulatorChain} from "@/types";
-import {simulator} from "@/chains";
+import {GenLayerClient, TransactionHash, SimulatorChain} from "../types";
+import {simulator} from "../chains";
 import {Account, Transport} from "viem";
 
 export function accountActions<

package/src/client/client.ts

@@ -4,7 +4,6 @@ import {accountActions} from "../accounts/actions";
 import {contractActions, overrideContractActions} from "../contracts/actions";
 import {transactionActions} from "../transactions/actions";
 import {GenLayerClient, SimulatorChain} from "@/types";
-import {createAccount} from "@/accounts/account";
 
 // Define the configuration interface for the client
 interface ClientConfig {

package/src/types/accounts.ts

@@ -1 +1,2 @@
+export {Account} from "viem";
 export type Address = `0x${string}` & {length: 42};

package/tests/client.test.ts

@@ -0,0 +1,11 @@
+// tests/client.test.ts
+import {createClient} from "../src/client/client";
+import {simulator} from "../src/chains/simulator";
+
+describe("Client Creation", () => {
+  it("should create a client for the simulator", () => {
+    const client = createClient({chain: simulator});
+    expect(client).toBeDefined();
+    expect(client.chain).toBe(simulator);
+  });
+});