genlayer-js 0.9.2 → 0.9.3

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 
 
+## 0.9.3 (2025-05-14)
+
 ## 0.9.2 (2025-05-14)
 
 ## 0.9.1 (2025-05-09)

package/dist/index.cjs

@@ -438,6 +438,20 @@ var contractActions = (client, publicClient) => {
         leaderOnly = false,
         transactionHashVariant = "latest-final" /* LATEST_FINAL */
       } = args;
+      if (client.chain.id === _chunkSMCXL465cjs.localnet.id) {
+        return _localnetReadContract({
+          client,
+          args: {
+            account,
+            address,
+            functionName,
+            args: callArgs,
+            kwargs,
+            stateStatus: transactionHashVariant === "latest-final" /* LATEST_FINAL */ ? "FINALIZED" /* FINALIZED */ : "ACCEPTED" /* ACCEPTED */,
+            rawReturn: _nullishCoalesce(args.rawReturn, () => ( false))
+          }
+        });
+      }
       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])));
@@ -508,6 +522,36 @@ var contractActions = (client, publicClient) => {
     }
   };
 };
+var _localnetReadContract = async ({
+  client,
+  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', _8 => _8.address]), () => ( _optionalChain([client, 'access', _9 => _9.account, 'optionalAccess', _10 => _10.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);
+};
 var _sendTransaction = async ({
   client,
   publicClient,
@@ -522,11 +566,11 @@ var _sendTransaction = async ({
       "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])) {
+  if (!_optionalChain([client, 'access', _11 => _11.chain, 'access', _12 => _12.consensusMainContract, 'optionalAccess', _13 => _13.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]),
+    abi: _optionalChain([client, 'access', _14 => _14.chain, 'access', _15 => _15.consensusMainContract, 'optionalAccess', _16 => _16.abi]),
     functionName: "addTransaction",
     args: [
       senderAccount.address,
@@ -539,13 +583,13 @@ var _sendTransaction = async ({
   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]),
+    to: _optionalChain([client, 'access', _17 => _17.chain, 'access', _18 => _18.consensusMainContract, 'optionalAccess', _19 => _19.address]),
     data: encodedData,
     type: "legacy",
     nonce: Number(nonce),
     value: _nullishCoalesce(value, () => ( 0n))
   });
-  if (_optionalChain([senderAccount, 'optionalAccess', _17 => _17.type]) !== "local") {
+  if (_optionalChain([senderAccount, 'optionalAccess', _20 => _20.type]) !== "local") {
     const formattedRequest = {
       from: transactionRequest.from,
       to: transactionRequest.to,
@@ -557,7 +601,7 @@ var _sendTransaction = async ({
       params: [formattedRequest]
     });
   }
-  if (!_optionalChain([senderAccount, 'optionalAccess', _18 => _18.signTransaction])) {
+  if (!_optionalChain([senderAccount, 'optionalAccess', _21 => _21.signTransaction])) {
     throw new Error("Account does not support signTransaction");
   }
   const serializedTransaction = await senderAccount.signTransaction(transactionRequest);
@@ -570,7 +614,7 @@ var _sendTransaction = async ({
     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]),
+    abi: _optionalChain([client, 'access', _22 => _22.chain, 'access', _23 => _23.consensusMainContract, 'optionalAccess', _24 => _24.abi]),
     eventName: "NewTransaction",
     logs: receipt.logs
   });
@@ -686,8 +730,8 @@ var transactionActions = (client, publicClient) => ({
       return _decodeLocalnetTransaction(transaction2);
     }
     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]),
+      address: _optionalChain([client, 'access', _25 => _25.chain, 'access', _26 => _26.consensusDataContract, 'optionalAccess', _27 => _27.address]),
+      abi: _optionalChain([client, 'access', _28 => _28.chain, 'access', _29 => _29.consensusDataContract, 'optionalAccess', _30 => _30.abi]),
       functionName: "getTransactionData",
       args: [
         hash,
@@ -775,7 +819,7 @@ var _decodeTransaction = (tx) => {
 var _decodeLocalnetTransaction = (tx) => {
   if (!tx.data) return tx;
   try {
-    const leaderReceipt = _optionalChain([tx, 'access', _28 => _28.consensus_data, 'optionalAccess', _29 => _29.leader_receipt]);
+    const leaderReceipt = _optionalChain([tx, 'access', _31 => _31.consensus_data, 'optionalAccess', _32 => _32.leader_receipt]);
     if (leaderReceipt) {
       if (leaderReceipt.result && typeof leaderReceipt.result === "string") {
         leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
@@ -795,7 +839,7 @@ var _decodeLocalnetTransaction = (tx) => {
         );
       }
     }
-    if (_optionalChain([tx, 'access', _30 => _30.data, 'optionalAccess', _31 => _31.calldata]) && typeof tx.data.calldata === "string") {
+    if (_optionalChain([tx, 'access', _33 => _33.data, 'optionalAccess', _34 => _34.calldata]) && typeof tx.data.calldata === "string") {
       tx.data.calldata = {
         base64: tx.data.calldata,
         ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
@@ -4848,7 +4892,7 @@ var connect = async (client, network = "studionet", snapSource = "npm") => {
     chainName: selectedNetwork.name,
     rpcUrls: selectedNetwork.rpcUrls.default.http,
     nativeCurrency: selectedNetwork.nativeCurrency,
-    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _32 => _32.blockExplorers, 'optionalAccess', _33 => _33.default, 'access', _34 => _34.url])]
+    blockExplorerUrls: [_optionalChain([selectedNetwork, 'access', _35 => _35.blockExplorers, 'optionalAccess', _36 => _36.default, 'access', _37 => _37.url])]
   };
   const currentChainId = await window.ethereum.request({ method: "eth_chainId" });
   if (currentChainId !== chainIdHex) {
@@ -4882,10 +4926,10 @@ var metamaskClient = async (snapSource = "npm") => {
   }
   const isFlask = async () => {
     try {
-      const clientVersion = await _optionalChain([window, 'access', _35 => _35.ethereum, 'optionalAccess', _36 => _36.request, 'call', _37 => _37({
+      const clientVersion = await _optionalChain([window, 'access', _38 => _38.ethereum, 'optionalAccess', _39 => _39.request, 'call', _40 => _40({
         method: "web3_clientVersion"
       })]);
-      return _optionalChain([clientVersion, 'optionalAccess', _38 => _38.includes, 'call', _39 => _39("flask")]);
+      return _optionalChain([clientVersion, 'optionalAccess', _41 => _41.includes, 'call', _42 => _42("flask")]);
     } catch (error) {
       console.error("Error detecting Flask:", error);
       return false;
@@ -4893,7 +4937,7 @@ var metamaskClient = async (snapSource = "npm") => {
   };
   const installedSnaps = async () => {
     try {
-      return await _optionalChain([window, 'access', _40 => _40.ethereum, 'optionalAccess', _41 => _41.request, 'call', _42 => _42({
+      return await _optionalChain([window, 'access', _43 => _43.ethereum, 'optionalAccess', _44 => _44.request, 'call', _45 => _45({
         method: "wallet_getSnaps"
       })]);
     } catch (error) {
@@ -4928,10 +4972,10 @@ function walletActions(client) {
 function chainActions(client) {
   return {
     initializeConsensusSmartContract: async (forceReset = false) => {
-      if (_optionalChain([client, 'access', _43 => _43.chain, 'optionalAccess', _44 => _44.id]) === _chunkSMCXL465cjs.testnetAsimov.id) {
+      if (_optionalChain([client, 'access', _46 => _46.chain, 'optionalAccess', _47 => _47.id]) === _chunkSMCXL465cjs.testnetAsimov.id) {
         return;
       }
-      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])) {
+      if (!forceReset && _optionalChain([client, 'access', _48 => _48.chain, 'access', _49 => _49.consensusMainContract, 'optionalAccess', _50 => _50.address]) && _optionalChain([client, 'access', _51 => _51.chain, 'access', _52 => _52.consensusMainContract, 'optionalAccess', _53 => _53.abi])) {
         return;
       }
       const contractsResponse = await fetch(client.chain.rpcUrls.default.http[0], {
@@ -4962,7 +5006,7 @@ var getCustomTransportConfig = (config) => {
     async request({ method, params = [] }) {
       if (method.startsWith("eth_") && isAddress) {
         try {
-          return await _optionalChain([window, 'access', _51 => _51.ethereum, 'optionalAccess', _52 => _52.request, 'call', _53 => _53({ method, params })]);
+          return await _optionalChain([window, 'access', _54 => _54.ethereum, 'optionalAccess', _55 => _55.request, 'call', _56 => _56({ method, params })]);
         } catch (err) {
           console.warn(`Error using window.ethereum for method ${method}:`, err);
           throw err;

package/dist/index.js

@@ -438,6 +438,20 @@ var contractActions = (client, publicClient) => {
         leaderOnly = false,
         transactionHashVariant = "latest-final" /* LATEST_FINAL */
       } = args;
+      if (client.chain.id === localnet.id) {
+        return _localnetReadContract({
+          client,
+          args: {
+            account,
+            address,
+            functionName,
+            args: callArgs,
+            kwargs,
+            stateStatus: transactionHashVariant === "latest-final" /* LATEST_FINAL */ ? "FINALIZED" /* FINALIZED */ : "ACCEPTED" /* ACCEPTED */,
+            rawReturn: args.rawReturn ?? false
+          }
+        });
+      }
       const encodedData = [encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
       const serializedData = serialize(encodedData);
       const senderAddress = account?.address ?? client.account?.address;
@@ -508,6 +522,36 @@ var contractActions = (client, publicClient) => {
     }
   };
 };
+var _localnetReadContract = async ({
+  client,
+  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);
+};
 var _sendTransaction = async ({
   client,
   publicClient,

package/package.json

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

package/src/contracts/actions.ts

@@ -1,5 +1,5 @@
 import * as calldata from "@/abi/calldata";
-import {serialize} from "@/abi/transactions";
+import {serialize, serializeOne} from "@/abi/transactions";
 import {localnet} from "@/chains/localnet";
 import {
   Account,
@@ -9,6 +9,7 @@ import {
   CalldataEncodable,
   Address,
   TransactionHashVariant,
+  TransactionStatus,
 } from "@/types";
 import {fromHex, toHex, zeroAddress, encodeFunctionData, PublicClient, parseEventLogs} from "viem";
 
@@ -90,6 +91,26 @@ export const contractActions = (client: GenLayerClient<GenLayerChain>, publicCli
         leaderOnly = false,
         transactionHashVariant = TransactionHashVariant.LATEST_FINAL,
       } = args;
+
+      // TODO: remove this once DXP-298 is merged
+      if (client.chain.id === localnet.id) {
+        return _localnetReadContract({
+          client,
+          args: {
+            account,
+            address,
+            functionName,
+            args: callArgs,
+            kwargs,
+            stateStatus:
+              transactionHashVariant === TransactionHashVariant.LATEST_FINAL
+                ? TransactionStatus.FINALIZED
+                : TransactionStatus.ACCEPTED,
+            rawReturn: args.rawReturn ?? false,
+          },
+        });
+      }
+
       const encodedData = [calldata.encode(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
       const serializedData = serialize(encodedData);
 
@@ -179,6 +200,51 @@ export const contractActions = (client: GenLayerClient<GenLayerChain>, publicCli
     },
   };
 };
+// TODO: remove this once DXP-298 is merged
+const _localnetReadContract = async ({
+  client,
+  args,
+}: {
+  client: GenLayerClient<GenLayerChain>;
+  args: {
+    account?: Account;
+    address: Address;
+    functionName: string;
+    args?: CalldataEncodable[];
+    kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
+    stateStatus?: TransactionStatus;
+    rawReturn?: boolean;
+  };
+}) => {
+  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;
+};
 
 const _sendTransaction = async ({
   client,