@unionlabs/payments 0.2.1 → 0.3.1

package/dist/cjs/internal/evmWalletClient.js

@@ -3,4 +3,654 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.makeViem = exports.makeBrowser = exports.TypeId = void 0;
+var A = _interopRequireWildcard(require("effect/Array"));
+var Effect = _interopRequireWildcard(require("effect/Effect"));
+var _Function = require("effect/Function");
+var Number = _interopRequireWildcard(require("effect/Number"));
+var Ref = _interopRequireWildcard(require("effect/Ref"));
+var Abi = _interopRequireWildcard(require("../Abi.js"));
+var ZAssetRegistry = _interopRequireWildcard(require("../constants/z-asset-registry.js"));
+var Domain = _interopRequireWildcard(require("../Domain.js"));
+var Error = _interopRequireWildcard(require("../Error.js"));
+var Client = _interopRequireWildcard(require("../WalletClient.js"));
+var internalEvmPublicClient = _interopRequireWildcard(require("./evmPublicClient.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/** @internal */
+const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("@unionlabs/payments/EvmWalletClient");
+/** @internal */
+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* (0, _Function.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(internalEvmPublicClient.makeViem));
+  // Use "latest" to avoid stale pending txs in mempool
+  const transactionCount = yield* (0, _Function.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")(parameters => Effect.try({
+    try: () => Viem.encodeFunctionData(parameters),
+    catch: cause => new Error.SystemError({
+      reason: "InvalidData",
+      method: "encodeFunctionData",
+      module: "EvmWalletClient",
+      cause
+    })
+  }));
+  const validateFunctionData = Effect.fn("validateFunctionData")(parameters => (0, _Function.pipe)(Effect.try({
+    try: () => Viem.encodeFunctionData(parameters),
+    catch: cause => new Error.SystemError({
+      reason: "InvalidData",
+      method: "validateFunctionData",
+      module: "EvmWalletClient",
+      cause
+    })
+  }), Effect.andThen(() => ({
+    ...parameters,
+    args: parameters.args ?? [],
+    functionName: parameters.functionName
+  }))));
+  const writeContract = Effect.fn("writeContract")(params => (0, _Function.pipe)(Effect.tryPromise({
+    try: () => wallet.writeContract(params),
+    catch: cause => new Error.SystemError({
+      method: "writeContract",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })
+  }), Effect.map(hash => Domain.SubmissionResult.SubmissionEvm({
+    hash: Domain.TxHash(hash)
+  }))));
+  const prepareTransactionRequest = Effect.fn("prepareTransactionRequest")(params => (0, _Function.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")(requests => 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 calls = yield* (0, _Function.pipe)(requests, Effect.forEach(request => (0, _Function.pipe)(encodeFunctionData({
+      abi: request.abi,
+      args: request.args,
+      functionName: request.functionName
+    }), Effect.map(data => ({
+      to: request.contractAddress,
+      data,
+      value: undefined
+    })))));
+    yield* Effect.log({
+      calls
+    });
+    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")(function* (request) {
+    const requests = yield* (0, _Function.pipe)(request, A.ensure, Effect.forEach(n => (0, _Function.pipe)(n, Effect.liftPredicate(Domain.PreparedRequest.$is("PreparedEvm"), cause => new Error.SystemError({
+      method: "sign",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })))));
+    return yield* (0, _Function.pipe)(requests, prepareBatchTransactionRequest, Effect.flatMap(Effect.forEach(value => signTransaction({
+      ...value,
+      account: wallet.account,
+      chain: wallet.chain
+    }))),
+    // Effect.tap((success) => Effect.log({ success })),
+    Effect.map(A.map(value => Domain.SignedRequest.SignedEvm({
+      value
+    }))));
+  });
+  const submit = Effect.fn("submit")(request => (0, _Function.pipe)(request, Effect.liftPredicate(Domain.SignedRequest.$is("SignedEvm"), 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.SubmissionEvm({
+    hash: Domain.TxHash(hash)
+  }))));
+  const signAndSubmit = Effect.fn("signAndSubmit")(function* (request) {
+    const _request = yield* Effect.liftPredicate(request, Domain.PreparedRequest.$is("PreparedEvm"), cause => new Error.SystemError({
+      method: "signAndSubmit",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    }));
+    const data = yield* encodeFunctionData({
+      abi: _request.abi,
+      args: _request.args,
+      functionName: _request.functionName
+    });
+    const prepared = yield* prepareTransactionRequest({
+      to: _request.contractAddress,
+      data,
+      chain: wallet.chain
+    });
+    return yield* (0, _Function.pipe)(Effect.tryPromise({
+      try: () => ViemActions.sendTransaction(wallet, {
+        to: prepared.to,
+        data: prepared.data,
+        value: prepared.value,
+        gas: prepared.gas,
+        nonce: prepared.nonce,
+        account: wallet.account,
+        chain: wallet.chain
+      }),
+      catch: cause => new Error.SystemError({
+        method: "signAndSubmit",
+        module: "EvmWalletClient",
+        reason: "InvalidData",
+        cause
+      })
+    }), Effect.map(hash => Domain.SubmissionResult.SubmissionEvm({
+      hash: Domain.TxHash(hash)
+    })));
+  });
+  // TODO: check if required
+  const approveZAssetToSpendErc20 = Effect.fn("approveZAssetToSpendErc20")(function* (args) {
+    return yield* (0, _Function.pipe)(ZAssetRegistry.getZAsset(args.universalChainId, args.srcErc20Address), Effect.mapError(cause => new Error.SystemError({
+      method: "approveZAssetToSpendErc20",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })), Effect.flatMap(zAsset => validateFunctionData({
+      abi: Abi.ERC20_ABI,
+      functionName: "approve",
+      args: [zAsset, args.amount]
+    })), Effect.map(request => Domain.PreparedRequest.PreparedEvm({
+      abi: request.abi,
+      args: request.args ?? [],
+      contractAddress: args.srcErc20Address,
+      functionName: request.functionName || "",
+      universalChainId: args.universalChainId,
+      kind: "Erc20.Approve"
+    })));
+  });
+  // TODO: check if required
+  const updateLoopbackClient = Effect.fn("updateLoopbackClient")(function* ({
+    clientId,
+    height,
+    ibcHandlerAddress,
+    universalChainId
+  }) {
+    // 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* (0, _Function.pipe)(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
+      })
+    }), Effect.map(Domain.Erc20Address));
+    return yield* (0, _Function.pipe)(validateFunctionData({
+      abi: LIGHTCLIENT_ABI,
+      functionName: "updateClient",
+      args: [wallet.account.address, clientId, clientMessage, wallet.account.address]
+    }), Effect.map(data => Domain.PreparedRequest.PreparedEvm({
+      ...data,
+      contractAddress: loopbackClient,
+      universalChainId,
+      kind: "LoopbackClient.Update"
+    })));
+  });
+  const depositUnderlyingZAsset = Effect.fn("depositUnderlyingZAsset")(function* (args) {
+    const zAssetAddress = yield* (0, _Function.pipe)(ZAssetRegistry.getZAsset(args.universalChainId, args.srcErc20Address), Effect.mapError(cause => new Error.SystemError({
+      method: "depositUnderlyingZAsset",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })));
+    return yield* (0, _Function.pipe)(validateFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "deposit",
+      args: [args.amount]
+    }), Effect.map(data => Domain.PreparedRequest.PreparedEvm({
+      ...data,
+      contractAddress: Domain.Erc20Address(zAssetAddress),
+      universalChainId: args.universalChainId,
+      kind: "Erc20.Wrap"
+    })));
+  });
+  const transferZAsset = Effect.fn("transferZAsset")(function* (args) {
+    const zAssetAddress = yield* (0, _Function.pipe)(ZAssetRegistry.getZAsset(args.universalChainId, args.srcErc20Address), Effect.mapError(cause => new Error.SystemError({
+      method: "transferZAsset",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })));
+    return yield* (0, _Function.pipe)(validateFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "transfer",
+      args: [args.depositAddress, args.amount]
+    }), Effect.map(data => Domain.PreparedRequest.PreparedEvm({
+      ...data,
+      contractAddress: Domain.Erc20Address(zAssetAddress),
+      universalChainId: args.universalChainId,
+      kind: "ZAsset.Transfer"
+    })));
+  });
+  const prepareDeposit = Effect.fn("prepareDeposit")(function* (args) {
+    const zAssetAddress = yield* (0, _Function.pipe)(ZAssetRegistry.getZAsset(args.destinationChainId, args.srcErc20Address), Effect.mapError(cause => new Error.SystemError({
+      method: "prepareDeposit",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })));
+    const [approval, deposit, transfer] = yield* Effect.all([(0, _Function.pipe)(validateFunctionData({
+      abi: Abi.ERC20_ABI,
+      functionName: "approve",
+      args: [zAssetAddress, args.amount]
+    }), Effect.map(data => Domain.PreparedRequest.PreparedEvm({
+      ...data,
+      contractAddress: args.srcErc20Address,
+      universalChainId: args.destinationChainId,
+      kind: "Erc20.Approve"
+    }))), (0, _Function.pipe)(validateFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "deposit",
+      args: [args.amount]
+    }), Effect.map(data => Domain.PreparedRequest.PreparedEvm({
+      ...data,
+      contractAddress: Domain.Erc20Address(zAssetAddress),
+      universalChainId: args.destinationChainId,
+      kind: "Erc20.Wrap"
+    }))), (0, _Function.pipe)(validateFunctionData({
+      abi: Abi.ZASSET_ABI,
+      functionName: "transfer",
+      args: [args.depositAddress, args.amount]
+    }), Effect.map(data => Domain.PreparedRequest.PreparedEvm({
+      ...data,
+      contractAddress: Domain.Erc20Address(zAssetAddress),
+      universalChainId: args.destinationChainId,
+      kind: "ZAsset.Transfer"
+    })))], {
+      concurrency: "unbounded"
+    });
+    yield* Effect.log("[deposit]", {
+      approval,
+      deposit,
+      transfer
+    });
+    return [approval, deposit, transfer];
+  });
+  const prepareRedemption = Effect.fn("prepareRedemption")(function* (args) {
+    const zAssetAddress = yield* (0, _Function.pipe)(ZAssetRegistry.getZAsset(args.universalChainId, args.dstErc20Address), Effect.mapError(cause => new Error.SystemError({
+      method: "prepareRedemption",
+      module: "EvmWalletClient",
+      reason: "InvalidData",
+      cause
+    })));
+    return yield* (0, _Function.pipe)(validateFunctionData({
+      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.map(data => Domain.PreparedRequest.PreparedEvm({
+      ...data,
+      contractAddress: Domain.Erc20Address(zAssetAddress),
+      universalChainId: args.universalChainId,
+      kind: "ZAsset.Transfer"
+    })));
+  });
+  return Object.assign(yield* Client.make({
+    sign: sign,
+    submit,
+    approveZAssetToSpendErc20,
+    updateLoopbackClient,
+    depositUnderlyingZAsset,
+    transferZAsset,
+    prepareDeposit,
+    prepareRedemption,
+    signAndSubmit
+  }), {
+    [TypeId]: TypeId,
+    signTransaction,
+    sendRawTransaction,
+    writeContract,
+    prepareBatchTransactionRequest
+  });
+});
+/** @internal */
+exports.makeViem = makeViem;
+const makeBrowser = exports.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* (0, _Function.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* (0, _Function.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 yield* makeViem(wallet);
+});
+// import type * as ThirdwebAdaptersViem from "thirdweb/adapters/viem"
+// 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)
+// })
 //# sourceMappingURL=evmWalletClient.js.map