genlayer-js 0.8.0 → 0.9.1

package/dist/index.js

@@ -1,17 +1,27 @@
 import {
   chains_exports,
   localnet,
-  simulator
-} from "./chunk-WEXFFND6.js";
+  testnet
+} from "./chunk-7YZQQWJZ.js";
 import {
-  CalldataAddress
-} from "./chunk-K72OSU5N.js";
+  CalldataAddress,
+  transactionResultNumberToName,
+  transactionsStatusNameToNumber,
+  transactionsStatusNumberToName,
+  voteTypeNumberToName
+} from "./chunk-RS7NCSOQ.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
 
 // src/client/client.ts
-import { createClient as createViemClient, publicActions, custom, walletActions as walletActions2 } from "viem";
+import {
+  createClient as createViemClient,
+  createPublicClient as createPublicViemClient,
+  publicActions,
+  custom,
+  walletActions as walletActions2
+} from "viem";
 
 // src/accounts/actions.ts
 function accountActions(client) {
@@ -25,7 +35,10 @@ function accountActions(client) {
         params: [address, amount]
       });
     },
-    getCurrentNonce: async ({ address, block = "latest" }) => {
+    getCurrentNonce: async ({
+      address,
+      block = "latest"
+    }) => {
       const addressToUse = address || client.account?.address;
       if (!addressToUse) {
         throw new Error("No address provided and no account is connected");
@@ -366,7 +379,7 @@ function serialize(data) {
 }
 
 // src/contracts/actions.ts
-import { fromHex, toHex as toHex2, zeroAddress, encodeFunctionData } from "viem";
+import { fromHex, toHex as toHex2, zeroAddress, encodeFunctionData, parseEventLogs } from "viem";
 function makeCalldataObject(method, args, kwargs) {
   let ret = {};
   if (method) {
@@ -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 !== 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 !== localnet.id) {
+        throw new Error("Contract schema is not supported on this network");
+      }
       const schema = await client.request({
         method: "gen_getContractSchemaForCode",
         params: [toHex2(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 = 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}`;
+      if (args.rawReturn) {
+        return prefixedResult;
+      }
+      const resultBinary = fromHex(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: 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 = account?.address ?? client.account?.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 = fromHex(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(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 (!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,
-      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,
+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 (!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,
+    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,
+    data: encodedData,
+    type: "legacy",
+    nonce: Number(nonce),
+    value: value ?? 0n
+  });
+  if (senderAccount?.type !== "local") {
+    const formattedRequest = {
+      from: transactionRequest.from,
+      to: transactionRequest.to,
       data: encodedData,
-      type: "legacy",
-      nonce,
-      value: value ?? 0n
+      value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0"
+    };
+    return await client.request({
+      method: "eth_sendTransaction",
+      params: [formattedRequest]
     });
-    if (senderAccount?.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 (!senderAccount?.signTransaction) {
-      throw new Error("Account does not support signTransaction");
-    }
-    const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
-    return client.sendRawTransaction({ serializedTransaction });
-  };
-  return client;
+  }
+  if (!senderAccount?.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 = parseEventLogs({
+    abi: client.chain.consensusMainContract?.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
@@ -514,26 +580,84 @@ async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/abi/index.ts
+var abi_exports = {};
+__export(abi_exports, {
+  calldata: () => calldata,
+  transactions: () => transactions
+});
+var calldata = calldata_exports;
+var transactions = transactions_exports;
+
+// src/utils/jsonifier.ts
+function b64ToArray(b64) {
+  return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+}
+function calldataToUserFriendlyJson(cd) {
+  return {
+    raw: Array.from(cd),
+    readable: calldata.toString(calldata.decode(cd))
+  };
+}
+var RESULT_CODES = /* @__PURE__ */ new Map([
+  [0, "return"],
+  [1, "rollback"],
+  [2, "contract_error"],
+  [3, "error"],
+  [4, "none"],
+  [5, "no_leaders"]
+]);
+function resultToUserFriendlyJson(cd64) {
+  const raw = b64ToArray(cd64);
+  const code = RESULT_CODES.get(raw[0]);
+  let status;
+  let payload = null;
+  if (code === void 0) {
+    status = "<unknown>";
+  } else {
+    status = code;
+    if ([1, 2].includes(raw[0])) {
+      payload = new TextDecoder("utf-8").decode(raw.slice(1));
+    } else if (raw[0] == 0) {
+      payload = calldataToUserFriendlyJson(raw.slice(1));
+    }
+  }
+  return {
+    raw: cd64,
+    status,
+    payload
+  };
+}
+
 // src/transactions/actions.ts
-var transactionActions = (client) => ({
+import { fromRlp, fromHex as fromHex2 } from "viem";
+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 */) {
+    const transactionStatusString = String(transaction.status);
+    const transactionStatusFinalized = transactionsStatusNameToNumber["FINALIZED" /* FINALIZED */];
+    const requestedStatus = transactionsStatusNameToNumber[status];
+    if (transactionStatusString === requestedStatus || status === "ACCEPTED" /* ACCEPTED */ && transactionStatusString === transactionStatusFinalized) {
+      if (client.chain.id === 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,
@@ -541,6 +665,128 @@ var transactionActions = (client) => ({
     });
   }
 });
+var transactionActions = (client, publicClient) => ({
+  getTransaction: async ({ hash }) => {
+    const transaction = await publicClient.readContract({
+      address: client.chain.consensusDataContract?.address,
+      abi: client.chain.consensusDataContract?.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 = fromRlp(rlpEncodedAppData);
+    if (rlpDecodedArray.length === 3) {
+      return {
+        code: fromHex2(rlpDecodedArray[0], "string"),
+        constructorArgs: rlpDecodedArray[1] && rlpDecodedArray[1] !== "0x" ? decode(fromHex2(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(fromHex2(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) => {
+  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: transactionsStatusNumberToName[String(tx.status)],
+    resultName: 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) => voteTypeNumberToName[String(vote)]
+      )
+    }
+  };
+  return decodedTx;
+};
+var _decodeLocalnetTransaction = (tx) => {
+  try {
+    const leaderReceipt = tx.consensus_data?.leader_receipt;
+    if (leaderReceipt) {
+      if (leaderReceipt.result) {
+        leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
+      }
+      if (leaderReceipt.calldata) {
+        leaderReceipt.calldata = {
+          base64: leaderReceipt.calldata,
+          ...calldataToUserFriendlyJson(b64ToArray(leaderReceipt.calldata))
+        };
+      }
+      if (leaderReceipt.eq_outputs) {
+        leaderReceipt.eq_outputs = Object.fromEntries(
+          Object.entries(leaderReceipt.eq_outputs).map(([key, value]) => {
+            const decodedValue = new TextDecoder().decode(b64ToArray(String(value)));
+            return [key, resultToUserFriendlyJson(decodedValue)];
+          })
+        );
+      }
+    }
+    if (tx.data?.calldata) {
+      tx.data.calldata = {
+        base64: tx.data.calldata,
+        ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
+      };
+    }
+  } catch (e) {
+    console.error("Error in _decodeLocalnetTransaction:", e);
+  }
+  return tx;
+};
 
 // src/config/snapID.ts
 var snapID = {
@@ -584,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",
@@ -651,8 +895,8 @@ function walletActions(client) {
 function chainActions(client) {
   return {
     initializeConsensusSmartContract: async (forceReset = false) => {
-      if (client.chain?.id !== simulator.id) {
-        throw new Error("Client is not connected to the simulator");
+      if (client.chain?.id !== testnet.id) {
+        return;
       }
       if (!forceReset && client.chain.consensusMainContract?.address && client.chain.consensusMainContract?.abi) {
         return;
@@ -679,14 +923,10 @@ function chainActions(client) {
 }
 
 // src/client/client.ts
-var createClient = (config = { chain: localnet }) => {
-  const chainConfig = config.chain || 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 window.ethereum?.request({ method, params });
@@ -695,8 +935,11 @@ var createClient = (config = { 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"
@@ -720,15 +963,40 @@ var createClient = (config = { chain: localnet }) => {
       }
     }
   };
+};
+var createClient = (config = { chain: localnet }) => {
+  const chainConfig = config.chain || localnet;
+  if (config.endpoint) {
+    chainConfig.rpcUrls.default.http = [config.endpoint];
+  }
+  const customTransport = custom(getCustomTransportConfig(config));
+  const publicClient = createPublicClient(chainConfig, customTransport).extend(
+    publicActions
+  );
   const baseClient = createViemClient({
     chain: chainConfig,
-    transport: custom(customTransport),
+    transport: customTransport,
     ...config.account ? { account: config.account } : {}
-  }).extend(publicActions).extend(walletActions2).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(publicActions).extend(walletActions2).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 createPublicViemClient({ chain: chainConfig, transport: customTransport });
 };
 
 // src/accounts/account.ts
@@ -739,15 +1007,6 @@ var createAccount = (accountPrivateKey) => {
   const account = privateKeyToAccount(privateKey);
   return account;
 };
-
-// src/abi/index.ts
-var abi_exports = {};
-__export(abi_exports, {
-  calldata: () => calldata,
-  transactions: () => transactions
-});
-var calldata = calldata_exports;
-var transactions = transactions_exports;
 export {
   abi_exports as abi,
   chains_exports as chains,

package/dist/types/index.cjs

@@ -1,9 +1,25 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunkYDFRDDP5cjs = require('../chunk-YDFRDDP5.cjs');
+
+
+
+
+
+
+
+
+var _chunkAZSICIZ3cjs = require('../chunk-AZSICIZ3.cjs');
 require('../chunk-75ZPJI57.cjs');
 
 
 
-exports.CalldataAddress = _chunkYDFRDDP5cjs.CalldataAddress; exports.TransactionStatus = _chunkYDFRDDP5cjs.TransactionStatus;
+
+
+
+
+
+
+
+
+exports.CalldataAddress = _chunkAZSICIZ3cjs.CalldataAddress; exports.TransactionResult = _chunkAZSICIZ3cjs.TransactionResult; exports.TransactionResultNameToNumber = _chunkAZSICIZ3cjs.TransactionResultNameToNumber; exports.TransactionStatus = _chunkAZSICIZ3cjs.TransactionStatus; exports.VoteType = _chunkAZSICIZ3cjs.VoteType; exports.transactionResultNumberToName = _chunkAZSICIZ3cjs.transactionResultNumberToName; exports.transactionsStatusNameToNumber = _chunkAZSICIZ3cjs.transactionsStatusNameToNumber; exports.transactionsStatusNumberToName = _chunkAZSICIZ3cjs.transactionsStatusNumberToName; exports.voteTypeNameToNumber = _chunkAZSICIZ3cjs.voteTypeNameToNumber; exports.voteTypeNumberToName = _chunkAZSICIZ3cjs.voteTypeNumberToName;

package/dist/types/index.d.cts

@@ -1,3 +1,3 @@
-export { A as Address, a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, G as GenLayerClient, b as GenLayerMethod, j as GenLayerTransaction, M as MethodDescription, N as Network, S as SnapSource, k as TransactionDataElement, h as TransactionHash, i as TransactionStatus } from '../index-BfeTR7rO.cjs';
-export { S as SimulatorChain } from '../chains-C5PI_Nr_.cjs';
-export { Account } from 'viem';
+export { Account, Address } from 'viem';
+export { a as CalldataAddress, C as CalldataEncodable, f as ContractMethod, e as ContractMethodBase, c as ContractParamsArraySchemaElement, d as ContractParamsSchema, g as ContractSchema, p as DecodedCallData, D as DecodedDeployData, G as GenLayerClient, b as GenLayerMethod, r as GenLayerRawTransaction, q as GenLayerTransaction, H as Hash, M as MethodDescription, N as Network, S as SnapSource, h as TransactionHash, j as TransactionResult, m as TransactionResultNameToNumber, i as TransactionStatus, o as TransactionType, V as VoteType, l as transactionResultNumberToName, k as transactionsStatusNameToNumber, t as transactionsStatusNumberToName, n as voteTypeNameToNumber, v as voteTypeNumberToName } from '../index-kDM_9wW1.cjs';
+export { G as GenLayerChain } from '../chains-BYSCF33g.cjs';