@unionlabs/payments 0.2.1 → 0.3.0

package/src/internal/evmWalletClient.ts

@@ -0,0 +1,1063 @@
+import * as A from "effect/Array";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Number from "effect/Number";
+import * as O from "effect/Option";
+import type * as P from "effect/Predicate";
+import * as R from "effect/Record";
+import * as Ref from "effect/Ref";
+import type * as Scope from "effect/Scope";
+import type * as Mipd from "mipd";
+import type * as Viem from "viem";
+import * as ViemChains from "viem/chains";
+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 type * as EvmWalletClient from "../EvmWalletClient.js";
+import * as Client from "../WalletClient.js";
+import * as internalEvmPublicClient from "./evmPublicClient.js";
+
+const UniversalChainIdMap: Record<Domain.UniversalChainId, Viem.Chain> = {
+  [Domain.UniversalChainId.make("base.8453")]: ViemChains.base,
+};
+
+/** @internal */
+export const resolveUniversalChainId = (
+  ucid: Domain.UniversalChainId,
+): Effect.Effect<Viem.Chain, Error.SdkError, never> =>
+  pipe(
+    UniversalChainIdMap,
+    R.get(ucid),
+    O.match({
+      onNone: () =>
+        Effect.fail(
+          new Error.SystemError({
+            method: "resolveUniversalChainId",
+            module: "EvmWalletClient",
+            reason: "InvalidData",
+          }),
+        ),
+      onSome: Effect.succeed,
+    }),
+  );
+
+/** @internal */
+export const TypeId: EvmWalletClient.TypeId = Symbol.for(
+  "@unionlabs/payments/EvmWalletClient",
+) as EvmWalletClient.TypeId;
+
+/** @internal */
+export const makeViem = (
+  wallet: Viem.WalletClient,
+): Effect.Effect<
+  EvmWalletClient.EvmWalletClient,
+  Error.SdkError,
+  Scope.Scope
+> =>
+  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(internalEvmPublicClient.makeViem),
+    );
+
+    // 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")(
+      (parameters: Viem.EncodeFunctionDataParameters) =>
+        Effect.try({
+          try: () => Viem.encodeFunctionData(parameters),
+          catch: (cause) =>
+            new Error.SystemError({
+              reason: "InvalidData",
+              method: "encodeFunctionData",
+              module: "EvmWalletClient",
+              cause,
+            }),
+        }),
+    );
+
+    const validateFunctionData = Effect.fn("validateFunctionData")(
+      (parameters: Viem.EncodeFunctionDataParameters) =>
+        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!,
+              }) as const,
+          ),
+        ),
+    );
+
+    const writeContract = Effect.fn("writeContract")(
+      <
+        const abi extends Viem.Abi | readonly unknown[],
+        functionName extends Viem.ContractFunctionName<
+          abi,
+          "payable" | "nonpayable"
+        >,
+        args extends Viem.ContractFunctionArgs<
+          abi,
+          "payable" | "nonpayable",
+          functionName
+        >,
+      >(
+        params: Viem.WriteContractParameters<abi, functionName, args>,
+      ) =>
+        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: Viem.PrepareTransactionRequestParameters) =>
+        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: ReadonlyArray<Domain.PreparedRequest>) =>
+      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* pipe(
+          requests,
+          Effect.forEach((request) =>
+            pipe(
+              encodeFunctionData({
+                abi: request.abi,
+                args: request.args,
+                functionName: request.functionName,
+              }),
+              Effect.map(
+                (data) =>
+                  ({
+                    to: request.contractAddress,
+                    data,
+                    value: undefined,
+                  }) as const,
+              ),
+            ),
+          ),
+        );
+
+        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: Array<bigint | undefined> =
+          simulationResult.results?.map(
+            (r: { gasUsed?: bigint | number | string }) =>
+              r?.gasUsed ? (BigInt(r.gasUsed) * 120n) / 100n : undefined,
+          ) ?? [];
+
+        yield* Effect.log("[prepareBatchTransactionRequest] Gas estimates", {
+          gasEstimates,
+        });
+
+        // Prepare each transaction with gas
+        const prepared: Array<Viem.PrepareTransactionRequestReturnType> = [];
+        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: Viem.SignTransactionParameters<undefined, undefined>) =>
+        Effect.tryPromise({
+          try: () => wallet.signTransaction(params),
+          catch: (cause) =>
+            new Error.SystemError({
+              method: "signTransaction",
+              module: "EvmWalletClient",
+              reason: "InvalidData",
+              cause,
+            }),
+        }),
+    );
+
+    const sendRawTransaction = Effect.fn("sendRawTransaction")(
+      (params: Viem.SendRawTransactionParameters) =>
+        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: ReadonlyArray<Domain.PreparedRequest> | Domain.PreparedRequest,
+    ) {
+      // const chain = yield* resolveUniversalChainId(request.universalChainId);
+      const requests = yield* pipe(
+        request,
+        A.ensure,
+        Effect.forEach((n) =>
+          pipe(
+            n,
+            Effect.liftPredicate(
+              Domain.PreparedRequest.$is("PreparedEvm"),
+              (x) =>
+                new Error.SystemError({
+                  method: "sign",
+                  module: "EvmWalletClient",
+                  reason: "InvalidData",
+                }),
+            ),
+          ),
+        ),
+      );
+
+      return yield* 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: Domain.SignedRequest) =>
+      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: Domain.PreparedRequest,
+    ) {
+      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* 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: Client.WalletClient.ApproveZAssetToSpendErc20) {
+        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) =>
+            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,
+    }: Client.WalletClient.UpdateLoopbackClient) {
+      // 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: bigint | number | null | undefined,
+      ): Viem.Hex => {
+        if (
+          value === undefined ||
+          value === null ||
+          value === 0n ||
+          value === 0
+        ) {
+          return "0x" as Viem.Hex;
+        }
+        let hex =
+          typeof value === "bigint" ? value.toString(16) : value.toString(16);
+        if (hex.length % 2 !== 0) {
+          hex = "0" + hex;
+        }
+        return `0x${hex}` as Viem.Hex;
+      };
+
+      // Build header fields in order (pre-merge + post-merge fields)
+      const headerFields: (Viem.Hex | Viem.Hex[])[] = [
+        block.parentHash,
+        block.sha3Uncles,
+        block.miner,
+        block.stateRoot,
+        block.transactionsRoot,
+        block.receiptsRoot,
+        block.logsBloom ?? (("0x" + "00".repeat(256)) as Viem.Hex),
+        toRlpHex(block.difficulty),
+        toRlpHex(block.number),
+        toRlpHex(block.gasLimit),
+        toRlpHex(block.gasUsed),
+        toRlpHex(block.timestamp),
+        block.extraData,
+        block.mixHash ??
+          ("0x0000000000000000000000000000000000000000000000000000000000000000" as Viem.Hex),
+        block.nonce ?? ("0x0000000000000000" as Viem.Hex),
+      ];
+
+      // 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 as Record<string, unknown>;
+      if (blockAny.requestsHash) {
+        headerFields.push(blockAny.requestsHash as Viem.Hex);
+      }
+
+      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",
+        },
+      ] as const;
+
+      // 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* 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* 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: Client.WalletClient.DepositUnderlyingZAsset) {
+        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(
+          validateFunctionData({
+            abi: Abi.ZASSET_ABI,
+            functionName: "deposit",
+            args: [args.amount],
+          }),
+          // Effect.map((data) =>
+          //   prepareTransactionRequest({
+          //     to: zAssetAddr,
+          //     data,
+          //     chain: wallet.chain,
+          //   }),
+          // ),
+          Effect.map((data) =>
+            Domain.PreparedRequest.PreparedEvm({
+              ...data,
+              contractAddress: Domain.Erc20Address(zAssetAddr),
+              universalChainId: args.universalChainId,
+              kind: "Erc20.Wrap",
+            }),
+          ),
+        );
+      },
+    );
+
+    const transferZAsset = Effect.fn("transferZAsset")(function* (
+      args: Client.WalletClient.TransferZAsset,
+    ) {
+      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(
+        validateFunctionData({
+          abi: Abi.ZASSET_ABI,
+          functionName: "transfer",
+          args: [args.depositAddress, args.amount],
+        }),
+        // Effect.flatMap((data) =>
+        //   prepareTransactionRequest({
+        //     to: zAssetAddr,
+        //     data,
+        //     chain: wallet.chain,
+        //   }),
+        // ),
+        Effect.map((data) =>
+          Domain.PreparedRequest.PreparedEvm({
+            ...data,
+            contractAddress: Domain.Erc20Address(zAssetAddr),
+            universalChainId: args.universalChainId,
+            kind: "ZAsset.Transfer",
+          }),
+        ),
+      );
+    });
+
+    const prepareDeposit = Effect.fn("prepareDeposit")(function* (
+      args: Client.WalletClient.Deposit,
+    ) {
+      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 [approval, deposit, transfer] = yield* Effect.all(
+        [
+          pipe(
+            validateFunctionData({
+              abi: Abi.ERC20_ABI,
+              functionName: "approve",
+              args: [zAssetAddress, args.amount],
+            }),
+            Effect.map((data) =>
+              Domain.PreparedRequest.PreparedEvm({
+                ...data,
+                contractAddress: args.srcErc20Address,
+                universalChainId: args.universalChainId,
+                kind: "Erc20.Approve",
+              }),
+            ),
+          ),
+          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",
+              }),
+            ),
+          ),
+          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",
+              }),
+            ),
+          ),
+        ] as const,
+        { concurrency: "unbounded" },
+      );
+
+      yield* Effect.log("[deposit]", { approval, deposit, transfer });
+
+      return <Domain.PreparedRequests>[approval, deposit, transfer];
+    });
+
+    const prepareRedemption = Effect.fn("prepareRedemption")(function* (
+      args: Client.WalletClient.Redeem,
+    ) {
+      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(
+        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.flatMap((data) =>
+        //   prepareTransactionRequest({
+        //     to: zAssetAddr,
+        //     data,
+        //     chain: wallet.chain,
+        //   }),
+        // ),
+        Effect.map((data) =>
+          Domain.PreparedRequest.PreparedEvm({
+            ...data,
+            contractAddress: Domain.Erc20Address(zAssetAddr),
+            universalChainId: args.universalChainId,
+            kind: "ZAsset.Transfer",
+          }),
+        ),
+      );
+    });
+
+    return Object.assign(
+      yield* Client.make({
+        sign: sign,
+        submit,
+        approveZAssetToSpendErc20,
+        updateLoopbackClient,
+        depositUnderlyingZAsset,
+        transferZAsset,
+        prepareDeposit,
+        prepareRedemption,
+        signAndSubmit,
+      }),
+      {
+        [TypeId]: TypeId as EvmWalletClient.TypeId,
+        signTransaction,
+        sendRawTransaction,
+        writeContract,
+        prepareBatchTransactionRequest,
+      },
+    );
+  });
+
+/** @internal */
+export const makeBrowser = Effect.fn(function* (options: {
+  providerPredicate: P.Predicate<Mipd.EIP6963ProviderDetail>;
+  accountPredicate: P.Predicate<`0x${string}`>;
+}) {
+  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 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)
+// })