@unionlabs/payments 0.1.0 → 0.2.0

package/src/EvmWalletClient.ts

@@ -0,0 +1,1034 @@
+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 type * as P from "effect/Predicate";
+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 type { Hex } from "viem";
+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: TypeId = "@unionlabs/payments/EvmWalletClient";
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export type TypeId = "@unionlabs/payments/EvmWalletClient";
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface EvmWalletClient extends Client.WalletClient {
+  readonly [TypeId]: TypeId;
+  readonly prepareBatchTransactionRequest: (
+    calls: Array<{
+      to: `0x${string}`;
+      data: `0x${string}`;
+      value?: bigint;
+    }>,
+  ) => Effect.Effect<Array<any>, Error.SdkError, never>;
+}
+
+/**
+ * @category tags
+ * @since 1.0.0
+ */
+export const EvmWalletClient = Context.GenericTag<EvmWalletClient>(
+  "@unionlabs/payments/EvmWalletClient",
+);
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+export type EvmWalletClientConfig = {};
+
+/**
+ * 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 = <
+  transport extends Viem.Transport = Viem.Transport,
+  chain extends Viem.Chain | undefined = Viem.Chain | undefined,
+  account extends Viem.Account | undefined = Viem.Account | undefined,
+  rpcSchema extends Viem.RpcSchema | undefined = undefined,
+>(
+  wallet: Viem.WalletClient<transport, chain, account, rpcSchema>,
+): Effect.Effect<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((x) => EvmPublicClient.makeViem(x as unknown as any)),
+    );
+
+    // 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: Viem.EncodeFunctionDataParameters) =>
+        Effect.try({
+          try: () => Viem.encodeFunctionData(parameters),
+          catch: (cause) =>
+            new Error.SystemError({
+              reason: "InvalidData",
+              method: "encodeFunctionData",
+              module: "EvmWalletClient",
+              cause,
+            }),
+        }),
+    );
+
+    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.viemWriteContract({
+              hash: Brand.nominal<Domain.TxHash>()(hash),
+            }),
+          ),
+        ),
+    );
+
+    const prepareTransactionRequest = Effect.fn("prepareTransactionRequest")(
+      (params: Viem.PrepareTransactionRequestParameters<chain, account>) =>
+        pipe(
+          Ref.get(transactionCount),
+          Effect.flatMap((nonce) =>
+            Effect.tryPromise({
+              try: () =>
+                wallet.prepareTransactionRequest({
+                  ...params,
+                  nonce,
+                } as unknown as any),
+              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: Array<{
+          to: `0x${string}`;
+          data: `0x${string}`;
+          value?: bigint;
+        }>,
+      ) =>
+        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: 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<any> = [];
+          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,
+                } as unknown as any),
+              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<chain, account>) =>
+        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")((request: Domain.PreparedRequest) =>
+      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 as unknown as any }),
+        ),
+      ),
+    );
+
+    const submit = Effect.fn("submit")((request: Domain.SignedRequest) =>
+      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<Domain.TxHash>()(hash),
+          }),
+        ),
+      ),
+    );
+
+    const signAndSubmit = Effect.fn("signAndSubmit")(
+      (request: Domain.PreparedRequest) =>
+        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!,
+                } as unknown as any),
+              catch: (cause) =>
+                new Error.SystemError({
+                  method: "signAndSubmit",
+                  module: "EvmWalletClient",
+                  reason: "InvalidData",
+                  cause,
+                }),
+            }),
+          ),
+          Effect.map((hash) =>
+            Domain.SubmissionResult.viemWriteContract({
+              hash: Brand.nominal<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) =>
+            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 as unknown as any,
+              kind: "approval",
+            }),
+          ),
+        );
+      },
+    );
+
+    // TODO: check if required
+    const updateLoopbackClient = Effect.fn("updateLoopbackClient")(function* ({
+      clientId,
+      height,
+      ibcHandlerAddress,
+    }: 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): Hex => {
+        if (
+          value === undefined ||
+          value === null ||
+          value === 0n ||
+          value === 0
+        ) {
+          return "0x" as Hex;
+        }
+        let hex =
+          typeof value === "bigint" ? value.toString(16) : value.toString(16);
+        if (hex.length % 2 !== 0) {
+          hex = "0" + hex;
+        }
+        return `0x${hex}` as Hex;
+      };
+
+      // Build header fields in order (pre-merge + post-merge fields)
+      const headerFields: (Hex | Hex[])[] = [
+        block.parentHash,
+        block.sha3Uncles,
+        block.miner,
+        block.stateRoot,
+        block.transactionsRoot,
+        block.receiptsRoot,
+        block.logsBloom ?? (("0x" + "00".repeat(256)) as Hex),
+        toRlpHex(block.difficulty),
+        toRlpHex(block.number),
+        toRlpHex(block.gasLimit),
+        toRlpHex(block.gasUsed),
+        toRlpHex(block.timestamp),
+        block.extraData,
+        block.mixHash ??
+          ("0x0000000000000000000000000000000000000000000000000000000000000000" as Hex),
+        block.nonce ?? ("0x0000000000000000" as 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 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* 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 as unknown as any,
+            kind: "transfer",
+          }),
+        ),
+      );
+    });
+
+    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(
+          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 as unknown as any,
+              kind: "deposit",
+            }),
+          ),
+        );
+      },
+    );
+
+    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(
+        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 as unknown as any,
+            kind: "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 [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],
+          }),
+        ] as const,
+        { 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 <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(
+        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 as unknown as any,
+            kind: "approval",
+          }),
+        ),
+      );
+    });
+
+    return Object.assign(
+      yield* Client.make({
+        sign,
+        submit,
+        approveZAssetToSpendErc20,
+        updateLoopbackClient,
+        depositUnderlyingZAsset,
+        transferZAsset,
+        prepareDeposit,
+        prepareRedemption,
+        signAndSubmit,
+      }),
+      {
+        [TypeId]: TypeId as TypeId,
+        signTransaction,
+        sendRawTransaction,
+        writeContract,
+        prepareBatchTransactionRequest,
+      },
+    );
+  });
+
+/**
+ * @category layers
+ * @since 1.0.0
+ */
+export const layerFromViem = (
+  config: Viem.WalletClient,
+): Layer.Layer<EvmWalletClient | Client.WalletClient, Error.SdkError> =>
+  Layer.scopedContext(
+    Effect.map(makeViem(config), (client) =>
+      Context.make(EvmWalletClient, client).pipe(
+        Context.add(Client.WalletClient, client),
+      ),
+    ),
+  );
+
+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 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: {
+  providerPredicate: P.Predicate<Mipd.EIP6963ProviderDetail>;
+  accountPredicate: P.Predicate<`0x${string}`>;
+}): Layer.Layer<EvmWalletClient | Client.WalletClient, Error.SdkError> =>
+  Layer.unwrapScoped(makeBrowser(options));