genlayer-js 0.9.0 → 0.9.1

package/dist/index.cjs

@@ -2,22 +2,32 @@
 
 
 
-var _chunkI6HC44KDcjs = require('./chunk-I6HC44KD.cjs');
+var _chunkFPFZLPXIcjs = require('./chunk-FPFZLPXI.cjs');
 
 
-var _chunkYDFRDDP5cjs = require('./chunk-YDFRDDP5.cjs');
+
+
+
+
+var _chunkAZSICIZ3cjs = require('./chunk-AZSICIZ3.cjs');
 
 
 var _chunk75ZPJI57cjs = 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]) !== _chunkI6HC44KDcjs.localnet.id) {
+      if (_optionalChain([client, 'access', _ => _.chain, 'optionalAccess', _2 => _2.id]) !== _chunkFPFZLPXIcjs.localnet.id) {
         throw new Error("Client is not connected to the localnet");
       }
       return client.request({
@@ -25,7 +35,10 @@ function accountActions(client) {
         params: [address, amount]
       });
     },
-    getCurrentNonce: async ({ address, block = "latest" }) => {
+    getCurrentNonce: async ({
+      address,
+      block = "latest"
+    }) => {
       const addressToUse = address || _optionalChain([client, 'access', _3 => _3.account, 'optionalAccess', _4 => _4.address]);
       if (!addressToUse) {
         throw new Error("No address provided and no account is connected");
@@ -168,7 +181,7 @@ function encodeImpl(to, data) {
         }
       } else if (data instanceof Map) {
         encodeMap(to, data);
-      } else if (data instanceof _chunkYDFRDDP5cjs.CalldataAddress) {
+      } else if (data instanceof _chunkAZSICIZ3cjs.CalldataAddress) {
         to.push(SPECIAL_ADDR);
         for (const c of data.bytes) {
           to.push(c);
@@ -217,7 +230,7 @@ function decodeImpl(data, index) {
     case BigInt(SPECIAL_ADDR): {
       const res = data.slice(index.i, index.i + 20);
       index.i += 20;
-      return new (0, _chunkYDFRDDP5cjs.CalldataAddress)(res);
+      return new (0, _chunkAZSICIZ3cjs.CalldataAddress)(res);
     }
   }
   const type = Number(cur & 0xffn) & (1 << BITS_IN_TYPE) - 1;
@@ -329,7 +342,7 @@ function toStringImpl(data, to) {
         to.push("]");
       } else if (data instanceof Map) {
         toStringImplMap(data.entries(), to);
-      } else if (data instanceof _chunkYDFRDDP5cjs.CalldataAddress) {
+      } else if (data instanceof _chunkAZSICIZ3cjs.CalldataAddress) {
         to.push("addr#");
         for (const c of data.bytes) {
           to.push(c.toString(16));
@@ -393,9 +406,12 @@ function makeCalldataObject(method, args, kwargs) {
   }
   return ret;
 }
-var contractActions = (client) => {
+var contractActions = (client, publicClient) => {
   return {
     getContractSchema: async (address) => {
+      if (client.chain.id !== _chunkFPFZLPXIcjs.localnet.id) {
+        throw new Error("Contract schema is not supported on this network");
+      }
       const schema = await client.request({
         method: "gen_getContractSchema",
         params: [address]
@@ -403,104 +419,154 @@ var contractActions = (client) => {
       return schema;
     },
     getContractSchemaForCode: async (contractCode) => {
+      if (client.chain.id !== _chunkFPFZLPXIcjs.localnet.id) {
+        throw new Error("Contract schema is not supported on this network");
+      }
       const schema = await client.request({
         method: "gen_getContractSchemaForCode",
         params: [_viem.toHex.call(void 0, contractCode)]
       });
       return schema;
+    },
+    readContract: async (args) => {
+      const { account, address, functionName, args: callArgs, kwargs, leaderOnly = false } = args;
+      const encodedData = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
+      const serializedData = serialize(encodedData);
+      const senderAddress = _nullishCoalesce(_optionalChain([account, 'optionalAccess', _5 => _5.address]), () => ( _optionalChain([client, 'access', _6 => _6.account, 'optionalAccess', _7 => _7.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}`;
+      if (args.rawReturn) {
+        return prefixedResult;
+      }
+      const resultBinary = _viem.fromHex.call(void 0, prefixedResult, "bytes");
+      return decode(resultBinary);
+    },
+    writeContract: async (args) => {
+      const {
+        account,
+        address,
+        functionName,
+        args: callArgs,
+        kwargs,
+        value = 0n,
+        leaderOnly = false,
+        consensusMaxRotations = client.chain.defaultConsensusMaxRotations
+      } = args;
+      const data = [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) => {
+      const {
+        account,
+        code,
+        args: constructorArgs,
+        kwargs,
+        leaderOnly = false,
+        consensusMaxRotations = client.chain.defaultConsensusMaxRotations
+      } = args;
+      const data = [
+        code,
+        encode(makeCalldataObject(void 0, constructorArgs, kwargs)),
+        leaderOnly
+      ];
+      const serializedData = serialize(data);
+      return _sendTransaction({
+        client,
+        publicClient,
+        recipient: _viem.zeroAddress,
+        data: serializedData,
+        senderAccount: account || client.account,
+        consensusMaxRotations
+      });
     }
   };
 };
-var overrideContractActions = (client) => {
-  client.readContract = async (args) => {
-    const {
-      account,
-      address,
-      functionName,
-      args: callArgs,
-      kwargs,
-      stateStatus = "ACCEPTED" /* ACCEPTED */
-    } = args;
-    const encodedData = encode(makeCalldataObject(functionName, callArgs, kwargs));
-    const serializedData = serializeOne(encodedData);
-    const senderAddress = _nullishCoalesce(_optionalChain([account, 'optionalAccess', _5 => _5.address]), () => ( _optionalChain([client, 'access', _6 => _6.account, 'optionalAccess', _7 => _7.address])));
-    const requestParams = {
-      to: address,
-      from: senderAddress,
-      data: serializedData
-    };
-    const result = await client.request({
-      method: "eth_call",
-      params: [requestParams, stateStatus == "FINALIZED" /* FINALIZED */ ? "finalized" : "latest"]
-    });
-    if (args.rawReturn) {
-      return result;
-    }
-    const resultBinary = _viem.fromHex.call(void 0, result, "bytes");
-    return decode(resultBinary);
-  };
-  client.writeContract = async (args) => {
-    const { account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations } = args;
-    const data = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
-    const serializedData = serialize(data);
-    return _sendTransaction(address, serializedData, account || client.account, consensusMaxRotations, value);
-  };
-  client.deployContract = async (args) => {
-    const { account, code, args: constructorArgs, kwargs, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations } = args;
-    const data = [code, encode(makeCalldataObject(void 0, constructorArgs, kwargs)), leaderOnly];
-    const serializedData = serialize(data);
-    return _sendTransaction(_viem.zeroAddress, serializedData, account || client.account, consensusMaxRotations);
-  };
-  const _sendTransaction = async (recipient, data, senderAccount, consensusMaxRotations, value) => {
-    if (!senderAccount) {
-      throw new Error(
-        "No account set. Configure the client with an account or pass an account to this function."
-      );
-    }
-    if (!_optionalChain([client, 'access', _8 => _8.chain, 'access', _9 => _9.consensusMainContract, 'optionalAccess', _10 => _10.address])) {
-      throw new Error(
-        "Consensus main contract not initialized. Please ensure client is properly initialized."
-      );
-    }
-    const encodedData = _viem.encodeFunctionData.call(void 0, {
-      abi: _optionalChain([client, 'access', _11 => _11.chain, 'access', _12 => _12.consensusMainContract, 'optionalAccess', _13 => _13.abi]),
-      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: _optionalChain([client, 'access', _14 => _14.chain, 'access', _15 => _15.consensusMainContract, 'optionalAccess', _16 => _16.address]),
+var _sendTransaction = async ({
+  client,
+  publicClient,
+  recipient,
+  data,
+  senderAccount,
+  consensusMaxRotations,
+  value
+}) => {
+  if (!senderAccount) {
+    throw new Error(
+      "No account set. Configure the client with an account or pass an account to this function."
+    );
+  }
+  if (!_optionalChain([client, 'access', _8 => _8.chain, 'access', _9 => _9.consensusMainContract, 'optionalAccess', _10 => _10.address])) {
+    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
+  }
+  const encodedData = _viem.encodeFunctionData.call(void 0, {
+    abi: _optionalChain([client, 'access', _11 => _11.chain, 'access', _12 => _12.consensusMainContract, 'optionalAccess', _13 => _13.abi]),
+    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: _optionalChain([client, 'access', _14 => _14.chain, 'access', _15 => _15.consensusMainContract, 'optionalAccess', _16 => _16.address]),
+    data: encodedData,
+    type: "legacy",
+    nonce: Number(nonce),
+    value: _nullishCoalesce(value, () => ( 0n))
+  });
+  if (_optionalChain([senderAccount, 'optionalAccess', _17 => _17.type]) !== "local") {
+    const formattedRequest = {
+      from: transactionRequest.from,
+      to: transactionRequest.to,
       data: encodedData,
-      type: "legacy",
-      nonce,
-      value: _nullishCoalesce(value, () => ( 0n))
+      value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0"
+    };
+    return await client.request({
+      method: "eth_sendTransaction",
+      params: [formattedRequest]
     });
-    if (_optionalChain([senderAccount, 'optionalAccess', _17 => _17.type]) !== "local") {
-      const formattedRequest = {
-        from: transactionRequest.from,
-        to: transactionRequest.to,
-        data: encodedData,
-        value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0"
-      };
-      return await client.request({
-        method: "eth_sendTransaction",
-        params: [formattedRequest]
-      });
-    }
-    if (!_optionalChain([senderAccount, 'optionalAccess', _18 => _18.signTransaction])) {
-      throw new Error("Account does not support signTransaction");
-    }
-    const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
-    return client.sendRawTransaction({ serializedTransaction });
-  };
-  return client;
+  }
+  if (!_optionalChain([senderAccount, 'optionalAccess', _18 => _18.signTransaction])) {
+    throw new Error("Account does not support signTransaction");
+  }
+  const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
+  const txHash = await client.sendRawTransaction({ serializedTransaction });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+  if (receipt.status === "reverted") {
+    throw new Error("Transaction reverted");
+  }
+  const newTxEvents = _viem.parseEventLogs.call(void 0, {
+    abi: _optionalChain([client, 'access', _19 => _19.chain, 'access', _20 => _20.consensusMainContract, 'optionalAccess', _21 => _21.abi]),
+    eventName: "NewTransaction",
+    logs: receipt.logs
+  });
+  if (newTxEvents.length === 0) {
+    throw new Error("Transaction not processed by consensus");
+  }
+  return newTxEvents[0].args["txId"];
 };
 
 // src/config/transactions.ts
@@ -564,25 +630,34 @@ function resultToUserFriendlyJson(cd64) {
 }
 
 // src/transactions/actions.ts
-var transactionActions = (client) => ({
+
+var receiptActions = (client, publicClient) => ({
   waitForTransactionReceipt: async ({
     hash,
     status = "ACCEPTED" /* ACCEPTED */,
     interval = transactionsConfig.waitInterval,
     retries = transactionsConfig.retries
   }) => {
-    const transaction = await client.getTransaction({ hash });
+    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 _decodeTransaction(transaction);
+    const transactionStatusString = String(transaction.status);
+    const transactionStatusFinalized = _chunkAZSICIZ3cjs.transactionsStatusNameToNumber["FINALIZED" /* FINALIZED */];
+    const requestedStatus = _chunkAZSICIZ3cjs.transactionsStatusNameToNumber[status];
+    if (transactionStatusString === requestedStatus || status === "ACCEPTED" /* ACCEPTED */ && transactionStatusString === transactionStatusFinalized) {
+      if (client.chain.id === _chunkFPFZLPXIcjs.localnet.id) {
+        return _decodeLocalnetTransaction(transaction);
+      }
+      return transaction;
     }
     if (retries === 0) {
       throw new Error("Transaction status is not " + status);
     }
     await sleep(interval);
-    return transactionActions(client).waitForTransactionReceipt({
+    return receiptActions(client, publicClient).waitForTransactionReceipt({
       hash,
       status,
       interval,
@@ -590,10 +665,98 @@ var transactionActions = (client) => ({
     });
   }
 });
+var transactionActions = (client, publicClient) => ({
+  getTransaction: async ({ hash }) => {
+    const transaction = await publicClient.readContract({
+      address: _optionalChain([client, 'access', _22 => _22.chain, 'access', _23 => _23.consensusDataContract, 'optionalAccess', _24 => _24.address]),
+      abi: _optionalChain([client, 'access', _25 => _25.chain, 'access', _26 => _26.consensusDataContract, 'optionalAccess', _27 => _27.abi]),
+      functionName: "getTransactionData",
+      args: [
+        hash,
+        Math.round((/* @__PURE__ */ new Date()).getTime() / 1e3)
+        // unix seconds
+      ]
+    });
+    return _decodeTransaction(transaction);
+  }
+});
+var _decodeInputData = (rlpEncodedAppData, recipient) => {
+  if (!rlpEncodedAppData || rlpEncodedAppData === "0x" || rlpEncodedAppData.length <= 2) {
+    return null;
+  }
+  try {
+    const rlpDecodedArray = _viem.fromRlp.call(void 0, rlpEncodedAppData);
+    if (rlpDecodedArray.length === 3) {
+      return {
+        code: _viem.fromHex.call(void 0, rlpDecodedArray[0], "string"),
+        constructorArgs: rlpDecodedArray[1] && rlpDecodedArray[1] !== "0x" ? decode(_viem.fromHex.call(void 0, rlpDecodedArray[1], "bytes")) : null,
+        leaderOnly: rlpDecodedArray[2] === "0x01",
+        type: "deploy",
+        contractAddress: recipient
+      };
+    } else if (rlpDecodedArray.length === 2) {
+      return {
+        callData: rlpDecodedArray[0] && rlpDecodedArray[0] !== "0x" ? decode(_viem.fromHex.call(void 0, rlpDecodedArray[0], "bytes")) : null,
+        leaderOnly: rlpDecodedArray[1] === "0x01",
+        type: "call"
+      };
+    } else {
+      console.warn(
+        "[decodeInputData] WRITE: Unexpected RLP array length:",
+        rlpDecodedArray.length,
+        rlpDecodedArray
+      );
+      return null;
+    }
+  } catch (e) {
+    console.error(
+      "[decodeInputData] Error during comprehensive decoding:",
+      e,
+      "Raw RLP App Data:",
+      rlpEncodedAppData
+    );
+    return null;
+  }
+};
 var _decodeTransaction = (tx) => {
-  if (!tx.data) return tx;
+  const txDataDecoded = _decodeInputData(tx.txData, tx.recipient);
+  const decodedTx = {
+    ...tx,
+    txData: tx.txData,
+    txDataDecoded,
+    currentTimestamp: tx.currentTimestamp.toString(),
+    numOfInitialValidators: tx.numOfInitialValidators.toString(),
+    txSlot: tx.txSlot.toString(),
+    createdTimestamp: tx.createdTimestamp.toString(),
+    lastVoteTimestamp: tx.lastVoteTimestamp.toString(),
+    queuePosition: tx.queuePosition.toString(),
+    numOfRounds: tx.numOfRounds.toString(),
+    readStateBlockRange: {
+      ...tx.readStateBlockRange,
+      activationBlock: tx.readStateBlockRange.activationBlock.toString(),
+      processingBlock: tx.readStateBlockRange.processingBlock.toString(),
+      proposalBlock: tx.readStateBlockRange.proposalBlock.toString()
+    },
+    statusName: _chunkAZSICIZ3cjs.transactionsStatusNumberToName[String(tx.status)],
+    resultName: _chunkAZSICIZ3cjs.transactionResultNumberToName[String(tx.result)],
+    lastRound: {
+      ...tx.lastRound,
+      round: tx.lastRound.round.toString(),
+      leaderIndex: tx.lastRound.leaderIndex.toString(),
+      votesCommitted: tx.lastRound.votesCommitted.toString(),
+      votesRevealed: tx.lastRound.votesRevealed.toString(),
+      appealBond: tx.lastRound.appealBond.toString(),
+      rotationsLeft: tx.lastRound.rotationsLeft.toString(),
+      validatorVotesName: tx.lastRound.validatorVotes.map(
+        (vote) => _chunkAZSICIZ3cjs.voteTypeNumberToName[String(vote)]
+      )
+    }
+  };
+  return decodedTx;
+};
+var _decodeLocalnetTransaction = (tx) => {
   try {
-    const leaderReceipt = _optionalChain([tx, 'access', _19 => _19.consensus_data, 'optionalAccess', _20 => _20.leader_receipt]);
+    const leaderReceipt = _optionalChain([tx, 'access', _28 => _28.consensus_data, 'optionalAccess', _29 => _29.leader_receipt]);
     if (leaderReceipt) {
       if (leaderReceipt.result) {
         leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
@@ -613,14 +776,14 @@ var _decodeTransaction = (tx) => {
         );
       }
     }
-    if (tx.data.calldata) {
+    if (_optionalChain([tx, 'access', _30 => _30.data, 'optionalAccess', _31 => _31.calldata])) {
       tx.data.calldata = {
         base64: tx.data.calldata,
         ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
       };
     }
   } catch (e) {
-    console.error("Error decoding transaction:", e);
+    console.error("Error in _decodeLocalnetTransaction:", e);
   }
   return tx;
 };
@@ -633,7 +796,7 @@ var snapID = {
 
 // src/wallet/connect.ts
 var networks = {
-  localnet: _chunkI6HC44KDcjs.localnet
+  localnet: _chunkFPFZLPXIcjs.localnet
 };
 var connect = async (client, network = "localnet", snapSource = "npm") => {
   if (!window.ethereum) {
@@ -652,7 +815,7 @@ var connect = async (client, network = "localnet", snapSource = "npm") => {
     chainName: selectedNetwork.name,
     rpcUrls: selectedNetwork.rpcUrls.default.http,
     nativeCurrency: selectedNetwork.nativeCurrency,
-    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _21 => _21.blockExplorers, 'optionalAccess', _22 => _22.default, 'access', _23 => _23.url])]
+    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _32 => _32.blockExplorers, 'optionalAccess', _33 => _33.default, 'access', _34 => _34.url])]
   };
   const currentChainId = await window.ethereum.request({ method: "eth_chainId" });
   if (currentChainId !== chainIdHex) {
@@ -667,9 +830,7 @@ var connect = async (client, network = "localnet", snapSource = "npm") => {
   }
   const id = snapSource === "local" ? snapID.local : snapID.npm;
   const installedSnaps = await window.ethereum.request({ method: "wallet_getSnaps" });
-  const isGenLayerSnapInstalled = Object.values(installedSnaps).some(
-    (snap) => snap.id === id
-  );
+  const isGenLayerSnapInstalled = Object.values(installedSnaps).some((snap) => snap.id === id);
   if (!isGenLayerSnapInstalled) {
     await window.ethereum.request({
       method: "wallet_requestSnaps",
@@ -688,10 +849,10 @@ var metamaskClient = async (snapSource = "npm") => {
   }
   const isFlask = async () => {
     try {
-      const clientVersion = await _optionalChain([window, 'access', _24 => _24.ethereum, 'optionalAccess', _25 => _25.request, 'call', _26 => _26({
+      const clientVersion = await _optionalChain([window, 'access', _35 => _35.ethereum, 'optionalAccess', _36 => _36.request, 'call', _37 => _37({
         method: "web3_clientVersion"
       })]);
-      return _optionalChain([clientVersion, 'optionalAccess', _27 => _27.includes, 'call', _28 => _28("flask")]);
+      return _optionalChain([clientVersion, 'optionalAccess', _38 => _38.includes, 'call', _39 => _39("flask")]);
     } catch (error) {
       console.error("Error detecting Flask:", error);
       return false;
@@ -699,7 +860,7 @@ var metamaskClient = async (snapSource = "npm") => {
   };
   const installedSnaps = async () => {
     try {
-      return await _optionalChain([window, 'access', _29 => _29.ethereum, 'optionalAccess', _30 => _30.request, 'call', _31 => _31({
+      return await _optionalChain([window, 'access', _40 => _40.ethereum, 'optionalAccess', _41 => _41.request, 'call', _42 => _42({
         method: "wallet_getSnaps"
       })]);
     } catch (error) {
@@ -734,10 +895,10 @@ function walletActions(client) {
 function chainActions(client) {
   return {
     initializeConsensusSmartContract: async (forceReset = false) => {
-      if (_optionalChain([client, 'access', _32 => _32.chain, 'optionalAccess', _33 => _33.id]) !== _chunkI6HC44KDcjs.simulator.id) {
-        throw new Error("Client is not connected to the simulator");
+      if (_optionalChain([client, 'access', _43 => _43.chain, 'optionalAccess', _44 => _44.id]) !== _chunkFPFZLPXIcjs.testnet.id) {
+        return;
       }
-      if (!forceReset && _optionalChain([client, 'access', _34 => _34.chain, 'access', _35 => _35.consensusMainContract, 'optionalAccess', _36 => _36.address]) && _optionalChain([client, 'access', _37 => _37.chain, 'access', _38 => _38.consensusMainContract, 'optionalAccess', _39 => _39.abi])) {
+      if (!forceReset && _optionalChain([client, 'access', _45 => _45.chain, 'access', _46 => _46.consensusMainContract, 'optionalAccess', _47 => _47.address]) && _optionalChain([client, 'access', _48 => _48.chain, 'access', _49 => _49.consensusMainContract, 'optionalAccess', _50 => _50.abi])) {
         return;
       }
       const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
@@ -762,24 +923,23 @@ function chainActions(client) {
 }
 
 // src/client/client.ts
-var createClient = (config = { chain: _chunkI6HC44KDcjs.localnet }) => {
-  const chainConfig = config.chain || _chunkI6HC44KDcjs.localnet;
-  if (config.endpoint) {
-    chainConfig.rpcUrls.default.http = [config.endpoint];
-  }
+var getCustomTransportConfig = (config) => {
   const isAddress = typeof config.account !== "object";
-  const customTransport = {
-    async request({ method, params }) {
+  return {
+    async request({ method, params = [] }) {
       if (method.startsWith("eth_") && isAddress) {
         try {
-          return await _optionalChain([window, 'access', _40 => _40.ethereum, 'optionalAccess', _41 => _41.request, 'call', _42 => _42({ method, params })]);
+          return await _optionalChain([window, 'access', _51 => _51.ethereum, 'optionalAccess', _52 => _52.request, 'call', _53 => _53({ method, params })]);
         } catch (err) {
           console.warn(`Error using window.ethereum for method ${method}:`, err);
           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"
@@ -803,15 +963,40 @@ var createClient = (config = { chain: _chunkI6HC44KDcjs.localnet }) => {
       }
     }
   };
+};
+var createClient = (config = { chain: _chunkFPFZLPXIcjs.localnet }) => {
+  const chainConfig = config.chain || _chunkFPFZLPXIcjs.localnet;
+  if (config.endpoint) {
+    chainConfig.rpcUrls.default.http = [config.endpoint];
+  }
+  const customTransport = _viem.custom.call(void 0, getCustomTransportConfig(config));
+  const publicClient = createPublicClient(chainConfig, customTransport).extend(
+    _viem.publicActions
+  );
   const baseClient = _viem.createClient.call(void 0, {
     chain: chainConfig,
-    transport: _viem.custom.call(void 0, customTransport),
+    transport: customTransport,
     ...config.account ? { account: config.account } : {}
-  }).extend(_viem.publicActions).extend(_viem.walletActions).extend((client) => accountActions(client)).extend((client) => transactionActions(client)).extend((client) => contractActions(client)).extend((client) => chainActions(client)).extend((client) => walletActions(client));
-  baseClient.initializeConsensusSmartContract().catch((error) => {
+  });
+  const clientWithBasicActions = baseClient.extend(_viem.publicActions).extend(_viem.walletActions).extend((client) => accountActions(client));
+  const clientWithAllActions = {
+    ...clientWithBasicActions,
+    ...contractActions(clientWithBasicActions, publicClient),
+    ...chainActions(clientWithBasicActions),
+    ...walletActions(clientWithBasicActions),
+    ...transactionActions(clientWithBasicActions, publicClient)
+  };
+  const finalClient = {
+    ...clientWithAllActions,
+    ...receiptActions(clientWithAllActions, publicClient)
+  };
+  finalClient.initializeConsensusSmartContract().catch((error) => {
     console.error("Failed to initialize consensus smart contract:", error);
   });
-  return overrideContractActions(baseClient);
+  return finalClient;
+};
+var createPublicClient = (chainConfig, customTransport) => {
+  return _viem.createPublicClient.call(void 0, { chain: chainConfig, transport: customTransport });
 };
 
 // src/accounts/account.ts
@@ -828,4 +1013,4 @@ var createAccount = (accountPrivateKey) => {
 
 
 
-exports.abi = abi_exports; exports.chains = _chunkI6HC44KDcjs.chains_exports; exports.createAccount = createAccount; exports.createClient = createClient; exports.generatePrivateKey = generatePrivateKey;
+exports.abi = abi_exports; exports.chains = _chunkFPFZLPXIcjs.chains_exports; exports.createAccount = createAccount; exports.createClient = createClient; exports.generatePrivateKey = generatePrivateKey;

package/dist/index.d.cts

@@ -1,11 +1,11 @@
 import * as viem from 'viem';
 import { Account, Address } from 'viem';
-import { S as SimulatorChain } from './chains-C5PI_Nr_.cjs';
-import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-BCbofn6t.cjs';
+import { G as GenLayerChain } from './chains-BYSCF33g.cjs';
+import { G as GenLayerClient, C as CalldataEncodable, T as TransactionDataElement } from './index-kDM_9wW1.cjs';
 import * as abitype from 'abitype';
-import * as viem__types_experimental_eip7702_types_authorization from 'viem/_types/experimental/eip7702/types/authorization';
+import * as viem__types_types_authorization from 'viem/_types/types/authorization';
 import * as viem_accounts from 'viem/accounts';
-export { i as chains } from './index-B8E0qiOq.cjs';
+export { i as chains } from './index-BM9hOtGg.cjs';
 
 interface ClientConfig {
     chain?: {
@@ -31,7 +31,7 @@ interface ClientConfig {
     endpoint?: string;
     account?: Account | Address;
 }
-declare const createClient: (config?: ClientConfig) => GenLayerClient<SimulatorChain>;
+declare const createClient: (config?: ClientConfig) => GenLayerClient<GenLayerChain>;
 
 declare const generatePrivateKey: () => `0x${string}`;
 declare const createAccount: (accountPrivateKey?: `0x${string}`) => {
@@ -40,7 +40,7 @@ declare const createAccount: (accountPrivateKey?: `0x${string}`) => {
     sign: (parameters: {
         hash: viem.Hash;
     }) => Promise<viem.Hex>;
-    experimental_signAuthorization: (parameters: viem__types_experimental_eip7702_types_authorization.Authorization) => Promise<viem_accounts.SignAuthorizationReturnType>;
+    signAuthorization: (parameters: viem__types_types_authorization.AuthorizationRequest) => Promise<viem_accounts.SignAuthorizationReturnType>;
     signMessage: ({ message }: {
         message: viem.SignableMessage;
     }) => Promise<viem.Hex>;