@unionlabs/payments 0.1.0 → 0.2.0

package/dist/esm/EvmWalletClient.js

@@ -0,0 +1,659 @@
+import * as A from "effect/Array";
+import * as Brand from "effect/Brand";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+// import type * as ThirdwebAdaptersViem from "thirdweb/adapters/viem"
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Number from "effect/Number";
+import * as Ref from "effect/Ref";
+import * as Abi from "./Abi.js";
+import * as ZAssetRegistry from "./constants/z-asset-registry.js";
+import * as Domain from "./Domain.js";
+import * as Error from "./Error.js";
+import * as EvmPublicClient from "./EvmPublicClient.js";
+import * as Client from "./WalletClient.js";
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export const TypeId = "@unionlabs/payments/EvmWalletClient";
+/**
+ * @category tags
+ * @since 1.0.0
+ */
+export const EvmWalletClient = /*#__PURE__*/Context.GenericTag("@unionlabs/payments/EvmWalletClient");
+/**
+ * A type-safe wrapper around viem's writeContract that handles error cases
+ * and returns an Effect with proper type inference. Extracts all error info
+ *
+ * @param client - The viem WalletClient to use for the contract transaction
+ * @param params - The parameters for the contract transaction
+ * @returns An Effect that resolves to the transaction hash
+ *
+ * @category utils
+ * @since 0.0.0
+ */
+export const makeViem = wallet => Effect.gen(function* () {
+  const Viem = yield* Effect.tryPromise({
+    try: () => import("viem").then(x => x),
+    catch: cause => new Error.SystemError({
+      reason: "DynamicImport",
+      method: "makeViem",
+      module: "EvmWalletClient",
+      cause,
+      description: "could not import viem"
+    })
+  });
+  const ViemActions = yield* Effect.tryPromise({
+    try: () => import("viem/actions").then(x => x),
+    catch: cause => new Error.SystemError({
+      reason: "DynamicImport",
+      method: "makeViemActions",
+      module: "EvmWalletClient",
+      cause,
+      description: "could not import viem/actions"
+    })
+  });
+  const publicClient = yield* pipe(Effect.try({
+    try: () => Viem.createPublicClient({
+      chain: wallet.chain,
+      transport: Viem.custom(wallet)
+    }),
+    catch: cause => new Error.SystemError({
+      reason: "DynamicImport",
+      method: "make",
+      module: "EvmWalletClient",
+      cause,
+      description: "could derive public client from wallet client"
+    })
+  }), Effect.flatMap(x => EvmPublicClient.makeViem(x)));
+  // Use "latest" to avoid stale pending txs in mempool
+  const transactionCount = yield* pipe(Effect.tryPromise({
+    try: () => ViemActions.getTransactionCount(wallet, {
+      address: wallet.account?.address,
+      blockTag: "latest"
+    }),
+    catch: cause => new Error.SystemError({
+      reason: "InvalidData",
+      method: "encodeFunctionData",
+      module: "EvmWalletClient",
+      cause
+    })
+  }), Effect.flatMap(Ref.make));
+  const encodeFunctionData = Effect.fn("encodeFunctionData")(
+  //<
+  // const abi extends Viem.Abi | readonly unknown[],
+  // functionName extends Viem.ContractFunctionName<abi> | undefined = undefined,
+  //>(
+  parameters => Effect.try({
+    try: () => Viem.encodeFunctionData(parameters),
+    catch: cause => new Error.SystemError({
+      reason: "InvalidData",
+      method: "encodeFunctionData",
+      module: "EvmWalletClient",
+      cause
+    })
+  }));
+  const writeContract = Effect.fn("writeContract")(params => pipe(Effect.tryPromise({
+    try: () => wallet.writeContract(params),
+    catch: cause => new Error.SystemError({
+      method: "writeContract",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })
+  }), Effect.map(hash => Domain.SubmissionResult.viemWriteContract({
+    hash: Brand.nominal()(hash)
+  }))));
+  const prepareTransactionRequest = Effect.fn("prepareTransactionRequest")(params => pipe(Ref.get(transactionCount), Effect.flatMap(nonce => Effect.tryPromise({
+    try: () => wallet.prepareTransactionRequest({
+      ...params,
+      nonce
+    }),
+    catch: cause => new Error.SystemError({
+      method: "prepareTransactionRequest",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })
+  })), Effect.tap(() => Ref.update(transactionCount, Number.increment))));
+  const prepareBatchTransactionRequest = Effect.fn("prepareBatchTransactionRequest")(calls => Effect.gen(function* () {
+    // Refresh nonce from chain before batch to ensure we're in sync
+    const chainNonce = yield* Effect.tryPromise({
+      try: () => ViemActions.getTransactionCount(wallet, {
+        address: wallet.account?.address,
+        blockTag: "latest"
+      }),
+      catch: cause => new Error.SystemError({
+        reason: "InvalidData",
+        method: "prepareBatchTransactionRequest",
+        module: "EvmWalletClient",
+        cause
+      })
+    });
+    yield* Ref.set(transactionCount, chainNonce);
+    yield* Effect.log("[prepareBatchTransactionRequest] Synced nonce", {
+      chainNonce
+    });
+    const simulationResult = yield* publicClient.simulateCalls({
+      calls: calls.map(call => ({
+        to: call.to,
+        data: call.data,
+        value: call.value
+      })),
+      account: wallet.account?.address
+    });
+    yield* Effect.log("[prepareBatchTransactionRequest] Simulation results", {
+      results: simulationResult.results
+    });
+    // Extract gas estimates with 20% buffer for safety
+    const gasEstimates = simulationResult.results?.map(r => r?.gasUsed ? BigInt(r.gasUsed) * 120n / 100n : undefined) ?? [];
+    yield* Effect.log("[prepareBatchTransactionRequest] Gas estimates", {
+      gasEstimates
+    });
+    // Prepare each transaction with gas
+    const prepared = [];
+    for (let i = 0; i < calls.length; i++) {
+      const call = calls[i];
+      const gas = gasEstimates[i];
+      const nonce = yield* Ref.get(transactionCount);
+      const request = yield* Effect.tryPromise({
+        try: () => wallet.prepareTransactionRequest({
+          to: call.to,
+          data: call.data,
+          ...(call.value !== undefined && {
+            value: call.value
+          }),
+          ...(gas !== undefined && {
+            gas
+          }),
+          nonce,
+          chain: wallet.chain
+        }),
+        catch: cause => new Error.SystemError({
+          method: "prepareBatchTransactionRequest",
+          module: "EvmWalletClient",
+          reason: "InvalidData",
+          cause
+        })
+      });
+      yield* Ref.update(transactionCount, Number.increment);
+      prepared.push(request);
+    }
+    return prepared;
+  }));
+  const signTransaction = Effect.fn("signTransaction")(params => Effect.tryPromise({
+    try: () => wallet.signTransaction(params),
+    catch: cause => new Error.SystemError({
+      method: "signTransaction",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })
+  }));
+  const sendRawTransaction = Effect.fn("sendRawTransaction")(params => Effect.tryPromise({
+    try: () => wallet.sendRawTransaction(params),
+    catch: cause => new Error.SystemError({
+      method: "sendRawTransaction",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })
+  }));
+  const sign = Effect.fn("sign")(request => pipe(request, Effect.liftPredicate(Domain.PreparedRequest.$is("viem"), cause => new Error.SystemError({
+    method: "sign",
+    module: "EvmWalletClient",
+    reason: "InvalidData",
+    cause
+  })), Effect.map(x => x.request), Effect.flatMap(value => signTransaction({
+    ...value,
+    account: wallet.account,
+    chain: wallet.chain
+  })), Effect.map(value => Domain.SignedRequest.viem({
+    value: value
+  }))));
+  const submit = Effect.fn("submit")(request => pipe(request, Effect.liftPredicate(Domain.SignedRequest.$is("viem"), cause => new Error.SystemError({
+    method: "submit",
+    module: "EvmWalletClient",
+    reason: "InvalidData",
+    cause
+  })), Effect.map(x => x.value), Effect.flatMap(serializedTransaction => sendRawTransaction({
+    serializedTransaction
+  })), Effect.map(hash => Domain.SubmissionResult.viemWriteContract({
+    hash: Brand.nominal()(hash)
+  }))));
+  const signAndSubmit = Effect.fn("signAndSubmit")(request => pipe(request, Effect.liftPredicate(Domain.PreparedRequest.$is("viem"), cause => new Error.SystemError({
+    method: "signAndSubmit",
+    module: "EvmWalletClient",
+    reason: "InvalidData",
+    cause
+  })), Effect.flatMap(prepared => Effect.tryPromise({
+    try: () => ViemActions.sendTransaction(wallet, {
+      to: prepared.request.to,
+      data: prepared.request.data,
+      value: prepared.request.value,
+      gas: prepared.request.gas,
+      nonce: prepared.request.nonce,
+      account: wallet.account,
+      chain: wallet.chain
+    }),
+    catch: cause => new Error.SystemError({
+      method: "signAndSubmit",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })
+  })), Effect.map(hash => Domain.SubmissionResult.viemWriteContract({
+    hash: Brand.nominal()(hash)
+  }))));
+  // TODO: check if required
+  const approveZAssetToSpendErc20 = Effect.fn("approveZAssetToSpendErc20")(function* (args) {
+    return yield* pipe(
+    // XXX: fix hardcoded chainid
+    ZAssetRegistry.getZAsset(8453n, args.srcErc20Address), Effect.mapError(cause => new Error.SystemError({
+      method: "approveZAssetToSpendErc20",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })), Effect.flatMap(zAsset => encodeFunctionData({
+      abi: Abi.ERC20_ABI,
+      functionName: "approve",
+      args: [zAsset, args.amount]
+    })), Effect.flatMap(data => prepareTransactionRequest({
+      to: args.srcErc20Address,
+      data,
+      chain: wallet.chain
+    })), Effect.map(request => Domain.PreparedRequest.viem({
+      request: request,
+      kind: "approval"
+    })));
+  });
+  // TODO: check if required
+  const updateLoopbackClient = Effect.fn("updateLoopbackClient")(function* ({
+    clientId,
+    height,
+    ibcHandlerAddress
+  }) {
+    // const publicClient = Viem.createPublicClient({
+    //   transport: Viem.http(wallet.transport.rpcUrl),
+    // });
+    const publicClient = wallet.extend(Viem.publicActions);
+    const blockNumber = height;
+    const block = yield* Effect.tryPromise({
+      try: () => publicClient.getBlock({
+        blockNumber
+      }),
+      catch: cause => new Error.SystemError({
+        module: "EvmWalletClient",
+        method: "updateLoopbackClient",
+        reason: "InvalidData",
+        description: "Cannot getBlockNumber",
+        cause
+      })
+    });
+    // if (!block.number) {
+    //   throw new Error("Block number is null");
+    // }
+    // Helper to convert bigint/number to minimal RLP hex encoding
+    const toRlpHex = value => {
+      if (value === undefined || value === null || value === 0n || value === 0) {
+        return "0x";
+      }
+      let hex = typeof value === "bigint" ? value.toString(16) : value.toString(16);
+      if (hex.length % 2 !== 0) {
+        hex = "0" + hex;
+      }
+      return `0x${hex}`;
+    };
+    // Build header fields in order (pre-merge + post-merge fields)
+    const headerFields = [block.parentHash, block.sha3Uncles, block.miner, block.stateRoot, block.transactionsRoot, block.receiptsRoot, block.logsBloom ?? "0x" + "00".repeat(256), toRlpHex(block.difficulty), toRlpHex(block.number), toRlpHex(block.gasLimit), toRlpHex(block.gasUsed), toRlpHex(block.timestamp), block.extraData, block.mixHash ?? "0x0000000000000000000000000000000000000000000000000000000000000000", block.nonce ?? "0x0000000000000000"];
+    // Post-merge fields
+    if (block.baseFeePerGas !== undefined && block.baseFeePerGas !== null) {
+      headerFields.push(toRlpHex(block.baseFeePerGas));
+    }
+    if (block.withdrawalsRoot) {
+      headerFields.push(block.withdrawalsRoot);
+    }
+    if (block.blobGasUsed !== undefined && block.blobGasUsed !== null) {
+      headerFields.push(toRlpHex(block.blobGasUsed));
+    }
+    if (block.excessBlobGas !== undefined && block.excessBlobGas !== null) {
+      headerFields.push(toRlpHex(block.excessBlobGas));
+    }
+    if (block.parentBeaconBlockRoot) {
+      headerFields.push(block.parentBeaconBlockRoot);
+    }
+    const blockAny = block;
+    if (blockAny.requestsHash) {
+      headerFields.push(blockAny.requestsHash);
+    }
+    const rlpEncoded = Viem.toRlp(headerFields);
+    // Verify the encoding produces the correct block hash
+    const computedHash = Viem.keccak256(rlpEncoded);
+    if (computedHash !== block.hash) {
+      return yield* new Error.SystemError({
+        module: "EvmWalletClient",
+        method: "updateLooopbackClient",
+        reason: "InvalidData",
+        description: `RLP encoding mismatch: computed hash ${computedHash} does not match block hash ${block.hash}`
+      });
+    }
+    // Encode the Header struct: (uint64 height, bytes encodedHeader)
+    const clientMessage = Viem.encodeAbiParameters([{
+      type: "uint64",
+      name: "height"
+    }, {
+      type: "bytes",
+      name: "encodedHeader"
+    }], [block.number, rlpEncoded]);
+    const LIGHTCLIENT_ABI = [{
+      inputs: [{
+        name: "caller",
+        type: "address"
+      }, {
+        name: "clientId",
+        type: "uint32"
+      }, {
+        name: "clientMessage",
+        type: "bytes"
+      }, {
+        name: "relayer",
+        type: "address"
+      }],
+      name: "updateClient",
+      outputs: [],
+      stateMutability: "nonpayable",
+      type: "function"
+    }];
+    // Wait for the next block so the fetched block's hash is verifiable on-chain
+    let currentBlock = yield* Effect.tryPromise({
+      try: () => publicClient.getBlockNumber(),
+      catch: cause => new Error.SystemError({
+        module: "EvmWalletClient",
+        method: "updateLoopbackClient",
+        reason: "InvalidData",
+        description: "Cannot getBlockNumber",
+        cause
+      })
+    });
+    while (currentBlock <= blockNumber) {
+      yield* Effect.sleep("1 second");
+      currentBlock = yield* Effect.tryPromise({
+        try: () => publicClient.getBlockNumber(),
+        catch: cause => new Error.SystemError({
+          module: "EvmWalletClient",
+          method: "updateLoopbackClient",
+          reason: "InvalidData",
+          description: "Cannot getBlockNumber",
+          cause
+        })
+      });
+    }
+    const loopbackClient = yield* Effect.tryPromise({
+      try: () => publicClient.readContract({
+        address: ibcHandlerAddress,
+        abi: Abi.IBC_STORE_ABI,
+        functionName: "getClient",
+        args: [clientId]
+      }),
+      catch: cause => new Error.SystemError({
+        module: "EvmWalletClient",
+        method: "updateLoopbackClient",
+        reason: "InvalidData",
+        description: "cannot get client given ibc handler address",
+        cause
+      })
+    });
+    return yield* pipe(encodeFunctionData({
+      abi: LIGHTCLIENT_ABI,
+      functionName: "updateClient",
+      args: [wallet.account.address, clientId, clientMessage, wallet.account.address]
+    }), Effect.flatMap(data => prepareTransactionRequest({
+      to: loopbackClient,
+      data,
+      chain: wallet.chain
+    })), Effect.map(request => Domain.PreparedRequest.viem({
+      request: request,
+      kind: "transfer"
+    })));
+  });
+  const depositUnderlyingZAsset = Effect.fn("depositUnderlyingZAsset")(function* (args) {
+    const zAssetAddr = yield* ZAssetRegistry.getZAsset(8453n, args.srcErc20Address).pipe(Effect.mapError(cause => new Error.SystemError({
+      method: "depositUnderlyingZAsset",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })));
+    return yield* pipe(encodeFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "deposit",
+      args: [args.amount]
+    }), Effect.flatMap(data => prepareTransactionRequest({
+      to: zAssetAddr,
+      data,
+      chain: wallet.chain
+    })), Effect.map(request => Domain.PreparedRequest.viem({
+      request: request,
+      kind: "deposit"
+    })));
+  });
+  const transferZAsset = Effect.fn("transferZAsset")(function* (args) {
+    const zAssetAddr = yield* ZAssetRegistry.getZAsset(8453n, args.srcErc20Address).pipe(Effect.mapError(cause => new Error.SystemError({
+      method: "transferZAsset",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })));
+    return yield* pipe(encodeFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "transfer",
+      args: [args.depositAddress, args.amount]
+    }), Effect.flatMap(data => prepareTransactionRequest({
+      to: zAssetAddr,
+      data,
+      chain: wallet.chain
+    })), Effect.map(request => Domain.PreparedRequest.viem({
+      request: request,
+      kind: "transfer"
+    })));
+  });
+  const prepareDeposit = Effect.fn("prepareDeposit")(function* (args) {
+    const zAssetAddress = ZAssetRegistry.Z_ASSET_REGISTRY[`${args.sourceChainId}`][args.srcErc20Address];
+    if (!zAssetAddress) {
+      return yield* new Error.SystemError({
+        method: "deposit",
+        module: "PaymentClient",
+        reason: "InvalidData",
+        description: `No zAsset found for ${args.srcErc20Address} on chain ${args.sourceChainId}`
+      });
+    }
+    const [approvalData, depositData, transferData] = yield* Effect.all([encodeFunctionData({
+      abi: Abi.ERC20_ABI,
+      functionName: "approve",
+      args: [zAssetAddress, args.amount]
+    }), encodeFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "deposit",
+      args: [args.amount]
+    }), encodeFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "transfer",
+      args: [args.depositAddress, args.amount]
+    })], {
+      concurrency: "unbounded"
+    });
+    const preparedTxs = yield* prepareBatchTransactionRequest([{
+      to: args.srcErc20Address,
+      data: approvalData
+    }, {
+      to: zAssetAddress,
+      data: depositData
+    }, {
+      to: zAssetAddress,
+      data: transferData
+    }]);
+    const approval = Domain.PreparedRequest.viem({
+      request: preparedTxs[0],
+      kind: "approval"
+    });
+    const deposit = Domain.PreparedRequest.viem({
+      request: preparedTxs[1],
+      kind: "deposit"
+    });
+    const transfer = Domain.PreparedRequest.viem({
+      request: preparedTxs[2],
+      kind: "transfer"
+    });
+    yield* Effect.log("[deposit]", {
+      approval,
+      deposit,
+      transfer
+    });
+    return [approval, deposit, transfer];
+  });
+  const prepareRedemption = Effect.fn("prepareRedemption")(function* (args) {
+    const zAssetAddr = yield* ZAssetRegistry.getZAsset(8453n, args.dstErc20Address).pipe(Effect.mapError(cause => new Error.SystemError({
+      method: "transferZAsset",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })));
+    return yield* pipe(encodeFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "redeem",
+      args: [args.proof, args.commitments, args.commitmentPok, args.lightClients, args.nullifier, args.value, args.beneficiary, args.attestedMessage, args.signature, args.unwrap ?? true]
+    }), Effect.flatMap(data => prepareTransactionRequest({
+      to: zAssetAddr,
+      data,
+      chain: wallet.chain
+    })), Effect.map(request => Domain.PreparedRequest.viem({
+      request: request,
+      kind: "approval"
+    })));
+  });
+  return Object.assign(yield* Client.make({
+    sign,
+    submit,
+    approveZAssetToSpendErc20,
+    updateLoopbackClient,
+    depositUnderlyingZAsset,
+    transferZAsset,
+    prepareDeposit,
+    prepareRedemption,
+    signAndSubmit
+  }), {
+    [TypeId]: TypeId,
+    signTransaction,
+    sendRawTransaction,
+    writeContract,
+    prepareBatchTransactionRequest
+  });
+});
+/**
+ * @category layers
+ * @since 1.0.0
+ */
+export const layerFromViem = config => Layer.scopedContext(Effect.map(makeViem(config), client => Context.make(EvmWalletClient, client).pipe(Context.add(Client.WalletClient, client))));
+const makeBrowser = /*#__PURE__*/Effect.fn(function* (options) {
+  const Mipd = yield* Effect.tryPromise({
+    try: () => import("mipd").then(x => x),
+    catch: cause => new Error.SystemError({
+      reason: "DynamicImport",
+      method: "makeBrowser",
+      module: "EvmWalletClient",
+      cause,
+      description: "could not import mipd"
+    })
+  });
+  const store = Mipd.createStore();
+  yield* Effect.log({
+    store
+  });
+  const providers = store.getProviders();
+  yield* Effect.log({
+    providers
+  });
+  const selected = yield* pipe(A.findFirst(providers, options.providerPredicate), Effect.mapError(cause => new Error.SystemError({
+    reason: "DynamicImport",
+    method: "makeBrowser",
+    module: "EvmWalletClient",
+    cause,
+    description: "could not find provider"
+  })));
+  yield* Effect.log({
+    selected
+  });
+  const account = yield* pipe(Effect.tryPromise({
+    try: () => selected.provider.request({
+      method: "eth_requestAccounts"
+    }),
+    catch: cause => new Error.SystemError({
+      reason: "DynamicImport",
+      method: "makeBrowser",
+      module: "EvmWalletClient",
+      cause,
+      description: "could not request accounts"
+    })
+  }), Effect.flatMap(A.findFirst(options.accountPredicate)), Effect.catchTag("NoSuchElementException", cause => new Error.SystemError({
+    reason: "DynamicImport",
+    method: "makeBrowser",
+    module: "EvmWalletClient",
+    cause,
+    description: "could not match account by predicate"
+  })));
+  const Viem = yield* Effect.tryPromise({
+    try: () => import("viem").then(x => x),
+    catch: cause => new Error.SystemError({
+      reason: "DynamicImport",
+      method: "makeViem",
+      module: "EvmWalletClient",
+      cause,
+      description: "could not import viem"
+    })
+  });
+  const ViemChains = yield* Effect.tryPromise({
+    try: () => import("viem/chains").then(x => x),
+    catch: cause => new Error.SystemError({
+      reason: "DynamicImport",
+      method: "makeViem",
+      module: "EvmWalletClient",
+      cause,
+      description: "could not import viem/chains"
+    })
+  });
+  const wallet = yield* Effect.try({
+    try: () => Viem.createWalletClient({
+      account: account,
+      chain: ViemChains.base,
+      transport: Viem.custom(selected.provider)
+    }),
+    catch: cause => new Error.SystemError({
+      reason: "DynamicImport",
+      method: "makeViem",
+      module: "EvmWalletClient",
+      cause,
+      description: "could not import viem/chains"
+    })
+  });
+  return layerFromViem(wallet);
+});
+// export const makeThirdweb = Effect.fn(function* (...options: Parameters<typeof ThirdwebAdaptersViem['viemAdapter']['wallet']['toViem']>) {
+//   const { viemAdapter } = yield* Effect.tryPromise({
+//     try: () => import("thirdweb/adapters/viem"),
+//     catch: (cause) => new Error.SystemError({
+//       method: "makeThirdweb",
+//       module: "EvmWalletClient",
+//       reason: "DynamicImport",
+//       cause,
+//     })
+//   })
+//   const wallet = viemAdapter.wallet.toViem(...options)
+//   return layerFromViem(wallet as Viem.WalletClient)
+// })
+/**
+ * @category layers
+ * @since 1.0.0
+ */
+export const layerFromBrowser = options => Layer.unwrapScoped(makeBrowser(options));
+//# sourceMappingURL=EvmWalletClient.js.map