genlayer-js 0.9.0 → 0.9.1

package/src/client/client.ts

@@ -1,9 +1,20 @@
-import {Account, createClient as createViemClient, publicActions, custom, Address, walletActions} from "viem";
+import {
+  Account,
+  createClient as createViemClient,
+  createPublicClient as createPublicViemClient,
+  publicActions,
+  custom,
+  Address,
+  walletActions,
+  Transport,
+  PublicClient,
+  Chain,
+} from "viem";
 import {accountActions} from "../accounts/actions";
-import {contractActions, overrideContractActions} from "../contracts/actions";
-import {transactionActions} from "../transactions/actions";
+import {contractActions} from "../contracts/actions";
+import {receiptActions, transactionActions} from "../transactions/actions";
 import {walletActions as genlayerWalletActions} from "../wallet/actions";
-import {GenLayerClient, SimulatorChain} from "@/types";
+import {GenLayerClient, GenLayerChain} from "@/types";
 import {chainActions} from "@/chains/actions";
 import {localnet} from "@/chains";
 
@@ -20,15 +31,11 @@ interface ClientConfig {
   account?: Account | Address;
 }
 
-export const createClient = (config: ClientConfig = {chain: localnet}) => {
-  const chainConfig = config.chain || localnet;
-  if (config.endpoint) {
-    chainConfig.rpcUrls.default.http = [config.endpoint];
-  }
+const getCustomTransportConfig = (config: ClientConfig) => {
   const isAddress = typeof config.account !== "object";
 
-  const customTransport = {
-    async request({method, params}: {method: string; params: any[]}) {
+  return {
+    async request({method, params = []}: {method: string; params: any[]}) {
       if (method.startsWith("eth_") && isAddress) {
         try {
           return await window.ethereum?.request({method, params});
@@ -37,8 +44,12 @@ export const createClient = (config: ClientConfig = {chain: localnet}) => {
           throw err;
         }
       } else {
+        if (!config.chain) {
+          throw new Error("Chain is not set");
+        }
+
         try {
-          const response = await fetch(chainConfig.rpcUrls.default.http[0], {
+          const response = await fetch(config.chain.rpcUrls.default.http[0], {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
@@ -65,24 +76,56 @@ export const createClient = (config: ClientConfig = {chain: localnet}) => {
       }
     },
   };
+};
+
+export const createClient = (config: ClientConfig = {chain: localnet}): GenLayerClient<GenLayerChain> => {
+  const chainConfig = config.chain || localnet;
+  if (config.endpoint) {
+    chainConfig.rpcUrls.default.http = [config.endpoint];
+  }
+
+  const customTransport = custom(getCustomTransportConfig(config));
+  const publicClient = createPublicClient(chainConfig as GenLayerChain, customTransport).extend(
+    publicActions,
+  );
 
   const baseClient = createViemClient({
     chain: chainConfig,
-    transport: custom(customTransport),
+    transport: customTransport,
     ...(config.account ? {account: config.account} : {}),
-  })
+  });
+
+  // First extend with basic actions
+  const clientWithBasicActions = baseClient
     .extend(publicActions)
     .extend(walletActions)
-    .extend(client => accountActions(client as unknown as GenLayerClient<SimulatorChain>))
-    .extend(client => transactionActions(client as unknown as GenLayerClient<SimulatorChain>))
-    .extend(client => contractActions(client as unknown as GenLayerClient<SimulatorChain>))
-    .extend(client => chainActions(client as unknown as GenLayerClient<SimulatorChain>))
-    .extend((client) => genlayerWalletActions(client as unknown as GenLayerClient<SimulatorChain>));
+    .extend(client => accountActions(client as unknown as GenLayerClient<GenLayerChain>));
+
+  // Create a client with all actions except transaction actions
+  const clientWithAllActions = {
+    ...clientWithBasicActions,
+    ...contractActions(clientWithBasicActions as unknown as GenLayerClient<GenLayerChain>, publicClient),
+    ...chainActions(clientWithBasicActions as unknown as GenLayerClient<GenLayerChain>),
+    ...genlayerWalletActions(clientWithBasicActions as unknown as GenLayerClient<GenLayerChain>),
+    ...transactionActions(clientWithBasicActions as unknown as GenLayerClient<GenLayerChain>, publicClient),
+  } as unknown as GenLayerClient<GenLayerChain>;
+
+  // Add transaction actions last, after all other actions are in place
+  const finalClient = {
+    ...clientWithAllActions,
+    ...receiptActions(clientWithAllActions as unknown as GenLayerClient<GenLayerChain>, publicClient),
+  } as unknown as GenLayerClient<GenLayerChain>;
 
   // Initialize in the background
-  baseClient.initializeConsensusSmartContract().catch(error => {
+  finalClient.initializeConsensusSmartContract().catch(error => {
     console.error("Failed to initialize consensus smart contract:", error);
   });
+  return finalClient;
+};
 
-  return overrideContractActions(baseClient as unknown as GenLayerClient<SimulatorChain>);
+export const createPublicClient = (
+  chainConfig: GenLayerChain,
+  customTransport: Transport,
+): PublicClient<Transport, Chain> => {
+  return createPublicViemClient({chain: chainConfig, transport: customTransport});
 };

package/src/contracts/actions.ts

@@ -1,15 +1,8 @@
 import * as calldata from "@/abi/calldata";
-import {serialize, serializeOne} from "@/abi/transactions";
-import {
-  Account,
-  ContractSchema,
-  SimulatorChain,
-  GenLayerClient,
-  CalldataEncodable,
-  Address,
-  TransactionStatus,
-} from "@/types";
-import {fromHex, toHex, zeroAddress, encodeFunctionData} from "viem";
+import {serialize} from "@/abi/transactions";
+import {localnet} from "@/chains/localnet";
+import {Account, ContractSchema, GenLayerChain, GenLayerClient, CalldataEncodable, Address} from "@/types";
+import {fromHex, toHex, zeroAddress, encodeFunctionData, PublicClient, parseEventLogs} from "viem";
 
 function makeCalldataObject(
   method: string | undefined,
@@ -48,9 +41,12 @@ function makeCalldataObject(
   return ret;
 }
 
-export const contractActions = (client: GenLayerClient<SimulatorChain>) => {
+export const contractActions = (client: GenLayerClient<GenLayerChain>, publicClient: PublicClient) => {
   return {
-    getContractSchema: async (address: string): Promise<ContractSchema> => {
+    getContractSchema: async (address: Address): Promise<ContractSchema> => {
+      if (client.chain.id !== localnet.id) {
+        throw new Error("Contract schema is not supported on this network");
+      }
       const schema = (await client.request({
         method: "gen_getContractSchema",
         params: [address],
@@ -58,148 +54,200 @@ export const contractActions = (client: GenLayerClient<SimulatorChain>) => {
       return schema as unknown as ContractSchema;
     },
     getContractSchemaForCode: async (contractCode: string | Uint8Array): Promise<ContractSchema> => {
+      if (client.chain.id !== localnet.id) {
+        throw new Error("Contract schema is not supported on this network");
+      }
       const schema = (await client.request({
         method: "gen_getContractSchemaForCode",
         params: [toHex(contractCode)],
       })) as string;
       return schema as unknown as ContractSchema;
     },
-  };
-};
-
-export const overrideContractActions = (client: GenLayerClient<SimulatorChain>) => {
-  client.readContract = async <RawReturn extends boolean | undefined>(args: {
-    account?: Account;
-    address: Address;
-    functionName: string;
-    args?: CalldataEncodable[];
-    kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-    stateStatus?: TransactionStatus;
-    rawReturn?: RawReturn;
-  }): Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable> => {
-    const {
-      account,
-      address,
-      functionName,
-      args: callArgs,
-      kwargs,
-      stateStatus = TransactionStatus.ACCEPTED,
-    } = args;
-    const encodedData = calldata.encode(makeCalldataObject(functionName, callArgs, kwargs));
-    const serializedData = serializeOne(encodedData);
-
-    const senderAddress = account?.address ?? client.account?.address;
-
-    const requestParams = {
-      to: address,
-      from: senderAddress,
-      data: serializedData,
-    };
-    const result = await client.request({
-      method: "eth_call",
-      params: [requestParams, stateStatus == TransactionStatus.FINALIZED ? "finalized" : "latest"],
-    });
-
-    if (args.rawReturn) {
-      return result;
-    }
-    const resultBinary = fromHex(result, "bytes");
-    return calldata.decode(resultBinary) as any;
-  };
+    readContract: async <RawReturn extends boolean | undefined>(args: {
+      account?: Account;
+      address: Address;
+      functionName: string;
+      args?: CalldataEncodable[];
+      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
+      rawReturn?: RawReturn;
+      leaderOnly?: boolean;
+    }): Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable> => {
+      const {account, address, functionName, args: callArgs, kwargs, leaderOnly = false} = args;
+      const encodedData = [calldata.encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
+      const serializedData = serialize(encodedData);
+
+      const senderAddress = account?.address ?? client.account?.address;
+
+      const requestParams = {
+        type: "read",
+        to: address,
+        from: senderAddress,
+        data: serializedData,
+        transaction_hash_variant: "latest-final",
+      };
+      const result = await client.request({
+        method: "gen_call",
+        params: [requestParams],
+      });
+      const prefixedResult = `0x${result}` as `0x${string}`;
 
-  client.writeContract = async (args: {
-    account?: Account;
-    address: Address;
-    functionName: string;
-    args?: CalldataEncodable[];
-    kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-    value: bigint;
-    leaderOnly?: boolean;
-    consensusMaxRotations?: number;
-  }): Promise<`0x${string}`> => {
-    const {account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations} = args;
-    const data = [calldata.encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
-    const serializedData = serialize(data);
-    return _sendTransaction(address, serializedData, account || client.account, consensusMaxRotations, value);
+      if (args.rawReturn) {
+        return prefixedResult;
+      }
+      const resultBinary = fromHex(prefixedResult, "bytes");
+      return calldata.decode(resultBinary) as any;
+    },
+    writeContract: async (args: {
+      account?: Account;
+      address: Address;
+      functionName: string;
+      args?: CalldataEncodable[];
+      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
+      value: bigint;
+      leaderOnly?: boolean;
+      consensusMaxRotations?: number;
+    }): Promise<`0x${string}`> => {
+      const {
+        account,
+        address,
+        functionName,
+        args: callArgs,
+        kwargs,
+        value = 0n,
+        leaderOnly = false,
+        consensusMaxRotations = client.chain.defaultConsensusMaxRotations,
+      } = args;
+      const data = [calldata.encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
+      const serializedData = serialize(data);
+      return _sendTransaction({
+        client,
+        publicClient,
+        recipient: address,
+        data: serializedData,
+        senderAccount: account || client.account,
+        consensusMaxRotations,
+        value,
+      });
+    },
+    deployContract: async (args: {
+      account?: Account;
+      code: string | Uint8Array;
+      args?: CalldataEncodable[];
+      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
+      leaderOnly?: boolean;
+      consensusMaxRotations?: number;
+    }) => {
+      const {
+        account,
+        code,
+        args: constructorArgs,
+        kwargs,
+        leaderOnly = false,
+        consensusMaxRotations = client.chain.defaultConsensusMaxRotations,
+      } = args;
+      const data = [
+        code,
+        calldata.encode(makeCalldataObject(undefined, constructorArgs, kwargs)),
+        leaderOnly,
+      ];
+      const serializedData = serialize(data);
+      return _sendTransaction({
+        client,
+        publicClient: publicClient,
+        recipient: zeroAddress,
+        data: serializedData,
+        senderAccount: account || client.account,
+        consensusMaxRotations,
+      });
+    },
   };
+};
 
-  client.deployContract = async (args: {
-    account?: Account;
-    code: string | Uint8Array;
-    args?: CalldataEncodable[];
-    kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-    leaderOnly?: boolean;
-    consensusMaxRotations?: number;
-  }) => {
-    const {account, code, args: constructorArgs, kwargs, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations} = args;
-    const data = [code, calldata.encode(makeCalldataObject(undefined, constructorArgs, kwargs)), leaderOnly];
-    const serializedData = serialize(data);
-    return _sendTransaction(zeroAddress, serializedData, account || client.account, consensusMaxRotations);
-  };
+const _sendTransaction = async ({
+  client,
+  publicClient,
+  recipient,
+  data,
+  senderAccount,
+  consensusMaxRotations,
+  value,
+}: {
+  client: GenLayerClient<GenLayerChain>;
+  publicClient: PublicClient;
+  recipient: `0x${string}`;
+  data: `0x${string}`;
+  senderAccount?: Account;
+  consensusMaxRotations?: number;
+  value?: bigint;
+}) => {
+  if (!senderAccount) {
+    throw new Error(
+      "No account set. Configure the client with an account or pass an account to this function.",
+    );
+  }
 
-  const _sendTransaction = async (
-    recipient: `0x${string}`,
-    data: `0x${string}`,
-    senderAccount?: Account,
-    consensusMaxRotations?: number,
-    value?: bigint,
-  ) => {
-    if (!senderAccount) {
-      throw new Error(
-        "No account set. Configure the client with an account or pass an account to this function.",
-      );
-    }
+  if (!client.chain.consensusMainContract?.address) {
+    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
+  }
 
-    if (!client.chain.consensusMainContract?.address) {
-      throw new Error(
-        "Consensus main contract not initialized. Please ensure client is properly initialized.",
-      );
-    }
+  const encodedData = encodeFunctionData({
+    abi: client.chain.consensusMainContract?.abi as any,
+    functionName: "addTransaction",
+    args: [
+      senderAccount.address,
+      recipient,
+      client.chain.defaultNumberOfInitialValidators,
+      consensusMaxRotations,
+      data,
+    ],
+  });
+
+  const nonce = await client.getCurrentNonce({address: senderAccount.address});
+  const transactionRequest = await client.prepareTransactionRequest({
+    account: senderAccount,
+    to: client.chain.consensusMainContract?.address as Address,
+    data: encodedData,
+    type: "legacy",
+    nonce: Number(nonce),
+    value: value ?? 0n,
+  });
+
+  if (senderAccount?.type !== "local") {
+    const formattedRequest = {
+      from: transactionRequest.from,
+      to: transactionRequest.to,
+      data: encodedData,
+      value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
+    };
 
-    const encodedData = encodeFunctionData({
-      abi: client.chain.consensusMainContract?.abi as any,
-      functionName: "addTransaction",
-      args: [
-        senderAccount.address,
-        recipient,
-        client.chain.defaultNumberOfInitialValidators,
-        consensusMaxRotations,
-        data,
-      ],
+    return await client.request({
+      method: "eth_sendTransaction",
+      params: [formattedRequest as any],
     });
+  }
 
-    const nonce = await client.getCurrentNonce({address: senderAccount.address});
-    const transactionRequest = await client.prepareTransactionRequest({
-      account: senderAccount,
-      to: client.chain.consensusMainContract?.address as Address,
-      data: encodedData,
-      type: "legacy",
-      nonce,
-      value: value ?? 0n,
-    });
+  if (!senderAccount?.signTransaction) {
+    throw new Error("Account does not support signTransaction");
+  }
 
-    if (senderAccount?.type !== "local") {
-      const formattedRequest = {
-        from: transactionRequest.from,
-        to: transactionRequest.to,
-        data: encodedData,
-        value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
-      };
+  const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
 
-      return await client.request({
-        method: "eth_sendTransaction",
-        params: [formattedRequest as any],
-      });
-    }
+  const txHash = await client.sendRawTransaction({serializedTransaction: serializedTransaction});
+  const receipt = await publicClient.waitForTransactionReceipt({hash: txHash});
 
-    if (!senderAccount?.signTransaction) {
-      throw new Error("Account does not support signTransaction");
-    }
+  if (receipt.status === "reverted") {
+    throw new Error("Transaction reverted");
+  }
 
-    const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
+  const newTxEvents = parseEventLogs({
+    abi: client.chain.consensusMainContract?.abi as any,
+    eventName: "NewTransaction",
+    logs: receipt.logs,
+  }) as unknown as {args: {txId: `0x${string}`}}[];
 
-    return client.sendRawTransaction({serializedTransaction: serializedTransaction});
-  };
+  if (newTxEvents.length === 0) {
+    throw new Error("Transaction not processed by consensus");
+  }
 
-  return client;
+  return newTxEvents[0].args["txId"];
 };