seismic-viem 1.1.2 → 2.0.0

package/dist/_cjs/index.js

@@ -32,6 +32,8 @@ __export(exports_src, {
   watchSRC20EventsWithKey: () => watchSRC20EventsWithKey,
   watchSRC20Events: () => watchSRC20Events,
   txExplorerUrl: () => txExplorerUrl,
+  transparentWriteContract: () => transparentWriteContract,
+  transparentReadContract: () => transparentReadContract,
   tokenExplorerUrl: () => tokenExplorerUrl,
   stringifyBigInt: () => stringifyBigInt,
   src20WalletActions: () => src20WalletActions,
@@ -61,6 +63,7 @@ __export(exports_src, {
   localSeismicDevnet: () => localSeismicDevnet,
   hdfkPrecompile: () => hdfkPrecompile,
   hdfk: () => hdfk,
+  hasShieldedParams: () => hasShieldedParams,
   getShieldedContract: () => getShieldedContract,
   getPlaintextCalldata: () => getPlaintextCalldata,
   getKeyHash: () => getKeyHash,
@@ -219,12 +222,14 @@ var seismicTxTypedData = (tx) => {
   if (tx.signedRead === undefined) {
     throw new Error("Seismic transactions require signedRead");
   }
+  const isCreate = tx.to === undefined || tx.to === null;
   const message = {
     chainId: tx.chainId,
     nonce: tx.nonce !== undefined ? BigInt(tx.nonce) : undefined,
     gasPrice: tx.gasPrice && BigInt(tx.gasPrice),
     gasLimit: tx.gas && BigInt(tx.gas),
-    to: tx.to,
+    to: isCreate ? "0x0000000000000000000000000000000000000000" : tx.to,
+    isCreate,
     value: tx.value ? BigInt(tx.value) : 0n,
     input: tx.data ?? "0x",
     encryptionPubkey: tx.encryptionPubkey,
@@ -248,6 +253,7 @@ var seismicTxTypedData = (tx) => {
         { name: "gasPrice", type: "uint128" },
         { name: "gasLimit", type: "uint64" },
         { name: "to", type: "address" },
+        { name: "isCreate", type: "bool" },
         { name: "value", type: "uint256" },
         { name: "input", type: "bytes" },
         { name: "encryptionPubkey", type: "bytes" },
@@ -283,13 +289,14 @@ var signSeismicTxTypedData = async (client, tx) => {
 };
 
 // src/metadata.ts
+var DEFAULT_SEISMIC_BLOCKS_WINDOW = 100n;
 var fillNonce = async (client, parameters) => {
   let account = import_accounts.parseAccount(parameters.account || client.account);
   const { nonce: nonce_ } = parameters;
   if (nonce_ !== undefined) {
     return nonce_;
   }
-  const { blockNumber, blockTag = "latest" } = parameters;
+  const { blockNumber, blockTag = "pending" } = parameters;
   let args = {
     address: account.address,
     blockTag
@@ -303,7 +310,7 @@ var inferTypedDataTx = (typedDataTx, account) => {
   if (typedDataTx !== undefined) {
     return typedDataTx;
   }
-  return account.type === "json-rpc";
+  return account.type === "json-rpc" || account.type === "local";
 };
 var buildTxSeismicMetadata = async (client, {
   account: paramsAcct,
@@ -311,7 +318,7 @@ var buildTxSeismicMetadata = async (client, {
   to,
   value = 0n,
   encryptionNonce,
-  blocksWindow = 100n,
+  blocksWindow = DEFAULT_SEISMIC_BLOCKS_WINDOW,
   recentBlockHash,
   expiresAtBlock,
   typedDataTx,
@@ -420,7 +427,8 @@ var serializeSeismicTransaction = (tx, signature) => {
     messageVersion = 0,
     recentBlockHash,
     expiresAtBlock,
-    signedRead = false
+    signedRead = false,
+    authorizationList
   } = tx;
   if (chainId === undefined) {
     throw new Error("Seismic transactions require chainId");
@@ -466,6 +474,14 @@ var serializeSeismicTransaction = (tx, signature) => {
     import_viem4.toHex(expiresAtBlock),
     signedRead ? "0x01" : "0x",
     data ?? "0x",
+    (authorizationList ?? []).map((auth) => [
+      auth.chainId ? import_viem4.toHex(auth.chainId) : "0x",
+      auth.contractAddress,
+      auth.nonce ? import_viem4.toHex(auth.nonce) : "0x",
+      auth.yParity ? import_viem4.toHex(auth.yParity) : "0x",
+      auth.r,
+      auth.s
+    ]),
     ...toYParitySignatureArray(tx, signature)
   ];
   const rlpEncoded = import_viem4.toRlp(rlpArray);
@@ -485,13 +501,27 @@ var seismicRpcSchema = [estimateGasRpcSchema, callRpcSchema];
 var hasSeismicFields = (request) => {
   return request.encryptionPubkey !== undefined && request.encryptionNonce !== undefined && request.messageVersion !== undefined && request.recentBlockHash !== undefined && request.expiresAtBlock !== undefined && request.signedRead !== undefined;
 };
+var formatAuthorizationList = (authorizationList) => authorizationList.map((authorization) => ({
+  address: authorization.contractAddress,
+  r: authorization.r,
+  s: authorization.s,
+  chainId: import_viem4.toHex(authorization.chainId),
+  nonce: import_viem4.toHex(authorization.nonce),
+  ...typeof authorization.yParity !== "undefined" ? { yParity: import_viem4.toHex(authorization.yParity) } : {},
+  ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: import_viem4.toHex(authorization.v) } : {}
+}));
 var fmtRpcRequest = (request) => {
   if (request.type === "seismic") {
+    const { authorizationList, ...legacyCompatibleRequest } = request;
     const seismicFmt = import_viem4.formatTransactionRequest({
-      ...request,
+      ...legacyCompatibleRequest,
       type: "legacy"
     });
-    return { ...seismicFmt, type: SEISMIC_TX_TYPE };
+    return {
+      ...seismicFmt,
+      type: SEISMIC_TX_TYPE,
+      ...authorizationList ? { authorizationList: formatAuthorizationList(authorizationList) } : {}
+    };
   }
   const { type, ...fmt } = import_viem4.formatTransactionRequest(request);
   if (hasSeismicFields(request)) {
@@ -606,11 +636,11 @@ var sanvil = /* @__PURE__ */ import_viem4.defineChain({
   testnet: true
 });
 // src/contract/contract.ts
-var import_viem12 = require("viem");
-var import_actions4 = require("viem/actions");
+var import_viem13 = require("viem");
 
 // src/contract/read.ts
 var import_viem9 = require("viem");
+var import_actions3 = require("viem/actions");
 var import_utils2 = require("viem/utils");
 
 // src/contract/abi.ts
@@ -658,6 +688,12 @@ var remapSeismicParam = (param) => {
   }
   return { shielded: false, type: ty };
 };
+function hasShieldedParams(abi, functionName) {
+  const abiItem = import_viem5.getAbiItem({ abi, name: functionName });
+  if (!abiItem?.inputs)
+    return false;
+  return abiItem.inputs.some((param) => remapSeismicParam(param).shielded);
+}
 var remapSeismicAbiInputs = (abiFunction) => {
   return {
     type: abiFunction.type,
@@ -670,7 +706,7 @@ var remapSeismicAbiInputs = (abiFunction) => {
   };
 };
 
-// src/signedCall.ts
+// src/tx/signedCall.ts
 var import_viem8 = require("viem");
 var import_actions2 = require("viem/actions");
 var import_utils = require("viem/utils");
@@ -701,9 +737,9 @@ function getRevertErrorData(err) {
   return typeof error?.data === "object" ? error.data?.data : error.data;
 }
 
-// src/signedCall.ts
+// src/tx/signedCall.ts
 var doSignedCall = async (client, seismicTx, { block }) => {
-  if (client.account?.type === "json-rpc") {
+  if (client.account?.type === "json-rpc" || client.account?.type === "local") {
     const { typedData, signature } = await signSeismicTxTypedData(client, seismicTx);
     const response2 = await client.publicRequest({
       method: "eth_call",
@@ -727,18 +763,19 @@ var prepareAccount = (paramsAccount, clientAccount) => {
   }
   return account;
 };
-async function signedCall(client, args, { blocksWindow = 100n, encryptionNonce } = {}) {
+async function signedCall(client, args, {
+  blocksWindow,
+  encryptionNonce,
+  recentBlockHash,
+  expiresAtBlock
+} = {}) {
   const {
     account: account_ = client.account,
-    batch = Boolean(client.batch?.multicall),
     blockNumber,
     blockTag = "latest",
     accessList,
     blobs,
-    code,
     data: plaintextCalldata,
-    factory,
-    factoryData,
     gas = 30000000,
     gasPrice,
     maxFeePerBlobGas,
@@ -782,6 +819,8 @@ async function signedCall(client, args, { blocksWindow = 100n, encryptionNonce }
       to,
       blocksWindow,
       encryptionNonce,
+      recentBlockHash,
+      expiresAtBlock,
       signedRead: true
     });
     const encryptedCalldata = await client.encrypt(plaintextCalldata, metadata);
@@ -831,6 +870,20 @@ async function signedCall(client, args, { blocksWindow = 100n, encryptionNonce }
 }
 
 // src/contract/read.ts
+async function smartReadContract(walletClient, readClient, parameters, securityParams, forcedAccount) {
+  const readArgs = parameters;
+  if (hasShieldedParams(readArgs.abi, readArgs.functionName)) {
+    const account = forcedAccount ?? walletClient?.account;
+    if (!walletClient || !account) {
+      throw new Error("Wallet must have an account to perform signed reads");
+    }
+    return signedReadContract(walletClient, {
+      ...parameters,
+      account
+    }, securityParams);
+  }
+  return import_actions3.readContract(readClient, parameters);
+}
 async function signedReadContract(client, parameters, securityParams) {
   const {
     abi,
@@ -857,20 +910,58 @@ async function signedReadContract(client, parameters, securityParams) {
     data: data || "0x"
   });
 }
+async function transparentReadContract(client, parameters) {
+  const {
+    abi,
+    functionName,
+    args = [],
+    address,
+    ...rest
+  } = parameters;
+  const seismicAbi = import_viem9.getAbiItem({ abi, name: functionName });
+  const selector = import_viem9.toFunctionSelector(import_utils2.formatAbiItem(seismicAbi));
+  const ethAbi = remapSeismicAbiInputs(seismicAbi);
+  const encodedParams = import_viem9.encodeAbiParameters(ethAbi.inputs, args).slice(2);
+  const data = `${selector}${encodedParams}`;
+  const callOptions = rest;
+  const { data: result } = await client.call({
+    to: address,
+    data,
+    ...callOptions
+  });
+  return import_viem9.decodeFunctionResult({
+    abi,
+    args,
+    functionName,
+    data: result || "0x"
+  });
+}
 
 // src/contract/write.ts
-var import_viem11 = require("viem");
-var import_utils4 = require("viem/utils");
+var import_viem12 = require("viem");
+var import_actions5 = require("viem/actions");
 
-// src/sendTransaction.ts
-var import_accounts2 = require("viem/accounts");
-var import_actions3 = require("viem/actions");
+// src/contract/calldata.ts
+var import_viem10 = require("viem");
 var import_utils3 = require("viem/utils");
+var getPlaintextCalldata = (parameters) => {
+  const { abi, functionName, args = [] } = parameters;
+  const seismicAbi = import_viem10.getAbiItem({ abi, name: functionName });
+  const selector = import_viem10.toFunctionSelector(import_utils3.formatAbiItem(seismicAbi));
+  const ethAbi = remapSeismicAbiInputs(seismicAbi);
+  const encodedParams = import_viem10.encodeAbiParameters(ethAbi.inputs, args).slice(2);
+  return `${selector}${encodedParams}`;
+};
+
+// src/tx/sendShielded.ts
+var import_accounts2 = require("viem/accounts");
+var import_actions4 = require("viem/actions");
+var import_utils4 = require("viem/utils");
 
 // src/error/account.ts
-var import_viem10 = require("viem");
+var import_viem11 = require("viem");
 
-class AccountNotFoundError extends import_viem10.BaseError {
+class AccountNotFoundError extends import_viem11.BaseError {
   constructor({ docsPath } = {}) {
     super([
       "Could not find an Account to execute with this Action.",
@@ -884,7 +975,7 @@ class AccountNotFoundError extends import_viem10.BaseError {
   }
 }
 
-class AccountTypeNotSupportedError extends import_viem10.BaseError {
+class AccountTypeNotSupportedError extends import_viem11.BaseError {
   constructor({
     docsPath,
     metaMessages,
@@ -898,8 +989,13 @@ class AccountTypeNotSupportedError extends import_viem10.BaseError {
   }
 }
 
-// src/sendTransaction.ts
-async function sendShieldedTransaction(client, parameters, { blocksWindow = 100n, encryptionNonce } = {}) {
+// src/tx/sendShielded.ts
+async function sendShieldedTransaction(client, parameters, {
+  blocksWindow,
+  encryptionNonce,
+  recentBlockHash,
+  expiresAtBlock
+} = {}) {
   const {
     account: account_ = client.account,
     chain = client.chain,
@@ -930,7 +1026,7 @@ async function sendShieldedTransaction(client, parameters, { blocksWindow = 100n
       maxPriorityFeePerGas,
       to: parameters.to
     };
-    import_utils3.assertRequest(assertRequestParams);
+    import_utils4.assertRequest(assertRequestParams);
     const to = await (async () => {
       if (parameters.to)
         return parameters.to;
@@ -944,19 +1040,25 @@ async function sendShieldedTransaction(client, parameters, { blocksWindow = 100n
         value,
         blocksWindow,
         signedRead: false,
-        encryptionNonce
+        encryptionNonce,
+        recentBlockHash,
+        expiresAtBlock
       });
       const encryptedCalldata = await client.encrypt(plaintextCalldata, metadata);
-      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
-      const request = {
-        ...import_utils3.extract({ ...rest, ...metadata.seismicElements, type: "seismic" }, { format: chainFormat }),
+      const resolvedGasPrice = gasPrice ?? maxFeePerGas ?? await client.getGasPrice();
+      const resolvedGas = gas ?? await estimateShieldedGas(client, {
+        encryptedData: encryptedCalldata,
+        metadata,
+        gasPrice: resolvedGasPrice
+      });
+      const prepRequest = {
         accessList,
         authorizationList,
         blobs,
         chainId: metadata.legacyFields.chainId,
-        data: encryptedCalldata,
+        data: plaintextCalldata,
         from: account.address,
-        gas,
+        gas: resolvedGas,
         gasPrice,
         maxFeePerBlobGas,
         maxFeePerGas,
@@ -964,24 +1066,27 @@ async function sendShieldedTransaction(client, parameters, { blocksWindow = 100n
         nonce: metadata.legacyFields.nonce,
         to,
         value,
-        type: "legacy",
         ...rest
       };
-      const { type: _legacy, ...viemPreparedTx } = await import_actions3.prepareTransactionRequest(client, request);
+      const viemPreparedTx = await import_actions4.prepareTransactionRequest(client, prepRequest);
       const preparedTx = {
         ...viemPreparedTx,
+        ...metadata.seismicElements,
+        data: encryptedCalldata,
+        gasPrice: resolvedGasPrice,
         type: "seismic"
       };
       if (metadata.seismicElements.messageVersion === TYPED_DATA_MESSAGE_VERSION) {
         const { typedData, signature } = await signSeismicTxTypedData(client, preparedTx);
-        const action = import_utils3.getAction(client, import_actions3.sendRawTransaction, "sendRawTransaction");
+        const action = import_utils4.getAction(client, import_actions4.sendRawTransaction, "sendRawTransaction");
         return await action({
           serializedTransaction: { data: typedData, signature }
         });
-      } else {
-        const serializedTransaction = await account.signTransaction(preparedTx, { serializer: serializeSeismicTransaction });
-        return await import_actions3.sendRawTransaction(client, { serializedTransaction });
       }
+      const serializedTransaction = await account.signTransaction(preparedTx, {
+        serializer: serializeSeismicTransaction
+      });
+      return await import_actions4.sendRawTransaction(client, { serializedTransaction });
     }
     if (account?.type === "smart")
       throw new AccountTypeNotSupportedError({
@@ -996,7 +1101,7 @@ async function sendShieldedTransaction(client, parameters, { blocksWindow = 100n
   } catch (err) {
     if (err instanceof AccountTypeNotSupportedError)
       throw err;
-    throw import_utils3.getTransactionError(err, {
+    throw import_utils4.getTransactionError(err, {
       ...parameters,
       account,
       chain: chain || undefined,
@@ -1004,39 +1109,78 @@ async function sendShieldedTransaction(client, parameters, { blocksWindow = 100n
     });
   }
 }
+async function estimateShieldedGas(client, {
+  encryptedData,
+  metadata,
+  gasPrice
+}) {
+  const block = await client.getBlock({ blockTag: "latest" });
+  const blockGasLimit = block.gasLimit;
+  const tempTx = {
+    type: "seismic",
+    chainId: metadata.legacyFields.chainId,
+    nonce: metadata.legacyFields.nonce,
+    gasPrice,
+    gas: blockGasLimit,
+    to: metadata.legacyFields.to ?? undefined,
+    value: metadata.legacyFields.value,
+    data: encryptedData,
+    ...metadata.seismicElements
+  };
+  const isEip712 = metadata.seismicElements.messageVersion === TYPED_DATA_MESSAGE_VERSION;
+  if (isEip712) {
+    const { typedData, signature } = await signSeismicTxTypedData(client, tempTx);
+    const response2 = await client.request({
+      method: "eth_estimateGas",
+      params: [{ data: typedData, signature }]
+    });
+    return BigInt(response2);
+  }
+  const serializedTransaction = await client.account.signTransaction(tempTx, {
+    serializer: serializeSeismicTransaction
+  });
+  const response = await client.request({
+    method: "eth_estimateGas",
+    params: [serializedTransaction]
+  });
+  return BigInt(response);
+}
 
 // src/contract/write.ts
-var getPlaintextCalldata = (parameters) => {
-  const { abi, functionName, args = [] } = parameters;
-  const seismicAbi = import_viem11.getAbiItem({ abi, name: functionName });
-  const selector = import_viem11.toFunctionSelector(import_utils4.formatAbiItem(seismicAbi));
-  const ethAbi = remapSeismicAbiInputs(seismicAbi);
-  const encodedParams = import_viem11.encodeAbiParameters(ethAbi.inputs, args).slice(2);
-  const plaintextCalldata = `${selector}${encodedParams}`;
-  return plaintextCalldata;
-};
-async function getShieldedWriteContractRequest(client, parameters, plaintextCalldata) {
-  const { address, gas, gasPrice, value, nonce } = parameters;
-  return {
-    account: client.account,
-    chain: undefined,
+async function smartWriteContract(client, parameters) {
+  const writeArgs = parameters;
+  if (hasShieldedParams(writeArgs.abi, writeArgs.functionName)) {
+    return shieldedWriteContract(client, parameters);
+  }
+  return import_actions5.writeContract(client, parameters);
+}
+async function transparentWriteContract(client, parameters) {
+  const {
+    abi: _abi,
+    functionName: _fn,
+    args: _args,
+    address,
+    ...txOptions
+  } = parameters;
+  const data = getPlaintextCalldata(parameters);
+  return client.sendTransaction({
     to: address,
-    data: plaintextCalldata,
-    nonce,
-    value,
-    gas,
-    gasPrice
-  };
+    data,
+    ...txOptions
+  });
 }
-async function shieldedWriteContract(client, parameters) {
+async function shieldedWriteContract(client, parameters, securityParams) {
   const plaintextCalldata = getPlaintextCalldata(parameters);
-  const request = await getShieldedWriteContractRequest(client, parameters, plaintextCalldata);
-  return sendShieldedTransaction(client, request);
+  const request = buildShieldedWriteRequest(client, parameters, plaintextCalldata);
+  return sendShieldedTransaction(client, request, securityParams);
 }
-async function shieldedWriteContractDebug(client, parameters, checkContractDeployed, {
-  blocksWindow = 100n,
-  encryptionNonce: userEncNonce
-} = {}) {
+async function shieldedWriteContractDebug(client, parameters, checkContractDeployed, securityParams = {}) {
+  const {
+    blocksWindow,
+    encryptionNonce: userEncNonce,
+    recentBlockHash,
+    expiresAtBlock
+  } = securityParams;
   if (checkContractDeployed) {
     const code = await client.getCode({ address: parameters.address });
     if (code === undefined) {
@@ -1044,7 +1188,7 @@ async function shieldedWriteContractDebug(client, parameters, checkContractDeplo
     }
   }
   const plaintextCalldata = getPlaintextCalldata(parameters);
-  const request = await getShieldedWriteContractRequest(client, parameters, plaintextCalldata);
+  const request = buildShieldedWriteRequest(client, parameters, plaintextCalldata);
   const encryptionNonce = userEncNonce ?? randomEncryptionNonce();
   const metadata = await buildTxSeismicMetadata(client, {
     account: parameters.account || client.account,
@@ -1053,30 +1197,46 @@ async function shieldedWriteContractDebug(client, parameters, checkContractDeplo
     value: request.value,
     encryptionNonce,
     blocksWindow,
+    recentBlockHash,
+    expiresAtBlock,
     signedRead: false
   });
   const txHash = await sendShieldedTransaction(client, request, {
-    blocksWindow,
-    encryptionNonce
+    encryptionNonce,
+    recentBlockHash: metadata.seismicElements.recentBlockHash,
+    expiresAtBlock: metadata.seismicElements.expiresAtBlock
   });
   return {
     plaintextTx: {
       to: request.to || null,
       data: plaintextCalldata,
-      type: import_viem11.numberToHex(SEISMIC_TX_TYPE),
+      type: import_viem12.numberToHex(SEISMIC_TX_TYPE),
       nonce: request.nonce,
       gas: request.gas,
       gasPrice: request.gasPrice,
       value: request.value
     },
     shieldedTx: {
-      type: import_viem11.numberToHex(SEISMIC_TX_TYPE),
+      type: import_viem12.numberToHex(SEISMIC_TX_TYPE),
       ...request,
       ...metadata.seismicElements
     },
     txHash
   };
 }
+function buildShieldedWriteRequest(client, parameters, plaintextCalldata) {
+  const { address, gas, gasPrice, value, nonce } = parameters;
+  return {
+    account: client.account,
+    chain: undefined,
+    to: address,
+    data: plaintextCalldata,
+    nonce,
+    value,
+    gas,
+    gasPrice
+  };
+}
 
 // src/viem-internal/function.ts
 function getFunctionParameters(values) {
@@ -1092,7 +1252,7 @@ function getShieldedContract({
   address,
   client
 }) {
-  const viemContract = import_viem12.getContract({ abi, address, client });
+  const viemContract = import_viem13.getContract({ abi, address, client });
   const walletClient = (() => {
     if (!client)
       return;
@@ -1100,6 +1260,17 @@ function getShieldedContract({
       return client.wallet;
     return client;
   })();
+  const readClient = (() => {
+    if (!client)
+      return;
+    if ("public" in client) {
+      return client.public;
+    }
+    if ("wallet" in client) {
+      return client.wallet;
+    }
+    return client;
+  })();
   const transparentWriteAction = new Proxy({}, {
     get(_, functionName) {
       return (...parameters) => {
@@ -1107,7 +1278,7 @@ function getShieldedContract({
           throw new Error("Must provide wallet client to call Contract.write");
         }
         const { args, options } = getFunctionParameters(parameters);
-        return import_actions4.writeContract(walletClient, {
+        return transparentWriteContract(walletClient, {
           abi,
           address,
           functionName,
@@ -1149,6 +1320,22 @@ function getShieldedContract({
       ...options
     });
   }
+  function smartWrite({
+    functionName,
+    args,
+    ...options
+  }) {
+    if (walletClient === undefined) {
+      throw new Error("Must provide wallet client to call Contract.write");
+    }
+    return smartWriteContract(walletClient, {
+      abi,
+      address,
+      functionName,
+      args,
+      ...options
+    });
+  }
   const shieldedWriteAction = new Proxy({}, {
     get(_, functionName) {
       return (...parameters) => {
@@ -1183,25 +1370,29 @@ function getShieldedContract({
     }
     return signedReadContract(walletClient, params);
   }
-  const readAction = new Proxy({}, {
+  function smartRead(params) {
+    if (readClient === undefined) {
+      throw new Error("Must provide a client to call Contract.read");
+    }
+    return smartReadContract(walletClient, readClient, params, undefined, walletClient?.account);
+  }
+  const transparentReadAction = new Proxy({}, {
     get(_, functionName) {
       return (...parameters) => {
         const { args, options } = getFunctionParameters(parameters);
-        if (!options?.account) {
-          return import_actions4.readContract(walletClient, {
-            abi,
-            address,
-            functionName,
-            args,
-            ...options
-          });
+        const opts = options;
+        if (opts?.account !== undefined) {
+          throw new Error("Contract.tread is always transparent. Seismic zeroes out `from` on transparent `eth_call`, so `account` would be ignored on the node and cause silent bugs. Remove `account` or use `contract.sread`.");
         }
-        return signedRead({
+        if (readClient === undefined) {
+          throw new Error("Must provide a client to call Contract.tread");
+        }
+        return transparentReadContract(readClient, {
           abi,
           address,
           functionName,
           args,
-          ...options
+          ...opts
         });
       };
     }
@@ -1216,7 +1407,7 @@ function getShieldedContract({
         const params = getFunctionParameters(parameters);
         const { args } = params;
         const {
-          options: { account, ...options }
+          options: { account: _account, ...options }
         } = params;
         return signedRead({
           abi,
@@ -1229,20 +1420,50 @@ function getShieldedContract({
       };
     }
   });
+  const smartReadAction = new Proxy({}, {
+    get(_, functionName) {
+      return (...parameters) => {
+        const { args, options } = getFunctionParameters(parameters);
+        return smartRead({
+          abi,
+          address,
+          functionName,
+          args,
+          ...options
+        });
+      };
+    }
+  });
+  const smartWriteAction = new Proxy({}, {
+    get(_, functionName) {
+      return (...parameters) => {
+        const { args, options } = getFunctionParameters(parameters);
+        return smartWrite({
+          abi,
+          address,
+          functionName,
+          args,
+          ...options
+        });
+      };
+    }
+  });
   const contract = viemContract;
   contract.twrite = transparentWriteAction;
-  contract.tread = readAction;
-  contract.write = shieldedWriteAction;
+  contract.tread = transparentReadAction;
+  contract.swrite = shieldedWriteAction;
+  contract.sread = signedReadAction;
+  contract.write = smartWriteAction;
+  contract.read = smartReadAction;
   contract.dwrite = shieldedWriteDebugAction;
-  contract.read = signedReadAction;
   return contract;
 }
 // src/client.ts
-var import_viem23 = require("viem");
-var import_accounts3 = require("viem/accounts");
+var import_viem24 = require("viem");
+var import_accounts4 = require("viem/accounts");
 
 // src/actions/depositContract.ts
-var import_actions5 = require("viem/actions");
+var import_actions6 = require("viem/actions");
 
 // src/abis/depositContract.ts
 var depositContractAbi = [
@@ -1330,19 +1551,19 @@ var depositContractAbi = [
 // src/actions/depositContract.ts
 var DEPOSIT_CONTRACT_ADDRESS = "0x00000000219ab540356cBB839Cbe05303d7705Fa";
 var depositContractPublicActions = (client) => ({
-  getDepositRoot: async (args) => import_actions5.readContract(client, {
+  getDepositRoot: async (args) => import_actions6.readContract(client, {
     abi: depositContractAbi,
     address: args.address || DEPOSIT_CONTRACT_ADDRESS,
     functionName: "get_deposit_root"
   }),
-  getDepositCount: async (args) => import_actions5.readContract(client, {
+  getDepositCount: async (args) => import_actions6.readContract(client, {
     abi: depositContractAbi,
     address: args.address || DEPOSIT_CONTRACT_ADDRESS,
     functionName: "get_deposit_count"
   })
 });
 var depositContractWalletActions = (client) => ({
-  deposit: async (args) => import_actions5.writeContract(client, {
+  deposit: async (args) => import_actions6.writeContract(client, {
     abi: depositContractAbi,
     address: args.address || DEPOSIT_CONTRACT_ADDRESS,
     functionName: "deposit",
@@ -1359,7 +1580,7 @@ var depositContractWalletActions = (client) => ({
 });
 
 // src/crypto/aead.ts
-var import_viem13 = require("viem");
+var import_viem14 = require("viem");
 var encodeSeismicMetadataAsAAD = ({
   sender,
   legacyFields: { chainId, nonce, to, value },
@@ -1374,22 +1595,22 @@ var encodeSeismicMetadataAsAAD = ({
 }) => {
   const fields = [
     sender,
-    import_viem13.toHex(chainId),
-    nonce === 0 ? "0x" : import_viem13.toHex(nonce),
+    import_viem14.toHex(chainId),
+    nonce === 0 ? "0x" : import_viem14.toHex(nonce),
     to ?? "0x",
-    value === 0n ? "0x" : import_viem13.toHex(value),
+    value === 0n ? "0x" : import_viem14.toHex(value),
     encryptionPubkey,
     encryptionNonce === "0x00" || encryptionNonce === "0x0" ? "0x" : encryptionNonce,
-    messageVersion === 0 ? "0x" : import_viem13.toHex(messageVersion),
+    messageVersion === 0 ? "0x" : import_viem14.toHex(messageVersion),
     recentBlockHash,
-    import_viem13.toHex(expiresAtBlock),
+    import_viem14.toHex(expiresAtBlock),
     signedRead ? "0x01" : "0x"
   ];
-  return import_viem13.toRlp(fields, "bytes");
+  return import_viem14.toRlp(fields, "bytes");
 };
 
 // src/crypto/aes.ts
-var import_viem14 = require("viem");
+var import_viem15 = require("viem");
 
 // ../../node_modules/@noble/hashes/esm/_assert.js
 function anumber2(n) {
@@ -3425,7 +3646,7 @@ var _0n5 = BigInt(0);
 var Point = secp256k1.ProjectivePoint;
 
 // ../../node_modules/@noble/hashes/esm/hkdf.js
-function extract3(hash, ikm, salt) {
+function extract2(hash, ikm, salt) {
   ahash(hash);
   if (salt === undefined)
     salt = new Uint8Array(hash.outputLen);
@@ -3457,7 +3678,7 @@ function expand(hash, prk, info, length = 32) {
   HKDF_COUNTER.fill(0);
   return okm.slice(0, length);
 }
-var hkdf = (hash, ikm, salt, info, length) => expand(hash, extract3(hash, ikm, salt), info, length);
+var hkdf = (hash, ikm, salt, info, length) => expand(hash, extract2(hash, ikm, salt), info, length);
 
 // src/crypto/aes.ts
 class AesGcmCrypto {
@@ -3466,7 +3687,7 @@ class AesGcmCrypto {
   U64_SIZE = 8;
   constructor(key) {
     this.key = key;
-    const keyBuffer = import_viem14.hexToBytes(key);
+    const keyBuffer = import_viem15.hexToBytes(key);
     if (keyBuffer.length !== 32) {
       throw new Error("Key must be 32 bytes (256 bits)");
     }
@@ -3481,34 +3702,34 @@ class AesGcmCrypto {
     return nonceBuffer;
   }
   validateAndConvertNonce(nonce) {
-    const nonceBuffer = import_viem14.hexToBytes(nonce);
+    const nonceBuffer = import_viem15.hexToBytes(nonce);
     if (nonceBuffer.length !== this.NONCE_LENGTH) {
       throw new Error("Nonce must be 12 bytes");
     }
     return nonceBuffer;
   }
   createNonce(num) {
-    return import_viem14.bytesToHex(this.numberToNonce(num));
+    return import_viem15.bytesToHex(this.numberToNonce(num));
   }
   async encrypt(plaintext, nonce, aad) {
     if (!plaintext || plaintext === "0x") {
       return "0x";
     }
     const nonceBuffer = new Uint8Array(typeof nonce === "string" ? this.validateAndConvertNonce(nonce) : this.numberToNonce(nonce));
-    const key = import_viem14.hexToBytes(this.key);
-    const plaintextBytes = import_viem14.hexToBytes(plaintext);
+    const key = import_viem15.hexToBytes(this.key);
+    const plaintextBytes = import_viem15.hexToBytes(plaintext);
     const ciphertextBytes = await gcm(key, nonceBuffer, aad).encrypt(plaintextBytes);
-    return import_viem14.bytesToHex(ciphertextBytes);
+    return import_viem15.bytesToHex(ciphertextBytes);
   }
   async decrypt(ciphertext, nonce, aad) {
     if (!ciphertext || ciphertext === "0x") {
       return "0x";
     }
     const nonceBuffer = new Uint8Array(typeof nonce === "string" ? this.validateAndConvertNonce(nonce) : this.numberToNonce(nonce));
-    const key = import_viem14.hexToBytes(this.key);
-    const ciphertextBytes = import_viem14.hexToBytes(ciphertext);
+    const key = import_viem15.hexToBytes(this.key);
+    const ciphertextBytes = import_viem15.hexToBytes(ciphertext);
     const plaintextBytes = await gcm(key, nonceBuffer, aad).decrypt(ciphertextBytes);
-    return import_viem14.bytesToHex(plaintextBytes);
+    return import_viem15.bytesToHex(plaintextBytes);
   }
 }
 var sharedSecretPoint = ({
@@ -3521,15 +3742,15 @@ var sharedSecretPoint = ({
 var sharedKeyFromPoint = (sharedSecret) => {
   const version = sharedSecret[63] & 1 | 2;
   const finalSecret = sha2562.create().update(new Uint8Array([version])).update(sharedSecret.slice(0, 32)).digest();
-  return import_viem14.bytesToHex(finalSecret).slice(2);
+  return import_viem15.bytesToHex(finalSecret).slice(2);
 };
 var generateSharedKey = (inputs) => {
   const sharedSecret = sharedSecretPoint(inputs);
   return sharedKeyFromPoint(sharedSecret);
 };
 var deriveAesKey = (sharedSecret) => {
-  const derivedKey = hkdf(sha2562, import_viem14.hexToBytes(`0x${sharedSecret}`), new Uint8Array(0), new TextEncoder().encode("aes-gcm key"), 32);
-  return import_viem14.bytesToHex(derivedKey);
+  const derivedKey = hkdf(sha2562, import_viem15.hexToBytes(`0x${sharedSecret}`), new Uint8Array(0), new TextEncoder().encode("aes-gcm key"), 32);
+  return import_viem15.bytesToHex(derivedKey);
 };
 var generateAesKey = (aesKeys) => {
   const sharedSecret = generateSharedKey(aesKeys);
@@ -3619,13 +3840,13 @@ var tokenExplorerUrl = ({
 };
 
 // src/precompiles/aes.ts
-var import_viem16 = require("viem");
+var import_viem17 = require("viem");
 
 // src/precompiles/precompile.ts
-var import_viem15 = require("viem");
+var import_viem16 = require("viem");
 var BASE_TX_GAS_COST = 21000n;
 var calldataGasCost = (data) => {
-  const dataBytes = import_viem15.hexToBytes(data);
+  const dataBytes = import_viem16.hexToBytes(data);
   const nonZeroBytes = dataBytes.filter((b) => b !== 0).length;
   return 4n * BigInt(dataBytes.length) + 12n * BigInt(nonZeroBytes);
 };
@@ -3672,7 +3893,7 @@ var AES_GCM_PER_BLOCK = 30n;
 var MIN_AES_PLAINTEXT_LENGTH = 0;
 var MIN_AES_CIPHERTEXT_LENGTH = 16;
 var aesGcmGasCost = (value) => {
-  const valueBytes = import_viem16.isHex(value) ? import_viem16.hexToBytes(value) : import_viem16.stringToBytes(value);
+  const valueBytes = import_viem17.isHex(value) ? import_viem17.hexToBytes(value) : import_viem17.stringToBytes(value);
   return calcLinearGasCost({
     bus: 16,
     len: valueBytes.length,
@@ -3682,21 +3903,21 @@ var aesGcmGasCost = (value) => {
 };
 var validateParams = (args, encryption) => {
   const [aesKey, nonce, input] = args;
-  const aesKeyBytes = import_viem16.hexToBytes(aesKey);
+  const aesKeyBytes = import_viem17.hexToBytes(aesKey);
   if (aesKeyBytes.length !== 32) {
     throw new Error(`Invalid AES key: expected 32 bytes but found ${aesKeyBytes.length}`);
   }
-  const nonceBytes = import_viem16.numberToBytes(nonce, { size: 12 });
+  const nonceBytes = import_viem17.numberToBytes(nonce, { size: 12 });
   if (nonceBytes.length !== 12) {
     throw new Error(`Invalid nonce: expected 12 bytes but found ${nonceBytes.length}`);
   }
   if (encryption) {
-    const plaintextBytes = import_viem16.stringToBytes(input);
+    const plaintextBytes = import_viem17.stringToBytes(input);
     if (plaintextBytes.length < MIN_AES_PLAINTEXT_LENGTH) {
       throw new Error(`Invalid plaintext: expected at least ${MIN_AES_PLAINTEXT_LENGTH} bytes but found ${plaintextBytes.length}`);
     }
   } else {
-    const ciphertextBytes = import_viem16.hexToBytes(input);
+    const ciphertextBytes = import_viem17.hexToBytes(input);
     if (ciphertextBytes.length < MIN_AES_CIPHERTEXT_LENGTH) {
       throw new Error(`Invalid ciphertext: expected at least ${MIN_AES_CIPHERTEXT_LENGTH} bytes but found ${ciphertextBytes.length}`);
     }
@@ -3708,21 +3929,21 @@ var aesGcmEncryptPrecompile = {
   gasCost: (args) => aesGcmGasCost(args.plaintext),
   encodeParams: (args) => {
     const [aesKey, nonce, plaintext] = validateParams([args.aesKey, args.nonce, args.plaintext], true);
-    const nonceHex = import_viem16.numberToHex(nonce, { size: 12 });
-    const plaintextHex = import_viem16.stringToHex(plaintext);
+    const nonceHex = import_viem17.numberToHex(nonce, { size: 12 });
+    const plaintextHex = import_viem17.stringToHex(plaintext);
     return `${aesKey}${nonceHex.slice(2)}${plaintextHex.slice(2)}`;
   },
-  decodeResult: (result) => import_viem16.trim(result)
+  decodeResult: (result) => import_viem17.trim(result)
 };
 var aesGcmDecryptPrecompile = {
   address: AES_GCM_DECRYPT_ADDRESS,
   gasCost: (args) => aesGcmGasCost(args.ciphertext),
   encodeParams: (args) => {
     const [aesKey, nonce, cipherText] = validateParams([args.aesKey, args.nonce, args.ciphertext], false);
-    const nonceHex = import_viem16.numberToHex(nonce, { size: 12 });
+    const nonceHex = import_viem17.numberToHex(nonce, { size: 12 });
     return `${aesKey}${nonceHex.slice(2)}${cipherText.slice(2)}`;
   },
-  decodeResult: (result) => import_viem16.hexToString(import_viem16.trim(result))
+  decodeResult: (result) => import_viem17.hexToString(import_viem17.trim(result))
 };
 var aesGcmEncrypt = async (client, args) => {
   return callPrecompile({
@@ -3740,10 +3961,10 @@ var aesGcmDecrypt = async (client, args) => {
 };
 
 // src/precompiles/ecdh.ts
-var import_viem18 = require("viem");
+var import_viem19 = require("viem");
 
 // src/precompiles/hkdf.ts
-var import_viem17 = require("viem");
+var import_viem18 = require("viem");
 var HKDF_ADDRESS = "0x0000000000000000000000000000000000000068";
 var SHA256_BASE_GAS = 60n;
 var SHA256_PER_WORD = 12n;
@@ -3752,7 +3973,7 @@ var SHARED_SECRET_GAS = 3000n;
 var hdfkPrecompile = {
   address: HKDF_ADDRESS,
   gasCost: (ikmHex) => {
-    const ikmBytes = import_viem17.isHex(ikmHex) ? import_viem17.hexToBytes(ikmHex) : import_viem17.stringToBytes(ikmHex);
+    const ikmBytes = import_viem18.isHex(ikmHex) ? import_viem18.hexToBytes(ikmHex) : import_viem18.stringToBytes(ikmHex);
     const linearGasCost = calcLinearGasCost({
       bus: 32,
       len: ikmBytes.length,
@@ -3762,13 +3983,13 @@ var hdfkPrecompile = {
     return 2n * linearGasCost + HKDF_EXPAND_COST_GAS;
   },
   encodeParams: (input) => {
-    if (import_viem17.isHex(input)) {
+    if (import_viem18.isHex(input)) {
       return input;
     }
-    return import_viem17.stringToHex(input);
+    return import_viem18.stringToHex(input);
   },
   decodeResult: (result) => {
-    const [output] = import_viem17.decodeAbiParameters([{ type: "bytes32" }], result);
+    const [output] = import_viem18.decodeAbiParameters([{ type: "bytes32" }], result);
     return output;
   }
 };
@@ -3785,7 +4006,7 @@ var ECDH_ADDRESS = "0x0000000000000000000000000000000000000065";
 var SECRET_KEY_LENGTH = 32;
 var PUBLIC_KEY_LENGTH = 33;
 var validateKey = (key, sk) => {
-  const bytes = import_viem18.hexToBytes(key);
+  const bytes = import_viem19.hexToBytes(key);
   const expectedLength = sk ? SECRET_KEY_LENGTH : PUBLIC_KEY_LENGTH;
   if (bytes.length !== expectedLength) {
     throw new Error(`Invalid ${sk ? "secret" : "public"} key: must be ${expectedLength} bytes (received ${bytes.length})`);
@@ -3800,7 +4021,7 @@ var ecdhPrecompile = {
     return `${sk}${pk.slice(2)}`;
   },
   decodeResult: (result) => {
-    const [output] = import_viem18.decodeAbiParameters([{ type: "bytes32" }], result);
+    const [output] = import_viem19.decodeAbiParameters([{ type: "bytes32" }], result);
     return output;
   }
 };
@@ -3813,7 +4034,7 @@ var ecdh = async (client, args) => {
 };
 
 // src/precompiles/rng.ts
-var import_viem19 = require("viem");
+var import_viem20 = require("viem");
 var RNG_ADDRESS = "0x0000000000000000000000000000000000000064";
 var RNG_INIT_BASE_GAS = 3500n;
 var STROBE_128_WORD_GAS = 5n;
@@ -3821,9 +4042,9 @@ var persToBytes = (pers) => {
   if (!pers) {
     return new Uint8Array;
   }
-  if (import_viem19.isHex(pers)) {
-    return import_viem19.hexToBytes(pers);
-  } else if (import_viem19.isBytes(pers)) {
+  if (import_viem20.isHex(pers)) {
+    return import_viem20.hexToBytes(pers);
+  } else if (import_viem20.isBytes(pers)) {
     return pers;
   }
   throw new Error("Invalid pers: must be a hex or bytes array");
@@ -3850,15 +4071,15 @@ var rngPrecompile = {
     if (BigInt(numBytes) > 32n) {
       throw new Error("Invalid length: must be less than or equal to 32");
     }
-    const encodedBytes = import_viem19.numberToHex(numBytes, { size: 4 });
+    const encodedBytes = import_viem20.numberToHex(numBytes, { size: 4 });
     if (!pers) {
       return encodedBytes;
     }
-    const encodedPers = import_viem19.bytesToHex(persToBytes(pers));
+    const encodedPers = import_viem20.bytesToHex(persToBytes(pers));
     return `${encodedBytes}${encodedPers.slice(2)}`;
   },
   decodeResult: (result) => {
-    const [output] = import_viem19.decodeAbiParameters([{ type: "uint256" }], import_viem19.pad(result));
+    const [output] = import_viem20.decodeAbiParameters([{ type: "uint256" }], import_viem20.pad(result));
     return output;
   }
 };
@@ -3871,7 +4092,7 @@ var rng = async (client, args) => {
 };
 
 // src/precompiles/secp256k1.ts
-var import_viem20 = require("viem");
+var import_viem21 = require("viem");
 var SECP256K1_SIG_ADDRESS = "0x0000000000000000000000000000000000000069";
 var SECP256K1_SIG_BASE_GAS = 3000n;
 var secp256k1SigPrecompile = {
@@ -3883,9 +4104,9 @@ var secp256k1SigPrecompile = {
       { name: "messageHash", type: "bytes32" }
     ];
     const skHex = sk;
-    return import_viem20.encodeAbiParameters(params, [skHex, import_viem20.hashMessage(message)]);
+    return import_viem21.encodeAbiParameters(params, [skHex, import_viem21.hashMessage(message)]);
   },
-  decodeResult: import_viem20.parseSignature
+  decodeResult: import_viem21.parseSignature
 };
 var secp256k1Sig = async (client, args) => {
   return callPrecompile({
@@ -4133,7 +4354,7 @@ function parseEncryptedData(encryptedData) {
 }
 
 // src/actions/src20/directory.ts
-var import_viem21 = require("viem");
+var import_viem22 = require("viem");
 
 // src/abis/directory.ts
 var DIRECTORY_ADDRESS = "0x1000000000000000000000000000000000000004";
@@ -4211,7 +4432,7 @@ async function registerKey(client, aesKey) {
   return withTimeout(txPromise, TX_TIMEOUT_MS);
 }
 function computeKeyHash(aesKey) {
-  return import_viem21.keccak256(aesKey);
+  return import_viem22.keccak256(aesKey);
 }
 
 // src/actions/src20/watchSRC20Events.ts
@@ -4348,47 +4569,143 @@ var src20WalletActions = (client) => ({
   watchSRC20Events: (params) => watchSRC20Events(client, params)
 });
 
+// src/tx/sendTransparent.ts
+var import_accounts3 = require("viem/accounts");
+var import_actions7 = require("viem/actions");
+var import_utils13 = require("viem/utils");
+var DEFAULT_SIGNED_ESTIMATE_GAS_LIMIT = 30000000n;
+async function sendTransparentTransaction(client, parameters) {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    accessList,
+    authorizationList,
+    blobs,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerBlobGas,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    value,
+    ...rest
+  } = parameters;
+  if (typeof account_ === "undefined")
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/sendTransaction"
+    });
+  const account = account_ ? import_accounts3.parseAccount(account_) : null;
+  try {
+    import_utils13.assertRequest(parameters);
+    const to = await (async () => {
+      if (parameters.to)
+        return parameters.to;
+      return;
+    })();
+    if (account?.type !== "local") {
+      return await import_actions7.sendTransaction(client, parameters);
+    }
+    const request = await import_actions7.prepareTransactionRequest(client, {
+      account,
+      accessList,
+      authorizationList,
+      blobs,
+      chain,
+      data,
+      gasPrice,
+      maxFeePerBlobGas,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce,
+      nonceManager: account.nonceManager,
+      parameters: [
+        "blobVersionedHashes",
+        "chainId",
+        "fees",
+        "nonce",
+        "type",
+        "sidecars"
+      ],
+      value,
+      ...rest,
+      to
+    });
+    const serializer = chain?.serializers?.transaction;
+    const gasEstimate = gas ?? BigInt(await client.request({
+      method: "eth_estimateGas",
+      params: [
+        await account.signTransaction({
+          ...request,
+          gas: DEFAULT_SIGNED_ESTIMATE_GAS_LIMIT
+        }, { serializer })
+      ]
+    }, { retryCount: 0 }));
+    const serializedTransaction = await account.signTransaction({
+      ...request,
+      gas: gasEstimate
+    }, { serializer });
+    return await import_utils13.getAction(client, import_actions7.sendRawTransaction, "sendRawTransaction")({
+      serializedTransaction
+    });
+  } catch (err) {
+    throw import_utils13.getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain || undefined
+    });
+  }
+}
+
 // src/actions/wallet.ts
-var import_actions6 = require("viem/actions");
 var shieldedWalletActions = (client) => {
   return {
-    writeContract: (args) => shieldedWriteContract(client, args),
-    twriteContract: (args) => import_actions6.writeContract(client, args),
-    dwriteContract: (args) => {
-      const debugResult = shieldedWriteContractDebug(client, args);
+    sendTransaction: (args) => sendTransparentTransaction(client, args),
+    writeContract: (args) => smartWriteContract(client, args),
+    swriteContract: (args, securityParams) => shieldedWriteContract(client, args, securityParams),
+    twriteContract: (args) => transparentWriteContract(client, args),
+    dwriteContract: (args, securityParams) => {
+      const debugResult = shieldedWriteContractDebug(client, args, undefined, securityParams);
       return debugResult;
     },
-    readContract: (args, securityParams) => signedReadContract(client, args, securityParams),
-    treadContract: (args) => import_actions6.readContract(client, args),
+    readContract: (args) => smartReadContract(client, client, args),
+    sreadContract: (args, securityParams) => signedReadContract(client, args, securityParams),
+    treadContract: (args) => {
+      const readArgs = args;
+      if (readArgs.account !== undefined) {
+        throw new Error("walletClient.treadContract is always transparent. Seismic zeroes out `from` on transparent `eth_call`, so `account` would be ignored on the node and cause silent bugs. Remove `account` or use `walletClient.sreadContract`.");
+      }
+      return transparentReadContract(client, args);
+    },
     signedCall: (args, securityParams) => signedCall(client, args, securityParams),
     sendShieldedTransaction: (args, securityParams) => sendShieldedTransaction(client, args, securityParams)
   };
 };
 
 // src/crypto/secp.ts
-var import_viem22 = require("viem");
+var import_viem23 = require("viem");
 var compressPublicKey = (uncompressedKey) => {
   const cleanKey = uncompressedKey.replace("0x", "");
   if (cleanKey.length !== 130) {
     throw new Error("Invalid uncompressed public key length");
   }
   const pt = secp256k1.ProjectivePoint.fromHex(cleanKey);
-  return import_viem22.bytesToHex(pt.toRawBytes(true));
+  return import_viem23.bytesToHex(pt.toRawBytes(true));
 };
 
 // src/client.ts
 var getEncryption = (networkPk, clientSk) => {
-  const encryptionPrivateKey = clientSk ?? import_accounts3.generatePrivateKey();
+  const encryptionPrivateKey = clientSk ?? import_accounts4.generatePrivateKey();
   const aesKey = generateAesKey({
     privateKey: encryptionPrivateKey,
     networkPublicKey: networkPk
   });
-  const uncompressedPk = import_accounts3.privateKeyToAccount(encryptionPrivateKey).publicKey;
+  const uncompressedPk = import_accounts4.privateKeyToAccount(encryptionPrivateKey).publicKey;
   const encryptionPublicKey = compressPublicKey(uncompressedPk);
   return { encryptionPrivateKey, encryptionPublicKey, aesKey };
 };
 var createShieldedPublicClient = (parameters) => {
-  const viemPublicClient = import_viem23.createPublicClient(parameters);
+  const viemPublicClient = import_viem24.createPublicClient(parameters);
   return viemPublicClient.extend(shieldedPublicActions).extend(depositContractPublicActions).extend(src20PublicActions);
 };
 var getSeismicClients = async ({
@@ -4404,12 +4721,12 @@ var getSeismicClients = async ({
   });
   const networkPublicKey = await pubClient.getTeePublicKey();
   const { aesKey, encryptionPublicKey } = getEncryption(networkPublicKey, encryptionSk);
-  const wallet = import_viem23.createClient({
+  const wallet = import_viem24.createClient({
     account,
     chain,
     transport,
     rpcSchema: seismicRpcSchema
-  }).extend(import_viem23.walletActions).extend(() => import_viem23.publicActions(pubClient)).extend(() => encryptionActions(aesKey, encryptionPublicKey)).extend(() => shieldedPublicActions(pubClient)).extend(shieldedWalletActions).extend(depositContractWalletActions).extend(src20WalletActions);
+  }).extend(import_viem24.walletActions).extend(() => import_viem24.publicActions(pubClient)).extend(() => encryptionActions(aesKey, encryptionPublicKey)).extend(() => shieldedPublicActions(pubClient)).extend(shieldedWalletActions).extend(depositContractWalletActions).extend(src20WalletActions);
   return {
     public: pubClient,
     wallet
@@ -4432,11 +4749,11 @@ var createShieldedWalletClient = async ({
   return clients.wallet;
 };
 // src/faucet.ts
-var import_utils13 = require("viem/utils");
-var DEFAULT_MIN_BALANCE_WEI = import_utils13.parseEther("0.5");
+var import_utils14 = require("viem/utils");
+var DEFAULT_MIN_BALANCE_WEI = import_utils14.parseEther("0.5");
 var parseMinBalance = (minBalanceWei, minBalanceEther) => {
   if (minBalanceWei && minBalanceEther) {
-    if (BigInt(minBalanceWei) !== import_utils13.parseEther(minBalanceEther.toString())) {
+    if (BigInt(minBalanceWei) !== import_utils14.parseEther(minBalanceEther.toString())) {
       console.warn("Both minBalanceWei and minBalanceEther provided, using minBalanceWei");
     }
   }
@@ -4444,7 +4761,7 @@ var parseMinBalance = (minBalanceWei, minBalanceEther) => {
     return BigInt(minBalanceWei);
   }
   if (minBalanceEther) {
-    return import_utils13.parseEther(minBalanceEther.toString());
+    return import_utils14.parseEther(minBalanceEther.toString());
   }
   return DEFAULT_MIN_BALANCE_WEI;
 };