@unionlabs/payments 0.2.1 → 0.3.0

package/dist/cjs/EvmWalletClient.js

@@ -3,668 +3,33 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.makeViem = exports.layerFromViem = exports.layerFromBrowser = exports.TypeId = exports.EvmWalletClient = void 0;
-var A = _interopRequireWildcard(require("effect/Array"));
-var Brand = _interopRequireWildcard(require("effect/Brand"));
+exports.layerFromViem = exports.layerFromBrowser = exports.TypeId = exports.EvmWalletClient = void 0;
 var Context = _interopRequireWildcard(require("effect/Context"));
 var Effect = _interopRequireWildcard(require("effect/Effect"));
-var _Function = require("effect/Function");
 var Layer = _interopRequireWildcard(require("effect/Layer"));
-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 EvmPublicClient = _interopRequireWildcard(require("./EvmPublicClient.js"));
+var internal = _interopRequireWildcard(require("./internal/evmWalletClient.js"));
 var Client = _interopRequireWildcard(require("./WalletClient.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); }
-// import type * as ThirdwebAdaptersViem from "thirdweb/adapters/viem"
-
 /**
+ * @since 0.0.0
  * @category type ids
- * @since 1.0.0
  */
-const TypeId = exports.TypeId = "@unionlabs/payments/EvmWalletClient";
+const TypeId = exports.TypeId = internal.TypeId;
 /**
  * @category tags
  * @since 1.0.0
  */
 const EvmWalletClient = exports.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
- */
-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(x => EvmPublicClient.makeViem(x)));
-  // 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")(
-  //<
-  // 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 => (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.viemWriteContract({
-    hash: Brand.nominal()(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")(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 => (0, _Function.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 => (0, _Function.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 => (0, _Function.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* (0, _Function.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* (0, _Function.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* (0, _Function.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* (0, _Function.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* (0, _Function.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
  */
-exports.makeViem = makeViem;
-const layerFromViem = config => Layer.scopedContext(Effect.map(makeViem(config), client => Context.make(EvmWalletClient, client).pipe(Context.add(Client.WalletClient, client))));
-exports.layerFromViem = layerFromViem;
-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* (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 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)
-// })
+const layerFromViem = config => Layer.scopedContext(Effect.map(internal.makeViem(config), client => Context.make(EvmWalletClient, client).pipe(Context.add(Client.WalletClient, client))));
 /**
  * @category layers
  * @since 1.0.0
  */
-const layerFromBrowser = options => Layer.unwrapScoped(makeBrowser(options));
+exports.layerFromViem = layerFromViem;
+const layerFromBrowser = options => Layer.scopedContext(Effect.map(internal.makeBrowser(options), client => Context.make(EvmWalletClient, client).pipe(Context.add(Client.WalletClient, client))));
 exports.layerFromBrowser = layerFromBrowser;
 //# sourceMappingURL=EvmWalletClient.js.map