seismic-viem 2.0.0 → 2.0.1

package/dist/_cjs/index.js

@@ -35,7 +35,6 @@ __export(exports_src, {
   transparentWriteContract: () => transparentWriteContract,
   transparentReadContract: () => transparentReadContract,
   tokenExplorerUrl: () => tokenExplorerUrl,
-  stringifyBigInt: () => stringifyBigInt,
   src20WalletActions: () => src20WalletActions,
   src20PublicActions: () => src20PublicActions,
   signedReadContract: () => signedReadContract,
@@ -51,6 +50,7 @@ __export(exports_src, {
   seismicTestnet2: () => seismicTestnet2,
   seismicTestnet1: () => seismicTestnet1,
   seismicTestnet: () => seismicTestnet,
+  seismicRpcSchema: () => seismicRpcSchema,
   seismicChainFormatters: () => seismicChainFormatters,
   secp256k1SigPrecompile: () => secp256k1SigPrecompile,
   secp256k1Sig: () => secp256k1Sig,
@@ -60,6 +60,9 @@ __export(exports_src, {
   remapSeismicAbiInputs: () => remapSeismicAbiInputs,
   registerKey: () => registerKey,
   randomEncryptionNonce: () => randomEncryptionNonce,
+  parseMinBalance: () => parseMinBalance,
+  parseFaucetResponseHash: () => parseFaucetResponseHash,
+  parseEncryptedData: () => parseEncryptedData,
   localSeismicDevnet: () => localSeismicDevnet,
   hdfkPrecompile: () => hdfkPrecompile,
   hdfk: () => hdfk,
@@ -71,12 +74,14 @@ __export(exports_src, {
   getExplorerUrl: () => getExplorerUrl,
   getEncryption: () => getEncryption,
   generateAesKey: () => generateAesKey,
+  estimateGasRpcSchema: () => estimateGasRpcSchema,
   encodeSeismicMetadataAsAAD: () => encodeSeismicMetadataAsAAD,
   ecdhPrecompile: () => ecdhPrecompile,
   ecdh: () => ecdh,
   deriveAesKey: () => deriveAesKey,
   createShieldedWalletClient: () => createShieldedWalletClient,
   createShieldedPublicClient: () => createShieldedPublicClient,
+  createSeismicTestnet: () => createSeismicTestnet,
   createSeismicGcpTestnet: () => createSeismicGcpTestnet,
   createSeismicDevnet: () => createSeismicDevnet,
   createSeismicAzTestnet: () => createSeismicAzTestnet,
@@ -84,6 +89,7 @@ __export(exports_src, {
   compressPublicKey: () => compressPublicKey,
   checkRegistration: () => checkRegistration,
   checkFaucet: () => checkFaucet,
+  callRpcSchema: () => callRpcSchema,
   buildTxSeismicMetadata: () => buildTxSeismicMetadata,
   blockExplorerUrl: () => blockExplorerUrl,
   aesGcmEncryptPrecompile: () => aesGcmEncryptPrecompile,
@@ -99,7 +105,7 @@ __export(exports_src, {
 });
 module.exports = __toCommonJS(exports_src);
 
-// src/metadata.ts
+// src/tx/metadata.ts
 var import_accounts = require("viem/accounts");
 
 // src/crypto/nonce.ts
@@ -199,7 +205,7 @@ var randomEncryptionNonce = () => {
   return nonce;
 };
 
-// src/signSeismicTypedData.ts
+// src/tx/signSeismicTypedData.ts
 var import_viem2 = require("viem");
 var import_actions = require("viem/actions");
 var TYPED_DATA_MESSAGE_VERSION = 2;
@@ -288,7 +294,7 @@ var signSeismicTxTypedData = async (client, tx) => {
   };
 };
 
-// src/metadata.ts
+// src/tx/metadata.ts
 var DEFAULT_SEISMIC_BLOCKS_WINDOW = 100n;
 var fillNonce = async (client, parameters) => {
   let account = import_accounts.parseAccount(parameters.account || client.account);
@@ -384,6 +390,12 @@ var buildTxSeismicMetadata = async (client, {
   };
 };
 // src/chain.ts
+var import_viem6 = require("viem");
+
+// src/tx/seismicRpc.ts
+var import_viem5 = require("viem");
+
+// src/tx/seismicTx.ts
 var import_viem4 = require("viem");
 
 // src/viem-internal/signature.ts
@@ -411,7 +423,7 @@ function toYParitySignatureArray(transaction, signature_) {
   return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
 }
 
-// src/chain.ts
+// src/tx/seismicTx.ts
 var SEISMIC_TX_TYPE = 74;
 var serializeSeismicTransaction = (tx, signature) => {
   const {
@@ -487,6 +499,8 @@ var serializeSeismicTransaction = (tx, signature) => {
   const rlpEncoded = import_viem4.toRlp(rlpArray);
   return import_viem4.concatHex([import_viem4.toHex(SEISMIC_TX_TYPE), rlpEncoded]);
 };
+
+// src/tx/seismicRpc.ts
 var estimateGasRpcSchema = {
   Method: "eth_estimateGas",
   Parameters: ["SeismicTransactionRequest"],
@@ -505,15 +519,15 @@ var formatAuthorizationList = (authorizationList) => authorizationList.map((auth
   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) } : {}
+  chainId: import_viem5.toHex(authorization.chainId),
+  nonce: import_viem5.toHex(authorization.nonce),
+  ...typeof authorization.yParity !== "undefined" ? { yParity: import_viem5.toHex(authorization.yParity) } : {},
+  ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: import_viem5.toHex(authorization.v) } : {}
 }));
-var fmtRpcRequest = (request) => {
+var formatSeismicRpcRequest = (request) => {
   if (request.type === "seismic") {
     const { authorizationList, ...legacyCompatibleRequest } = request;
-    const seismicFmt = import_viem4.formatTransactionRequest({
+    const seismicFmt = import_viem5.formatTransactionRequest({
       ...legacyCompatibleRequest,
       type: "legacy"
     });
@@ -523,7 +537,7 @@ var fmtRpcRequest = (request) => {
       ...authorizationList ? { authorizationList: formatAuthorizationList(authorizationList) } : {}
     };
   }
-  const { type, ...fmt } = import_viem4.formatTransactionRequest(request);
+  const { type, ...fmt } = import_viem5.formatTransactionRequest(request);
   if (hasSeismicFields(request)) {
     return { ...fmt, type: SEISMIC_TX_TYPE };
   }
@@ -532,8 +546,8 @@ var fmtRpcRequest = (request) => {
 var seismicChainFormatters = {
   transactionRequest: {
     format: (request) => {
-      let chainId = request.chainId;
-      const formattedRpcRequest = fmtRpcRequest(request);
+      const chainId = request.chainId;
+      const formattedRpcRequest = formatSeismicRpcRequest(request);
       if (request.type === "seismic") {
         if (!request.encryptionNonce) {
           throw new Error("Encryption nonce is required for seismic transactions");
@@ -554,7 +568,7 @@ var seismicChainFormatters = {
           throw new Error("signedRead is required for seismic transaction requests");
         }
       }
-      const fmtSeismicReq = {
+      return {
         ...formattedRpcRequest,
         chainId,
         encryptionPubkey: request.encryptionPubkey,
@@ -564,19 +578,20 @@ var seismicChainFormatters = {
         expiresAtBlock: request.expiresAtBlock,
         signedRead: request.signedRead
       };
-      return fmtSeismicReq;
     },
     type: "transactionRequest"
   }
 };
+
+// src/chain.ts
 var createSeismicDevnet = ({
   nodeHost,
   explorerUrl
 }) => {
   if (!nodeHost) {
-    throw new Error("Must set `nodeHost` argument, e.g. gcp-1.seismictest.net");
+    throw new Error("Must set `nodeHost` argument, e.g. testnet-1.seismictest.net");
   }
-  return import_viem4.defineChain({
+  return import_viem6.defineChain({
     id: 5124,
     name: "Seismic",
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
@@ -604,12 +619,16 @@ var createSeismicGcpTestnet = (n) => createSeismicDevnet({
   nodeHost: `gcp-${n}.seismictest.net`,
   explorerUrl: "https://seismic-testnet.socialscan.io"
 });
+var createSeismicTestnet = (n) => createSeismicDevnet({
+  nodeHost: `testnet-${n}.seismictest.net`,
+  explorerUrl: "https://seismic-testnet.socialscan.io"
+});
 var seismicTestnetGcp1 = createSeismicGcpTestnet(1);
 var seismicTestnetGcp2 = createSeismicGcpTestnet(2);
-var seismicTestnet1 = seismicTestnetGcp1;
-var seismicTestnet2 = seismicTestnetGcp2;
+var seismicTestnet1 = createSeismicTestnet(1);
+var seismicTestnet2 = createSeismicTestnet(2);
 var seismicTestnet = seismicTestnet1;
-var localSeismicDevnet = /* @__PURE__ */ import_viem4.defineChain({
+var localSeismicDevnet = /* @__PURE__ */ import_viem6.defineChain({
   id: 5124,
   name: "Seismic",
   nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
@@ -622,7 +641,7 @@ var localSeismicDevnet = /* @__PURE__ */ import_viem4.defineChain({
   formatters: seismicChainFormatters,
   testnet: true
 });
-var sanvil = /* @__PURE__ */ import_viem4.defineChain({
+var sanvil = /* @__PURE__ */ import_viem6.defineChain({
   id: 31337,
   name: "Anvil",
   nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
@@ -636,15 +655,15 @@ var sanvil = /* @__PURE__ */ import_viem4.defineChain({
   testnet: true
 });
 // src/contract/contract.ts
-var import_viem13 = require("viem");
+var import_viem15 = require("viem");
 
 // src/contract/read.ts
-var import_viem9 = require("viem");
+var import_viem11 = require("viem");
 var import_actions3 = require("viem/actions");
 var import_utils2 = require("viem/utils");
 
 // src/contract/abi.ts
-var import_viem5 = require("viem");
+var import_viem7 = require("viem");
 var isAnyTrue = (bools) => bools.reduce((acc, val) => acc || val, false);
 var remapSeismicParam = (param) => {
   const ty = param.type;
@@ -689,7 +708,7 @@ var remapSeismicParam = (param) => {
   return { shielded: false, type: ty };
 };
 function hasShieldedParams(abi, functionName) {
-  const abiItem = import_viem5.getAbiItem({ abi, name: functionName });
+  const abiItem = import_viem7.getAbiItem({ abi, name: functionName });
   if (!abiItem?.inputs)
     return false;
   return abiItem.inputs.some((param) => remapSeismicParam(param).shielded);
@@ -707,14 +726,14 @@ var remapSeismicAbiInputs = (abiFunction) => {
 };
 
 // src/tx/signedCall.ts
-var import_viem8 = require("viem");
+var import_viem10 = require("viem");
 var import_actions2 = require("viem/actions");
 var import_utils = require("viem/utils");
 
 // src/error/signedCall.ts
-var import_viem6 = require("viem");
+var import_viem8 = require("viem");
 
-class SignedCallError extends import_viem6.BaseError {
+class SignedCallError extends import_viem8.BaseError {
   constructor({
     docsPath,
     metaMessages,
@@ -729,9 +748,9 @@ class SignedCallError extends import_viem6.BaseError {
 }
 
 // src/viem-internal/call.ts
-var import_viem7 = require("viem");
+var import_viem9 = require("viem");
 function getRevertErrorData(err) {
-  if (!(err instanceof import_viem7.BaseError))
+  if (!(err instanceof import_viem9.BaseError))
     return;
   const error = err.walk();
   return typeof error?.data === "object" ? error.data?.data : error.data;
@@ -789,7 +808,7 @@ async function signedCall(client, args, {
   } = args;
   const account = prepareAccount(account_, client.account);
   if (!to) {
-    throw new import_viem8.BaseError("Signed calls must set 'to' address");
+    throw new import_viem10.BaseError("Signed calls must set 'to' address");
   }
   try {
     const assertRequestParams = {
@@ -799,8 +818,8 @@ async function signedCall(client, args, {
       maxPriorityFeePerGas,
       to: args.to
     };
-    import_viem8.assertRequest(assertRequestParams);
-    const blockNumberHex = blockNumber ? import_viem8.numberToHex(blockNumber) : undefined;
+    import_viem10.assertRequest(assertRequestParams);
+    const blockNumberHex = blockNumber ? import_viem10.numberToHex(blockNumber) : undefined;
     const block = blockNumberHex || blockTag;
     const chainFormat = client.chain?.formatters?.transactionRequest?.format;
     const fromAddress = account?.address;
@@ -852,8 +871,8 @@ async function signedCall(client, args, {
     return { data: decryptedResponse };
   } catch (err) {
     const data = getRevertErrorData(err);
-    if (client.ccipRead !== false && data?.slice(0, 10) === import_viem8.offchainLookupSignature && to)
-      return { data: await import_viem8.offchainLookup(client, { data, to }) };
+    if (client.ccipRead !== false && data?.slice(0, 10) === import_viem10.offchainLookupSignature && to)
+      return { data: await import_viem10.offchainLookup(client, { data, to }) };
     throw import_utils.getCallError(err, {
       account,
       chain: client.chain,
@@ -892,10 +911,10 @@ async function signedReadContract(client, parameters, securityParams) {
     address,
     ...rest
   } = parameters;
-  const seismicAbi = import_viem9.getAbiItem({ abi, name: functionName });
-  const selector = import_viem9.toFunctionSelector(import_utils2.formatAbiItem(seismicAbi));
+  const seismicAbi = import_viem11.getAbiItem({ abi, name: functionName });
+  const selector = import_viem11.toFunctionSelector(import_utils2.formatAbiItem(seismicAbi));
   const ethAbi = remapSeismicAbiInputs(seismicAbi);
-  const encodedParams = import_viem9.encodeAbiParameters(ethAbi.inputs, args).slice(2);
+  const encodedParams = import_viem11.encodeAbiParameters(ethAbi.inputs, args).slice(2);
   const plaintextCalldata = `${selector}${encodedParams}`;
   const request = {
     ...rest,
@@ -903,7 +922,7 @@ async function signedReadContract(client, parameters, securityParams) {
     data: plaintextCalldata
   };
   const { data } = await signedCall(client, request, securityParams);
-  return import_viem9.decodeFunctionResult({
+  return import_viem11.decodeFunctionResult({
     abi,
     args,
     functionName,
@@ -918,10 +937,10 @@ async function transparentReadContract(client, parameters) {
     address,
     ...rest
   } = parameters;
-  const seismicAbi = import_viem9.getAbiItem({ abi, name: functionName });
-  const selector = import_viem9.toFunctionSelector(import_utils2.formatAbiItem(seismicAbi));
+  const seismicAbi = import_viem11.getAbiItem({ abi, name: functionName });
+  const selector = import_viem11.toFunctionSelector(import_utils2.formatAbiItem(seismicAbi));
   const ethAbi = remapSeismicAbiInputs(seismicAbi);
-  const encodedParams = import_viem9.encodeAbiParameters(ethAbi.inputs, args).slice(2);
+  const encodedParams = import_viem11.encodeAbiParameters(ethAbi.inputs, args).slice(2);
   const data = `${selector}${encodedParams}`;
   const callOptions = rest;
   const { data: result } = await client.call({
@@ -929,7 +948,7 @@ async function transparentReadContract(client, parameters) {
     data,
     ...callOptions
   });
-  return import_viem9.decodeFunctionResult({
+  return import_viem11.decodeFunctionResult({
     abi,
     args,
     functionName,
@@ -938,18 +957,18 @@ async function transparentReadContract(client, parameters) {
 }
 
 // src/contract/write.ts
-var import_viem12 = require("viem");
+var import_viem14 = require("viem");
 var import_actions5 = require("viem/actions");
 
 // src/contract/calldata.ts
-var import_viem10 = require("viem");
+var import_viem12 = 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 seismicAbi = import_viem12.getAbiItem({ abi, name: functionName });
+  const selector = import_viem12.toFunctionSelector(import_utils3.formatAbiItem(seismicAbi));
   const ethAbi = remapSeismicAbiInputs(seismicAbi);
-  const encodedParams = import_viem10.encodeAbiParameters(ethAbi.inputs, args).slice(2);
+  const encodedParams = import_viem12.encodeAbiParameters(ethAbi.inputs, args).slice(2);
   return `${selector}${encodedParams}`;
 };
 
@@ -959,9 +978,9 @@ var import_actions4 = require("viem/actions");
 var import_utils4 = require("viem/utils");
 
 // src/error/account.ts
-var import_viem11 = require("viem");
+var import_viem13 = require("viem");
 
-class AccountNotFoundError extends import_viem11.BaseError {
+class AccountNotFoundError extends import_viem13.BaseError {
   constructor({ docsPath } = {}) {
     super([
       "Could not find an Account to execute with this Action.",
@@ -975,7 +994,7 @@ class AccountNotFoundError extends import_viem11.BaseError {
   }
 }
 
-class AccountTypeNotSupportedError extends import_viem11.BaseError {
+class AccountTypeNotSupportedError extends import_viem13.BaseError {
   constructor({
     docsPath,
     metaMessages,
@@ -1210,14 +1229,14 @@ async function shieldedWriteContractDebug(client, parameters, checkContractDeplo
     plaintextTx: {
       to: request.to || null,
       data: plaintextCalldata,
-      type: import_viem12.numberToHex(SEISMIC_TX_TYPE),
+      type: import_viem14.numberToHex(SEISMIC_TX_TYPE),
       nonce: request.nonce,
       gas: request.gas,
       gasPrice: request.gasPrice,
       value: request.value
     },
     shieldedTx: {
-      type: import_viem12.numberToHex(SEISMIC_TX_TYPE),
+      type: import_viem14.numberToHex(SEISMIC_TX_TYPE),
       ...request,
       ...metadata.seismicElements
     },
@@ -1252,7 +1271,7 @@ function getShieldedContract({
   address,
   client
 }) {
-  const viemContract = import_viem13.getContract({ abi, address, client });
+  const viemContract = import_viem15.getContract({ abi, address, client });
   const walletClient = (() => {
     if (!client)
       return;
@@ -1459,128 +1478,11 @@ function getShieldedContract({
   return contract;
 }
 // src/client.ts
-var import_viem24 = require("viem");
+var import_viem26 = require("viem");
 var import_accounts4 = require("viem/accounts");
 
-// src/actions/depositContract.ts
-var import_actions6 = require("viem/actions");
-
-// src/abis/depositContract.ts
-var depositContractAbi = [
-  {
-    type: "constructor",
-    inputs: [],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "deposit",
-    inputs: [
-      { name: "node_pubkey", type: "bytes", internalType: "bytes" },
-      { name: "consensus_pubkey", type: "bytes", internalType: "bytes" },
-      { name: "withdrawal_credentials", type: "bytes", internalType: "bytes" },
-      { name: "node_signature", type: "bytes", internalType: "bytes" },
-      { name: "consensus_signature", type: "bytes", internalType: "bytes" },
-      { name: "deposit_data_root", type: "bytes32", internalType: "bytes32" }
-    ],
-    outputs: [],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "get_deposit_count",
-    inputs: [],
-    outputs: [{ name: "", type: "bytes", internalType: "bytes" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "get_deposit_root",
-    inputs: [],
-    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "supportsInterface",
-    inputs: [{ name: "interfaceId", type: "bytes4", internalType: "bytes4" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "pure"
-  },
-  {
-    type: "event",
-    name: "DepositEvent",
-    inputs: [
-      {
-        name: "node_pubkey",
-        type: "bytes",
-        indexed: false,
-        internalType: "bytes"
-      },
-      {
-        name: "consensus_pubkey",
-        type: "bytes",
-        indexed: false,
-        internalType: "bytes"
-      },
-      {
-        name: "withdrawal_credentials",
-        type: "bytes",
-        indexed: false,
-        internalType: "bytes"
-      },
-      { name: "amount", type: "bytes", indexed: false, internalType: "bytes" },
-      {
-        name: "node_signature",
-        type: "bytes",
-        indexed: false,
-        internalType: "bytes"
-      },
-      {
-        name: "consensus_signature",
-        type: "bytes",
-        indexed: false,
-        internalType: "bytes"
-      },
-      { name: "index", type: "bytes", indexed: false, internalType: "bytes" }
-    ],
-    anonymous: false
-  }
-];
-
-// src/actions/depositContract.ts
-var DEPOSIT_CONTRACT_ADDRESS = "0x00000000219ab540356cBB839Cbe05303d7705Fa";
-var depositContractPublicActions = (client) => ({
-  getDepositRoot: async (args) => import_actions6.readContract(client, {
-    abi: depositContractAbi,
-    address: args.address || DEPOSIT_CONTRACT_ADDRESS,
-    functionName: "get_deposit_root"
-  }),
-  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_actions6.writeContract(client, {
-    abi: depositContractAbi,
-    address: args.address || DEPOSIT_CONTRACT_ADDRESS,
-    functionName: "deposit",
-    args: [
-      args.nodePubkey,
-      args.consensusPubkey,
-      args.withdrawalCredentials,
-      args.nodeSignature,
-      args.consensusSignature,
-      args.depositDataRoot
-    ],
-    value: args.value
-  })
-});
-
 // src/crypto/aead.ts
-var import_viem14 = require("viem");
+var import_viem16 = require("viem");
 var encodeSeismicMetadataAsAAD = ({
   sender,
   legacyFields: { chainId, nonce, to, value },
@@ -1595,22 +1497,22 @@ var encodeSeismicMetadataAsAAD = ({
 }) => {
   const fields = [
     sender,
-    import_viem14.toHex(chainId),
-    nonce === 0 ? "0x" : import_viem14.toHex(nonce),
+    import_viem16.toHex(chainId),
+    nonce === 0 ? "0x" : import_viem16.toHex(nonce),
     to ?? "0x",
-    value === 0n ? "0x" : import_viem14.toHex(value),
+    value === 0n ? "0x" : import_viem16.toHex(value),
     encryptionPubkey,
     encryptionNonce === "0x00" || encryptionNonce === "0x0" ? "0x" : encryptionNonce,
-    messageVersion === 0 ? "0x" : import_viem14.toHex(messageVersion),
+    messageVersion === 0 ? "0x" : import_viem16.toHex(messageVersion),
     recentBlockHash,
-    import_viem14.toHex(expiresAtBlock),
+    import_viem16.toHex(expiresAtBlock),
     signedRead ? "0x01" : "0x"
   ];
-  return import_viem14.toRlp(fields, "bytes");
+  return import_viem16.toRlp(fields, "bytes");
 };
 
 // src/crypto/aes.ts
-var import_viem15 = require("viem");
+var import_viem17 = require("viem");
 
 // ../../node_modules/@noble/hashes/esm/_assert.js
 function anumber2(n) {
@@ -3687,7 +3589,7 @@ class AesGcmCrypto {
   U64_SIZE = 8;
   constructor(key) {
     this.key = key;
-    const keyBuffer = import_viem15.hexToBytes(key);
+    const keyBuffer = import_viem17.hexToBytes(key);
     if (keyBuffer.length !== 32) {
       throw new Error("Key must be 32 bytes (256 bits)");
     }
@@ -3702,34 +3604,34 @@ class AesGcmCrypto {
     return nonceBuffer;
   }
   validateAndConvertNonce(nonce) {
-    const nonceBuffer = import_viem15.hexToBytes(nonce);
+    const nonceBuffer = import_viem17.hexToBytes(nonce);
     if (nonceBuffer.length !== this.NONCE_LENGTH) {
       throw new Error("Nonce must be 12 bytes");
     }
     return nonceBuffer;
   }
   createNonce(num) {
-    return import_viem15.bytesToHex(this.numberToNonce(num));
+    return import_viem17.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_viem15.hexToBytes(this.key);
-    const plaintextBytes = import_viem15.hexToBytes(plaintext);
+    const key = import_viem17.hexToBytes(this.key);
+    const plaintextBytes = import_viem17.hexToBytes(plaintext);
     const ciphertextBytes = await gcm(key, nonceBuffer, aad).encrypt(plaintextBytes);
-    return import_viem15.bytesToHex(ciphertextBytes);
+    return import_viem17.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_viem15.hexToBytes(this.key);
-    const ciphertextBytes = import_viem15.hexToBytes(ciphertext);
+    const key = import_viem17.hexToBytes(this.key);
+    const ciphertextBytes = import_viem17.hexToBytes(ciphertext);
     const plaintextBytes = await gcm(key, nonceBuffer, aad).decrypt(ciphertextBytes);
-    return import_viem15.bytesToHex(plaintextBytes);
+    return import_viem17.bytesToHex(plaintextBytes);
   }
 }
 var sharedSecretPoint = ({
@@ -3742,15 +3644,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_viem15.bytesToHex(finalSecret).slice(2);
+  return import_viem17.bytesToHex(finalSecret).slice(2);
 };
 var generateSharedKey = (inputs) => {
   const sharedSecret = sharedSecretPoint(inputs);
   return sharedKeyFromPoint(sharedSecret);
 };
 var deriveAesKey = (sharedSecret) => {
-  const derivedKey = hkdf(sha2562, import_viem15.hexToBytes(`0x${sharedSecret}`), new Uint8Array(0), new TextEncoder().encode("aes-gcm key"), 32);
-  return import_viem15.bytesToHex(derivedKey);
+  const derivedKey = hkdf(sha2562, import_viem17.hexToBytes(`0x${sharedSecret}`), new Uint8Array(0), new TextEncoder().encode("aes-gcm key"), 32);
+  return import_viem17.bytesToHex(derivedKey);
 };
 var generateAesKey = (aesKeys) => {
   const sharedSecret = generateSharedKey(aesKeys);
@@ -3840,13 +3742,13 @@ var tokenExplorerUrl = ({
 };
 
 // src/precompiles/aes.ts
-var import_viem17 = require("viem");
+var import_viem19 = require("viem");
 
 // src/precompiles/precompile.ts
-var import_viem16 = require("viem");
+var import_viem18 = require("viem");
 var BASE_TX_GAS_COST = 21000n;
 var calldataGasCost = (data) => {
-  const dataBytes = import_viem16.hexToBytes(data);
+  const dataBytes = import_viem18.hexToBytes(data);
   const nonZeroBytes = dataBytes.filter((b) => b !== 0).length;
   return 4n * BigInt(dataBytes.length) + 12n * BigInt(nonZeroBytes);
 };
@@ -3893,7 +3795,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_viem17.isHex(value) ? import_viem17.hexToBytes(value) : import_viem17.stringToBytes(value);
+  const valueBytes = import_viem19.isHex(value) ? import_viem19.hexToBytes(value) : import_viem19.stringToBytes(value);
   return calcLinearGasCost({
     bus: 16,
     len: valueBytes.length,
@@ -3903,21 +3805,21 @@ var aesGcmGasCost = (value) => {
 };
 var validateParams = (args, encryption) => {
   const [aesKey, nonce, input] = args;
-  const aesKeyBytes = import_viem17.hexToBytes(aesKey);
+  const aesKeyBytes = import_viem19.hexToBytes(aesKey);
   if (aesKeyBytes.length !== 32) {
     throw new Error(`Invalid AES key: expected 32 bytes but found ${aesKeyBytes.length}`);
   }
-  const nonceBytes = import_viem17.numberToBytes(nonce, { size: 12 });
+  const nonceBytes = import_viem19.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_viem17.stringToBytes(input);
+    const plaintextBytes = import_viem19.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_viem17.hexToBytes(input);
+    const ciphertextBytes = import_viem19.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}`);
     }
@@ -3929,21 +3831,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_viem17.numberToHex(nonce, { size: 12 });
-    const plaintextHex = import_viem17.stringToHex(plaintext);
+    const nonceHex = import_viem19.numberToHex(nonce, { size: 12 });
+    const plaintextHex = import_viem19.stringToHex(plaintext);
     return `${aesKey}${nonceHex.slice(2)}${plaintextHex.slice(2)}`;
   },
-  decodeResult: (result) => import_viem17.trim(result)
+  decodeResult: (result) => import_viem19.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_viem17.numberToHex(nonce, { size: 12 });
+    const nonceHex = import_viem19.numberToHex(nonce, { size: 12 });
     return `${aesKey}${nonceHex.slice(2)}${cipherText.slice(2)}`;
   },
-  decodeResult: (result) => import_viem17.hexToString(import_viem17.trim(result))
+  decodeResult: (result) => import_viem19.hexToString(import_viem19.trim(result))
 };
 var aesGcmEncrypt = async (client, args) => {
   return callPrecompile({
@@ -3961,10 +3863,10 @@ var aesGcmDecrypt = async (client, args) => {
 };
 
 // src/precompiles/ecdh.ts
-var import_viem19 = require("viem");
+var import_viem21 = require("viem");
 
 // src/precompiles/hkdf.ts
-var import_viem18 = require("viem");
+var import_viem20 = require("viem");
 var HKDF_ADDRESS = "0x0000000000000000000000000000000000000068";
 var SHA256_BASE_GAS = 60n;
 var SHA256_PER_WORD = 12n;
@@ -3973,7 +3875,7 @@ var SHARED_SECRET_GAS = 3000n;
 var hdfkPrecompile = {
   address: HKDF_ADDRESS,
   gasCost: (ikmHex) => {
-    const ikmBytes = import_viem18.isHex(ikmHex) ? import_viem18.hexToBytes(ikmHex) : import_viem18.stringToBytes(ikmHex);
+    const ikmBytes = import_viem20.isHex(ikmHex) ? import_viem20.hexToBytes(ikmHex) : import_viem20.stringToBytes(ikmHex);
     const linearGasCost = calcLinearGasCost({
       bus: 32,
       len: ikmBytes.length,
@@ -3983,13 +3885,13 @@ var hdfkPrecompile = {
     return 2n * linearGasCost + HKDF_EXPAND_COST_GAS;
   },
   encodeParams: (input) => {
-    if (import_viem18.isHex(input)) {
+    if (import_viem20.isHex(input)) {
       return input;
     }
-    return import_viem18.stringToHex(input);
+    return import_viem20.stringToHex(input);
   },
   decodeResult: (result) => {
-    const [output] = import_viem18.decodeAbiParameters([{ type: "bytes32" }], result);
+    const [output] = import_viem20.decodeAbiParameters([{ type: "bytes32" }], result);
     return output;
   }
 };
@@ -4006,7 +3908,7 @@ var ECDH_ADDRESS = "0x0000000000000000000000000000000000000065";
 var SECRET_KEY_LENGTH = 32;
 var PUBLIC_KEY_LENGTH = 33;
 var validateKey = (key, sk) => {
-  const bytes = import_viem19.hexToBytes(key);
+  const bytes = import_viem21.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})`);
@@ -4021,7 +3923,7 @@ var ecdhPrecompile = {
     return `${sk}${pk.slice(2)}`;
   },
   decodeResult: (result) => {
-    const [output] = import_viem19.decodeAbiParameters([{ type: "bytes32" }], result);
+    const [output] = import_viem21.decodeAbiParameters([{ type: "bytes32" }], result);
     return output;
   }
 };
@@ -4034,7 +3936,7 @@ var ecdh = async (client, args) => {
 };
 
 // src/precompiles/rng.ts
-var import_viem20 = require("viem");
+var import_viem22 = require("viem");
 var RNG_ADDRESS = "0x0000000000000000000000000000000000000064";
 var RNG_INIT_BASE_GAS = 3500n;
 var STROBE_128_WORD_GAS = 5n;
@@ -4042,9 +3944,9 @@ var persToBytes = (pers) => {
   if (!pers) {
     return new Uint8Array;
   }
-  if (import_viem20.isHex(pers)) {
-    return import_viem20.hexToBytes(pers);
-  } else if (import_viem20.isBytes(pers)) {
+  if (import_viem22.isHex(pers)) {
+    return import_viem22.hexToBytes(pers);
+  } else if (import_viem22.isBytes(pers)) {
     return pers;
   }
   throw new Error("Invalid pers: must be a hex or bytes array");
@@ -4071,15 +3973,15 @@ var rngPrecompile = {
     if (BigInt(numBytes) > 32n) {
       throw new Error("Invalid length: must be less than or equal to 32");
     }
-    const encodedBytes = import_viem20.numberToHex(numBytes, { size: 4 });
+    const encodedBytes = import_viem22.numberToHex(numBytes, { size: 4 });
     if (!pers) {
       return encodedBytes;
     }
-    const encodedPers = import_viem20.bytesToHex(persToBytes(pers));
+    const encodedPers = import_viem22.bytesToHex(persToBytes(pers));
     return `${encodedBytes}${encodedPers.slice(2)}`;
   },
   decodeResult: (result) => {
-    const [output] = import_viem20.decodeAbiParameters([{ type: "uint256" }], import_viem20.pad(result));
+    const [output] = import_viem22.decodeAbiParameters([{ type: "uint256" }], import_viem22.pad(result));
     return output;
   }
 };
@@ -4092,7 +3994,7 @@ var rng = async (client, args) => {
 };
 
 // src/precompiles/secp256k1.ts
-var import_viem21 = require("viem");
+var import_viem23 = require("viem");
 var SECP256K1_SIG_ADDRESS = "0x0000000000000000000000000000000000000069";
 var SECP256K1_SIG_BASE_GAS = 3000n;
 var secp256k1SigPrecompile = {
@@ -4104,9 +4006,9 @@ var secp256k1SigPrecompile = {
       { name: "messageHash", type: "bytes32" }
     ];
     const skHex = sk;
-    return import_viem21.encodeAbiParameters(params, [skHex, import_viem21.hashMessage(message)]);
+    return import_viem23.encodeAbiParameters(params, [skHex, import_viem23.hashMessage(message)]);
   },
-  decodeResult: import_viem21.parseSignature
+  decodeResult: import_viem23.parseSignature
 };
 var secp256k1Sig = async (client, args) => {
   return callPrecompile({
@@ -4157,104 +4059,345 @@ var shieldedPublicActions = (client) => ({
   aesGcmDecryption: (args) => aesGcmDecrypt(client, args)
 });
 
-// src/abis/src20.ts
-var SRC20Abi = [
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "owner",
-        type: "address",
-        indexed: true
-      },
-      {
-        internalType: "address",
-        name: "spender",
-        type: "address",
-        indexed: true
-      },
-      {
-        internalType: "bytes32",
-        name: "encryptKeyHash",
-        type: "bytes32",
-        indexed: true
-      },
-      {
-        internalType: "bytes",
-        name: "encryptedAmount",
-        type: "bytes",
-        indexed: false
-      }
-    ],
-    type: "event",
-    name: "Approval",
-    anonymous: false
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "from",
-        type: "address",
-        indexed: true
-      },
-      {
-        internalType: "address",
-        name: "to",
-        type: "address",
-        indexed: true
-      },
-      {
-        internalType: "bytes32",
-        name: "encryptKeyHash",
-        type: "bytes32",
-        indexed: true
-      },
-      {
-        internalType: "bytes",
-        name: "encryptedAmount",
-        type: "bytes",
-        indexed: false
-      }
-    ],
-    type: "event",
-    name: "Transfer",
-    anonymous: false
-  },
-  {
-    inputs: [],
-    stateMutability: "view",
-    type: "function",
-    name: "DOMAIN_SEPARATOR",
-    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }]
-  },
-  {
-    inputs: [],
-    stateMutability: "view",
-    type: "function",
-    name: "INTELLIGENCE_ADDRESS",
-    outputs: [{ internalType: "address", name: "", type: "address" }]
-  },
-  {
-    inputs: [{ internalType: "address", name: "spender", type: "address" }],
-    stateMutability: "view",
-    type: "function",
-    name: "allowance",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }]
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "spender", type: "address" },
-      { internalType: "suint256", name: "amount", type: "suint256" }
-    ],
-    stateMutability: "nonpayable",
-    type: "function",
-    name: "approve",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }]
-  },
-  {
-    inputs: [],
-    stateMutability: "view",
+// src/tx/sendTransparent.ts
+var import_accounts3 = require("viem/accounts");
+var import_actions6 = 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_actions6.sendTransaction(client, parameters);
+    }
+    const request = await import_actions6.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_actions6.sendRawTransaction, "sendRawTransaction")({
+      serializedTransaction
+    });
+  } catch (err) {
+    throw import_utils13.getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain || undefined
+    });
+  }
+}
+
+// src/actions/wallet.ts
+var shieldedWalletActions = (client) => {
+  return {
+    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) => 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_viem24 = 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_viem24.bytesToHex(pt.toRawBytes(true));
+};
+
+// src/extensions/depositContract.ts
+var import_actions7 = require("viem/actions");
+
+// src/abis/depositContract.ts
+var depositContractAbi = [
+  {
+    type: "constructor",
+    inputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "deposit",
+    inputs: [
+      { name: "node_pubkey", type: "bytes", internalType: "bytes" },
+      { name: "consensus_pubkey", type: "bytes", internalType: "bytes" },
+      { name: "withdrawal_credentials", type: "bytes", internalType: "bytes" },
+      { name: "node_signature", type: "bytes", internalType: "bytes" },
+      { name: "consensus_signature", type: "bytes", internalType: "bytes" },
+      { name: "deposit_data_root", type: "bytes32", internalType: "bytes32" }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "get_deposit_count",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes", internalType: "bytes" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "get_deposit_root",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "supportsInterface",
+    inputs: [{ name: "interfaceId", type: "bytes4", internalType: "bytes4" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "pure"
+  },
+  {
+    type: "event",
+    name: "DepositEvent",
+    inputs: [
+      {
+        name: "node_pubkey",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      {
+        name: "consensus_pubkey",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      {
+        name: "withdrawal_credentials",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      { name: "amount", type: "bytes", indexed: false, internalType: "bytes" },
+      {
+        name: "node_signature",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      {
+        name: "consensus_signature",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      { name: "index", type: "bytes", indexed: false, internalType: "bytes" }
+    ],
+    anonymous: false
+  }
+];
+
+// src/extensions/depositContract.ts
+var DEPOSIT_CONTRACT_ADDRESS = "0x00000000219ab540356cBB839Cbe05303d7705Fa";
+var depositContractPublicActions = (client) => ({
+  getDepositRoot: async (args) => import_actions7.readContract(client, {
+    abi: depositContractAbi,
+    address: args.address || DEPOSIT_CONTRACT_ADDRESS,
+    functionName: "get_deposit_root"
+  }),
+  getDepositCount: async (args) => import_actions7.readContract(client, {
+    abi: depositContractAbi,
+    address: args.address || DEPOSIT_CONTRACT_ADDRESS,
+    functionName: "get_deposit_count"
+  })
+});
+var depositContractWalletActions = (client) => ({
+  deposit: async (args) => import_actions7.writeContract(client, {
+    abi: depositContractAbi,
+    address: args.address || DEPOSIT_CONTRACT_ADDRESS,
+    functionName: "deposit",
+    args: [
+      args.nodePubkey,
+      args.consensusPubkey,
+      args.withdrawalCredentials,
+      args.nodeSignature,
+      args.consensusSignature,
+      args.depositDataRoot
+    ],
+    value: args.value
+  })
+});
+
+// src/abis/src20.ts
+var SRC20Abi = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address",
+        indexed: true
+      },
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address",
+        indexed: true
+      },
+      {
+        internalType: "bytes32",
+        name: "encryptKeyHash",
+        type: "bytes32",
+        indexed: true
+      },
+      {
+        internalType: "bytes",
+        name: "encryptedAmount",
+        type: "bytes",
+        indexed: false
+      }
+    ],
+    type: "event",
+    name: "Approval",
+    anonymous: false
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address",
+        indexed: true
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address",
+        indexed: true
+      },
+      {
+        internalType: "bytes32",
+        name: "encryptKeyHash",
+        type: "bytes32",
+        indexed: true
+      },
+      {
+        internalType: "bytes",
+        name: "encryptedAmount",
+        type: "bytes",
+        indexed: false
+      }
+    ],
+    type: "event",
+    name: "Transfer",
+    anonymous: false
+  },
+  {
+    inputs: [],
+    stateMutability: "view",
+    type: "function",
+    name: "DOMAIN_SEPARATOR",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }]
+  },
+  {
+    inputs: [],
+    stateMutability: "view",
+    type: "function",
+    name: "INTELLIGENCE_ADDRESS",
+    outputs: [{ internalType: "address", name: "", type: "address" }]
+  },
+  {
+    inputs: [{ internalType: "address", name: "spender", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+    name: "allowance",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }]
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "spender", type: "address" },
+      { internalType: "suint256", name: "amount", type: "suint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+    name: "approve",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }]
+  },
+  {
+    inputs: [],
+    stateMutability: "view",
     type: "function",
     name: "balance",
     outputs: [{ internalType: "uint256", name: "", type: "uint256" }]
@@ -4342,7 +4485,7 @@ var SRC20Abi = [
   }
 ];
 
-// src/actions/src20/crypto.ts
+// src/extensions/src20/crypto.ts
 var NONCE_LENGTH = 24;
 function parseEncryptedData(encryptedData) {
   if (!encryptedData || encryptedData === "0x" || encryptedData.length <= 2) {
@@ -4353,8 +4496,8 @@ function parseEncryptedData(encryptedData) {
   return { ciphertext, nonce };
 }
 
-// src/actions/src20/directory.ts
-var import_viem22 = require("viem");
+// src/extensions/src20/directory.ts
+var import_viem25 = require("viem");
 
 // src/abis/directory.ts
 var DIRECTORY_ADDRESS = "0x1000000000000000000000000000000000000004";
@@ -4389,7 +4532,7 @@ var DirectoryAbi = [
   }
 ];
 
-// src/actions/src20/directory.ts
+// src/extensions/src20/directory.ts
 var TX_TIMEOUT_MS = 30000;
 function withTimeout(promise, ms) {
   const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error(`Transaction timed out after ${ms}ms`)), ms));
@@ -4432,10 +4575,10 @@ async function registerKey(client, aesKey) {
   return withTimeout(txPromise, TX_TIMEOUT_MS);
 }
 function computeKeyHash(aesKey) {
-  return import_viem22.keccak256(aesKey);
+  return import_viem25.keccak256(aesKey);
 }
 
-// src/actions/src20/watchSRC20Events.ts
+// src/extensions/src20/watchSRC20Events.ts
 async function watchSRC20Events(client, params) {
   const { address, onTransfer, onApproval, onError } = params;
   const aesKey = await getKey(client);
@@ -4500,7 +4643,7 @@ async function watchSRC20Events(client, params) {
   };
 }
 
-// src/actions/src20/watchSRC20EventsWithKey.ts
+// src/extensions/src20/watchSRC20EventsWithKey.ts
 async function watchSRC20EventsWithKey(client, viewingKey, params) {
   const { address, onTransfer, onApproval, onError } = params;
   const aesCipher = new AesGcmCrypto(viewingKey);
@@ -4561,7 +4704,7 @@ async function watchSRC20EventsWithKey(client, viewingKey, params) {
   };
 }
 
-// src/actions/src20/src20Actions.ts
+// src/extensions/src20/src20Actions.ts
 var src20PublicActions = (client) => ({
   watchSRC20EventsWithKey: (viewingKey, params) => watchSRC20EventsWithKey(client, viewingKey, params)
 });
@@ -4569,130 +4712,6 @@ 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 shieldedWalletActions = (client) => {
-  return {
-    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) => 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_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_viem23.bytesToHex(pt.toRawBytes(true));
-};
-
 // src/client.ts
 var getEncryption = (networkPk, clientSk) => {
   const encryptionPrivateKey = clientSk ?? import_accounts4.generatePrivateKey();
@@ -4705,7 +4724,7 @@ var getEncryption = (networkPk, clientSk) => {
   return { encryptionPrivateKey, encryptionPublicKey, aesKey };
 };
 var createShieldedPublicClient = (parameters) => {
-  const viemPublicClient = import_viem24.createPublicClient(parameters);
+  const viemPublicClient = import_viem26.createPublicClient(parameters);
   return viemPublicClient.extend(shieldedPublicActions).extend(depositContractPublicActions).extend(src20PublicActions);
 };
 var getSeismicClients = async ({
@@ -4721,12 +4740,12 @@ var getSeismicClients = async ({
   });
   const networkPublicKey = await pubClient.getTeePublicKey();
   const { aesKey, encryptionPublicKey } = getEncryption(networkPublicKey, encryptionSk);
-  const wallet = import_viem24.createClient({
+  const wallet = import_viem26.createClient({
     account,
     chain,
     transport,
     rpcSchema: seismicRpcSchema
-  }).extend(import_viem24.walletActions).extend(() => import_viem24.publicActions(pubClient)).extend(() => encryptionActions(aesKey, encryptionPublicKey)).extend(() => shieldedPublicActions(pubClient)).extend(shieldedWalletActions).extend(depositContractWalletActions).extend(src20WalletActions);
+  }).extend(import_viem26.walletActions).extend(() => import_viem26.publicActions(pubClient)).extend(() => encryptionActions(aesKey, encryptionPublicKey)).extend(() => shieldedPublicActions(pubClient)).extend(shieldedWalletActions).extend(depositContractWalletActions).extend(src20WalletActions);
   return {
     public: pubClient,
     wallet
@@ -4748,9 +4767,11 @@ var createShieldedWalletClient = async ({
   });
   return clients.wallet;
 };
-// src/faucet.ts
+// src/extensions/faucet.ts
 var import_utils14 = require("viem/utils");
 var DEFAULT_MIN_BALANCE_WEI = import_utils14.parseEther("0.5");
+var TXHASH_PREFIX = "Txhash: ";
+var HASH_HEX_LENGTH = 66;
 var parseMinBalance = (minBalanceWei, minBalanceEther) => {
   if (minBalanceWei && minBalanceEther) {
     if (BigInt(minBalanceWei) !== import_utils14.parseEther(minBalanceEther.toString())) {
@@ -4765,6 +4786,16 @@ var parseMinBalance = (minBalanceWei, minBalanceEther) => {
   }
   return DEFAULT_MIN_BALANCE_WEI;
 };
+var parseFaucetResponseHash = (msg) => {
+  if (!msg.startsWith(TXHASH_PREFIX)) {
+    return null;
+  }
+  const hash = msg.slice(TXHASH_PREFIX.length);
+  if (!hash.startsWith("0x") || hash.length !== HASH_HEX_LENGTH) {
+    throw new Error(`Invalid hash from faucet claim: ${hash}`);
+  }
+  return hash;
+};
 var checkFaucet = async ({
   address,
   publicClient,
@@ -4785,20 +4816,14 @@ var checkFaucet = async ({
     throw new Error(`Faucet request failed with status ${response.status}: ${await response.text()}`);
   }
   const { msg } = await response.json();
-  if (msg.startsWith("Txhash: ")) {
-    const hash = msg.slice(8);
-    if (hash.startsWith("0x") && hash.length === 66) {
-      const txUrl = txExplorerUrl({ chain: publicClient.chain, txHash: hash });
-      if (txUrl) {
-        console.debug(`Faucet sent eth to ${address}: ${txUrl}`);
-      }
-      await publicClient.waitForTransactionReceipt({ hash });
-      return { sent: true, hash, txUrl: txUrl ?? undefined };
-    } else {
-      throw new Error(`Invalid hash from faucet claim: ${hash}`);
-    }
+  const hash = parseFaucetResponseHash(msg);
+  if (!hash) {
+    throw new Error(`Faucet claim failed: ${msg}`);
+  }
+  const txUrl = txExplorerUrl({ chain: publicClient.chain, txHash: hash });
+  if (txUrl) {
+    console.debug(`Faucet sent eth to ${address}: ${txUrl}`);
   }
-  throw new Error(`Faucet claim failed: ${msg}`);
+  await publicClient.waitForTransactionReceipt({ hash });
+  return { sent: true, hash, txUrl: txUrl ?? undefined };
 };
-// src/utils.ts
-var stringifyBigInt = (_, v) => typeof v === "bigint" ? v.toString() : v;