genlayer-js 0.3.4 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 
 
+## 0.4.1 (2024-11-20)
+
+## 0.4.0 (2024-11-14)
+
+
+### Features
+
+* add contract schema methods ([#26](https://github.com/yeagerai/genlayer-js/issues/26)) ([7dc726f](https://github.com/yeagerai/genlayer-js/commit/7dc726fa4fc8769feaec07a50149956d7c2a2035))
+
 ## 0.3.4 (2024-11-14)
 
 

package/dist/index.cjs

@@ -222,8 +222,9 @@ var overrideContractActions = (client) => {
     return result;
   };
   client.writeContract = async (args) => {
-    const { account, address, functionName, args: params, value = 0n } = args;
-    const encodedData = encodeAndSerialize({ method: functionName, args: params });
+    const { account, address, functionName, args: params, value = 0n, leader_only = false } = args;
+    const data = [encode({ method: functionName, args: params }), leader_only];
+    const serializedData = serialize(data);
     const senderAccount = account || client.account;
     if (!senderAccount) {
       throw new Error(
@@ -235,7 +236,7 @@ var overrideContractActions = (client) => {
     }
     const nonce = await client.getCurrentNonce({ address: senderAccount.address });
     const signedTransaction = await senderAccount.signTransaction({
-      data: encodedData,
+      data: serializedData,
       to: address,
       value,
       type: "legacy",
@@ -248,8 +249,8 @@ var overrideContractActions = (client) => {
     return result;
   };
   client.deployContract = async (args) => {
-    const { account, code, args: constructorArgs } = args;
-    const data = [code, encode({ args: constructorArgs })];
+    const { account, code, args: constructorArgs, leader_only = false } = args;
+    const data = [code, encode({ args: constructorArgs }), leader_only];
     const serializedData = serialize(data);
     const senderAccount = account || client.account;
     if (!senderAccount) {

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as viem from 'viem';
 import { Account } from 'viem';
 import { S as SimulatorChain } from './chains-BV4Glo-M.cjs';
-import { G as GenLayerClient } from './clients-B5D5440g.cjs';
+import { GenLayerClient } from './types/index.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 { Account } from 'viem';
 import { S as SimulatorChain } from './chains-BV4Glo-M.js';
-import { G as GenLayerClient } from './clients-CRRMg5Gh.js';
+import { GenLayerClient } from './types/index.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

@@ -222,8 +222,9 @@ var overrideContractActions = (client) => {
     return result;
   };
   client.writeContract = async (args) => {
-    const { account, address, functionName, args: params, value = 0n } = args;
-    const encodedData = encodeAndSerialize({ method: functionName, args: params });
+    const { account, address, functionName, args: params, value = 0n, leader_only = false } = args;
+    const data = [encode({ method: functionName, args: params }), leader_only];
+    const serializedData = serialize(data);
     const senderAccount = account || client.account;
     if (!senderAccount) {
       throw new Error(
@@ -235,7 +236,7 @@ var overrideContractActions = (client) => {
     }
     const nonce = await client.getCurrentNonce({ address: senderAccount.address });
     const signedTransaction = await senderAccount.signTransaction({
-      data: encodedData,
+      data: serializedData,
       to: address,
       value,
       type: "legacy",
@@ -248,8 +249,8 @@ var overrideContractActions = (client) => {
     return result;
   };
   client.deployContract = async (args) => {
-    const { account, code, args: constructorArgs } = args;
-    const data = [code, encode({ args: constructorArgs })];
+    const { account, code, args: constructorArgs, leader_only = false } = args;
+    const data = [code, encode({ args: constructorArgs }), leader_only];
     const serializedData = serialize(data);
     const senderAccount = account || client.account;
     if (!senderAccount) {

package/dist/types/index.d.cts

@@ -1,7 +1,58 @@
-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-B5D5440g.cjs';
-export { S as SimulatorChain } from '../chains-BV4Glo-M.cjs';
+import { S as SimulatorChain } from '../chains-BV4Glo-M.cjs';
+import { Client, Transport, PublicActions, Account } from 'viem';
 export { Account } from 'viem';
 
+type Address$1 = `0x${string}` & {
+    length: 42;
+};
+
+declare class Address {
+    bytes: Uint8Array;
+    constructor(addr: Uint8Array);
+}
+type CalldataEncodable = null | boolean | Address | number | bigint | string | Uint8Array | 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;
+};
+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 TransactionDataElement = string | number | bigint | boolean | Uint8Array;
+
 type ContractSchema = {
     abi: Array<{
         inputs?: Array<{
@@ -18,4 +69,69 @@ type ContractSchema = {
     class: string;
 };
 
-export type { ContractSchema };
+type GenLayerMethod = {
+    method: "sim_fundAccount";
+    params: [address: string, amount: number];
+} | {
+    method: "eth_getTransactionByHash";
+    params: [hash: TransactionHash];
+} | {
+    method: "eth_call";
+    params: [requestParams: any, blockNumberOrHash: string];
+} | {
+    method: "eth_sedRawTransaction";
+    params: [signedTransaction: string];
+} | {
+    method: "gen_getContractSchema";
+    params: [address: string];
+} | {
+    method: "gen_getContractSchemaForCode";
+    params: [contractCode: string];
+} | {
+    method: "sim_getTransactionsForAddress";
+    params: [address: string, filter?: "all" | "from" | "to"];
+} | {
+    method: "eth_getTransactionCount";
+    params: [address: string];
+};
+type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transport, TSimulatorChain>, "transport" | "getTransaction" | "readContract"> & Omit<PublicActions<Transport, TSimulatorChain>, "readContract" | "getTransaction"> & {
+    request: Client<Transport, TSimulatorChain>["request"] & {
+        <TMethod extends GenLayerMethod>(args: Extract<GenLayerMethod, {
+            method: TMethod["method"];
+        }>): Promise<unknown>;
+    };
+    readContract: (args: {
+        account?: Account;
+        address: Address$1;
+        functionName: string;
+        args: CalldataEncodable[];
+    }) => Promise<any>;
+    writeContract: (args: {
+        account?: Account;
+        address: Address$1;
+        functionName: string;
+        args: CalldataEncodable[];
+        value: bigint;
+        leader_only?: boolean;
+    }) => Promise<any>;
+    deployContract: (args: {
+        account?: Account;
+        code: string;
+        args: CalldataEncodable[];
+        leader_only?: boolean;
+    }) => Promise<any>;
+    getTransaction: (args: {
+        hash: TransactionHash;
+    }) => Promise<GenLayerTransaction>;
+    getCurrentNonce: (args: {
+        address: string;
+    }) => Promise<number>;
+    waitForTransactionReceipt: (args: {
+        hash: TransactionHash;
+        status?: TransactionStatus;
+    }) => Promise<GenLayerTransaction>;
+    getContractSchema: (address: string) => Promise<ContractSchema>;
+    getContractSchemaForCode: (contractCode: string) => Promise<ContractSchema>;
+};
+
+export { type Address$1 as Address, type CalldataEncodable, type ContractSchema, type GenLayerClient, type GenLayerMethod, type GenLayerTransaction, type MethodDescription, SimulatorChain, type TransactionData, type TransactionDataElement, type TransactionHash, TransactionStatus };

package/dist/types/index.d.ts

@@ -1,7 +1,58 @@
-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-CRRMg5Gh.js';
-export { S as SimulatorChain } from '../chains-BV4Glo-M.js';
+import { S as SimulatorChain } from '../chains-BV4Glo-M.js';
+import { Client, Transport, PublicActions, Account } from 'viem';
 export { Account } from 'viem';
 
+type Address$1 = `0x${string}` & {
+    length: 42;
+};
+
+declare class Address {
+    bytes: Uint8Array;
+    constructor(addr: Uint8Array);
+}
+type CalldataEncodable = null | boolean | Address | number | bigint | string | Uint8Array | 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;
+};
+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 TransactionDataElement = string | number | bigint | boolean | Uint8Array;
+
 type ContractSchema = {
     abi: Array<{
         inputs?: Array<{
@@ -18,4 +69,69 @@ type ContractSchema = {
     class: string;
 };
 
-export type { ContractSchema };
+type GenLayerMethod = {
+    method: "sim_fundAccount";
+    params: [address: string, amount: number];
+} | {
+    method: "eth_getTransactionByHash";
+    params: [hash: TransactionHash];
+} | {
+    method: "eth_call";
+    params: [requestParams: any, blockNumberOrHash: string];
+} | {
+    method: "eth_sedRawTransaction";
+    params: [signedTransaction: string];
+} | {
+    method: "gen_getContractSchema";
+    params: [address: string];
+} | {
+    method: "gen_getContractSchemaForCode";
+    params: [contractCode: string];
+} | {
+    method: "sim_getTransactionsForAddress";
+    params: [address: string, filter?: "all" | "from" | "to"];
+} | {
+    method: "eth_getTransactionCount";
+    params: [address: string];
+};
+type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transport, TSimulatorChain>, "transport" | "getTransaction" | "readContract"> & Omit<PublicActions<Transport, TSimulatorChain>, "readContract" | "getTransaction"> & {
+    request: Client<Transport, TSimulatorChain>["request"] & {
+        <TMethod extends GenLayerMethod>(args: Extract<GenLayerMethod, {
+            method: TMethod["method"];
+        }>): Promise<unknown>;
+    };
+    readContract: (args: {
+        account?: Account;
+        address: Address$1;
+        functionName: string;
+        args: CalldataEncodable[];
+    }) => Promise<any>;
+    writeContract: (args: {
+        account?: Account;
+        address: Address$1;
+        functionName: string;
+        args: CalldataEncodable[];
+        value: bigint;
+        leader_only?: boolean;
+    }) => Promise<any>;
+    deployContract: (args: {
+        account?: Account;
+        code: string;
+        args: CalldataEncodable[];
+        leader_only?: boolean;
+    }) => Promise<any>;
+    getTransaction: (args: {
+        hash: TransactionHash;
+    }) => Promise<GenLayerTransaction>;
+    getCurrentNonce: (args: {
+        address: string;
+    }) => Promise<number>;
+    waitForTransactionReceipt: (args: {
+        hash: TransactionHash;
+        status?: TransactionStatus;
+    }) => Promise<GenLayerTransaction>;
+    getContractSchema: (address: string) => Promise<ContractSchema>;
+    getContractSchemaForCode: (contractCode: string) => Promise<ContractSchema>;
+};
+
+export { type Address$1 as Address, type CalldataEncodable, type ContractSchema, type GenLayerClient, type GenLayerMethod, type GenLayerTransaction, type MethodDescription, SimulatorChain, type TransactionData, type TransactionDataElement, type TransactionHash, TransactionStatus };

package/package.json

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

package/src/contracts/actions.ts

@@ -48,9 +48,11 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     functionName: string;
     args: CalldataEncodable[];
     value: bigint;
+    leader_only?: boolean;
   }): Promise<any> => {
-    const {account, address, functionName, args: params, value = 0n} = args;
-    const encodedData = encodeAndSerialize({method: functionName, args: params});
+    const {account, address, functionName, args: params, value = 0n, leader_only = false} = args;
+    const data = [encode({method: functionName, args: params}), leader_only];
+    const serializedData = serialize(data);
 
     const senderAccount = account || client.account;
     if (!senderAccount) {
@@ -66,7 +68,7 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     const nonce = await client.getCurrentNonce({address: senderAccount.address});
 
     const signedTransaction = await senderAccount.signTransaction({
-      data: encodedData,
+      data: serializedData,
       to: address,
       value,
       type: "legacy",
@@ -79,9 +81,14 @@ export const overrideContractActions = (client: GenLayerClient<SimulatorChain>)
     return result;
   };
 
-  client.deployContract = async (args: {account?: Account; code: string; args: CalldataEncodable[]}) => {
-    const {account, code, args: constructorArgs} = args;
-    const data = [code, encode({args: constructorArgs})];
+  client.deployContract = async (args: {
+    account?: Account;
+    code: string;
+    args: CalldataEncodable[];
+    leader_only?: boolean;
+  }) => {
+    const {account, code, args: constructorArgs, leader_only = false} = args;
+    const data = [code, encode({args: constructorArgs}), leader_only];
     const serializedData = serialize(data);
 
     const senderAccount = account || client.account;

package/src/types/clients.ts

@@ -3,6 +3,7 @@ import {GenLayerTransaction, TransactionHash, TransactionStatus} from "./transac
 import {SimulatorChain} from "./chains";
 import {Address, Account} from "./accounts";
 import {CalldataEncodable} from "./calldata";
+import {ContractSchema} from "./contracts";
 
 export type GenLayerMethod =
   | {method: "sim_fundAccount"; params: [address: string, amount: number]}
@@ -42,12 +43,20 @@ export type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<
       functionName: string;
       args: CalldataEncodable[];
       value: bigint;
+      leader_only?: boolean;
+    }) => Promise<any>;
+    deployContract: (args: {
+      account?: Account;
+      code: string;
+      args: CalldataEncodable[];
+      leader_only?: boolean;
     }) => Promise<any>;
-    deployContract: (args: {account?: Account; code: string; args: CalldataEncodable[]}) => Promise<any>;
     getTransaction: (args: {hash: TransactionHash}) => Promise<GenLayerTransaction>;
     getCurrentNonce: (args: {address: string}) => Promise<number>;
     waitForTransactionReceipt: (args: {
       hash: TransactionHash;
       status?: TransactionStatus;
     }) => Promise<GenLayerTransaction>;
+    getContractSchema: (address: string) => Promise<ContractSchema>;
+    getContractSchemaForCode: (contractCode: string) => Promise<ContractSchema>;
   };

package/tests/client.test-d.ts

@@ -8,26 +8,32 @@ test("type checks", () => {
     account: createAccount(generatePrivateKey()),
   });
 
+  const exampleAddress = "0x1234567890123456789012345678901234567890";
+
   // This should fail type checking - "whatever" is not a valid filter
   // @ts-expect-error "whatever" is not a valid filter type
   void client.request({
     method: "sim_getTransactionsForAddress",
-    params: ["0x1234567890123456789012345678901234567890", "whatever"],
+    params: [exampleAddress, "whatever"],
   });
 
   // This should pass type checking - "all", "to" and "from" are valid filters
   void client.request({
     method: "sim_getTransactionsForAddress",
-    params: ["0x1234567890123456789012345678901234567890", "all"],
+    params: [exampleAddress, "all"],
   });
 
   void client.request({
     method: "sim_getTransactionsForAddress",
-    params: ["0x1234567890123456789012345678901234567890", "to"],
+    params: [exampleAddress, "to"],
   });
 
   void client.request({
     method: "sim_getTransactionsForAddress",
-    params: ["0x1234567890123456789012345678901234567890", "from"],
+    params: [exampleAddress, "from"],
   });
+
+  void client.getContractSchema(exampleAddress);
+
+  void client.getContractSchemaForCode("class SomeContract...");
 });

package/dist/clients-B5D5440g.d.cts

@@ -1,116 +0,0 @@
-import { Client, Transport, PublicActions, Account } from 'viem';
-import { S as SimulatorChain } from './chains-BV4Glo-M.cjs';
-
-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;
-};
-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 TransactionDataElement = string | number | bigint | boolean | Uint8Array;
-
-type GenLayerMethod = {
-    method: "sim_fundAccount";
-    params: [address: string, amount: number];
-} | {
-    method: "eth_getTransactionByHash";
-    params: [hash: TransactionHash];
-} | {
-    method: "eth_call";
-    params: [requestParams: any, blockNumberOrHash: string];
-} | {
-    method: "eth_sedRawTransaction";
-    params: [signedTransaction: string];
-} | {
-    method: "gen_getContractSchema";
-    params: [address: string];
-} | {
-    method: "gen_getContractSchemaForCode";
-    params: [contractCode: string];
-} | {
-    method: "sim_getTransactionsForAddress";
-    params: [address: string, filter?: "all" | "from" | "to"];
-} | {
-    method: "eth_getTransactionCount";
-    params: [address: string];
-};
-type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transport, TSimulatorChain>, "transport" | "getTransaction" | "readContract"> & Omit<PublicActions<Transport, TSimulatorChain>, "readContract" | "getTransaction"> & {
-    request: Client<Transport, TSimulatorChain>["request"] & {
-        <TMethod extends GenLayerMethod>(args: Extract<GenLayerMethod, {
-            method: TMethod["method"];
-        }>): Promise<unknown>;
-    };
-    readContract: (args: {
-        account?: Account;
-        address: Address$1;
-        functionName: string;
-        args: CalldataEncodable[];
-    }) => Promise<any>;
-    writeContract: (args: {
-        account?: Account;
-        address: Address$1;
-        functionName: string;
-        args: CalldataEncodable[];
-        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>;
-    waitForTransactionReceipt: (args: {
-        hash: TransactionHash;
-        status?: TransactionStatus;
-    }) => Promise<GenLayerTransaction>;
-};
-
-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-CRRMg5Gh.d.ts

@@ -1,116 +0,0 @@
-import { Client, Transport, PublicActions, Account } from 'viem';
-import { S as SimulatorChain } from './chains-BV4Glo-M.js';
-
-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;
-};
-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 TransactionDataElement = string | number | bigint | boolean | Uint8Array;
-
-type GenLayerMethod = {
-    method: "sim_fundAccount";
-    params: [address: string, amount: number];
-} | {
-    method: "eth_getTransactionByHash";
-    params: [hash: TransactionHash];
-} | {
-    method: "eth_call";
-    params: [requestParams: any, blockNumberOrHash: string];
-} | {
-    method: "eth_sedRawTransaction";
-    params: [signedTransaction: string];
-} | {
-    method: "gen_getContractSchema";
-    params: [address: string];
-} | {
-    method: "gen_getContractSchemaForCode";
-    params: [contractCode: string];
-} | {
-    method: "sim_getTransactionsForAddress";
-    params: [address: string, filter?: "all" | "from" | "to"];
-} | {
-    method: "eth_getTransactionCount";
-    params: [address: string];
-};
-type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<Client<Transport, TSimulatorChain>, "transport" | "getTransaction" | "readContract"> & Omit<PublicActions<Transport, TSimulatorChain>, "readContract" | "getTransaction"> & {
-    request: Client<Transport, TSimulatorChain>["request"] & {
-        <TMethod extends GenLayerMethod>(args: Extract<GenLayerMethod, {
-            method: TMethod["method"];
-        }>): Promise<unknown>;
-    };
-    readContract: (args: {
-        account?: Account;
-        address: Address$1;
-        functionName: string;
-        args: CalldataEncodable[];
-    }) => Promise<any>;
-    writeContract: (args: {
-        account?: Account;
-        address: Address$1;
-        functionName: string;
-        args: CalldataEncodable[];
-        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>;
-    waitForTransactionReceipt: (args: {
-        hash: TransactionHash;
-        status?: TransactionStatus;
-    }) => Promise<GenLayerTransaction>;
-};
-
-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 };