@unionlabs/payments 0.2.1 → 0.3.1

package/src/WalletClient.ts

@@ -66,8 +66,8 @@ export interface WalletClient {
   ) => Effect.Effect<Domain.PreparedRequest, SdkError, never>;
 
   readonly sign: (
-    request: Domain.PreparedRequest,
-  ) => Effect.Effect<Domain.SignedRequest, SdkError, never>;
+    request: ReadonlyArray<Domain.PreparedRequest> | Domain.PreparedRequest,
+  ) => Effect.Effect<Domain.SignedRequest[], SdkError, never>;
 
   // TODO: can be done by public client (?)
   readonly submit: (
@@ -94,7 +94,7 @@ export class SourceWalletClient extends Context.Tag("SourceWalletClient")<
   SourceWalletClient,
   WalletClient
 >() {
-  static layer = <E, R>(layer: Layer.Layer<WalletClient, E, R>) =>
+  static project = <E, R>(layer: Layer.Layer<WalletClient, E, R>) =>
     Layer.project(layer, WalletClient, SourceWalletClient, identity);
 }
 
@@ -105,7 +105,7 @@ export class SourceWalletClient extends Context.Tag("SourceWalletClient")<
 export class DestinationWalletClient extends Context.Tag(
   "DestinationWalletClient",
 )<DestinationWalletClient, WalletClient>() {
-  static layer = <E, R>(layer: Layer.Layer<WalletClient, E, R>) =>
+  static project = <E, R>(layer: Layer.Layer<WalletClient, E, R>) =>
     Layer.project(layer, WalletClient, DestinationWalletClient, identity);
 }
 
@@ -131,37 +131,41 @@ export namespace WalletClient {
   }
 
   export interface ApproveZAssetToSpendErc20 {
+    universalChainId: Domain.UniversalChainId;
     srcErc20Address: Domain.Erc20Address;
     amount: bigint;
   }
 
   export interface UpdateLoopbackClient {
+    universalChainId: Domain.UniversalChainId;
     clientId: number;
     height: bigint;
-    ibcHandlerAddress: Domain.IbcHandlerAddress;
+    ibcHandlerAddress: Domain.IbcCoreAddress;
   }
 
   export interface DepositUnderlyingZAsset {
+    universalChainId: Domain.UniversalChainId;
     srcErc20Address: Domain.Erc20Address;
     amount: bigint;
   }
 
   export interface TransferZAsset {
+    universalChainId: Domain.UniversalChainId;
     srcErc20Address: Domain.Erc20Address;
     depositAddress: `0x${string}`;
     amount: bigint;
   }
 
   export type Deposit = {
+    destinationChainId: Domain.UniversalChainId;
     srcErc20Address: Domain.Erc20Address;
-    sourceChainId: bigint;
     readonly beneficiaries: ReadonlyArray<Address>;
     depositAddress: Domain.ZAssetAddress;
-    destinationChainId: bigint;
     amount: bigint;
   };
 
   export type Redeem = {
+    universalChainId: Domain.UniversalChainId;
     dstErc20Address: Domain.Erc20Address;
     unwrap?: boolean | undefined;
   } & RedeemParams;

package/src/constants/ibc-core-registry.ts

@@ -1,25 +1,25 @@
-import { type Brand, Effect, flow, Option } from "effect";
+import { Effect, flow, Option } from "effect";
 import * as Domain from "../Domain.js";
 import * as Error from "../Error.js";
 
-export type ZAssetAddress = `0x${string}` & Brand.Brand<"ZAssetAddress">;
-
 export const IBC_CORE_REGISTRY: {
-  [chainId: string]: Domain.IbcHandlerAddress;
+  [chainId: Domain.UniversalChainId]: Domain.IbcCoreAddress;
 } = {
-  "8453": Domain.IbcHandlerAddress(
+  [Domain.UniversalChainId.make("base.8453")]: Domain.IbcCoreAddress(
+    "0xee4ea8d358473f0fcebf0329feed95d56e8c04d7",
+  ),
+  [Domain.UniversalChainId.make("ethereum.1")]: Domain.IbcCoreAddress(
     "0xee4ea8d358473f0fcebf0329feed95d56e8c04d7",
   ),
 } as const;
 
-export function getIbcHandler(
-  chainId: bigint,
-): Option.Option<Domain.IbcHandlerAddress> {
-  return Option.fromNullable(IBC_CORE_REGISTRY[`${chainId}`]);
-}
+export const getIbcCoreAddress = (
+  ucid: Domain.UniversalChainId,
+): Option.Option<Domain.IbcCoreAddress> =>
+  Option.fromNullable(IBC_CORE_REGISTRY[ucid]);
 
-export const getIbcHandlerOrError = flow(
-  getIbcHandler,
+export const getIbcCoreAddressOrError = flow(
+  getIbcCoreAddress,
   Effect.mapError(
     (cause) =>
       new Error.SystemError({
@@ -31,8 +31,8 @@ export const getIbcHandlerOrError = flow(
   ),
 );
 
-export const getIbcHandlerOrThrow = flow(
-  getIbcHandler,
+export const getIbcCoreAddressOrThrow = flow(
+  getIbcCoreAddress,
   Option.getOrThrowWith(
     () =>
       new Error.SystemError({

package/src/constants/z-asset-registry.ts

@@ -4,22 +4,25 @@ import * as Domain from "../Domain.js";
 import * as Error from "../Error.js";
 
 export const Z_ASSET_REGISTRY: {
-  [chainId: string]: {
+  [chainId: Domain.UniversalChainId]: {
     [assetAddress: Erc20Address]: Domain.ZAssetAddress;
   };
 } = {
-  "8453": {
+  [Domain.UniversalChainId.make("base.8453")]: {
     [Domain.Erc20Address("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913")]:
       Domain.ZAssetAddress("0xF0000101561619d8A61ABd045F47Af4f41Afe62D"),
   },
+  [Domain.UniversalChainId.make("ethereum.1")]: {
+    [Domain.Erc20Address("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48")]: // USDC on ethereum.1
+      Domain.ZAssetAddress("0xF0000101561619d8A61ABd045F47Af4f41Afe62D"),
+  },
 } as const;
 
-export function getZAsset(
-  chainId: bigint,
+export const getZAsset = (
+  universalChainId: Domain.UniversalChainId,
   assetAddress: Erc20Address,
-): Option.Option<Domain.ZAssetAddress> {
-  return Option.fromNullable(Z_ASSET_REGISTRY[`${chainId}`]?.[assetAddress]);
-}
+): Option.Option<Domain.ZAssetAddress> =>
+  Option.fromNullable(Z_ASSET_REGISTRY?.[universalChainId]?.[assetAddress]);
 
 export const getZAssetOrError = flow(
   getZAsset,

package/src/internal/evmPublicClient.ts

@@ -0,0 +1,459 @@
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as S from "effect/Schema";
+import type * as Viem from "viem";
+import { bytesToHex, hexToBytes } 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 type * as EvmPublicClient from "../EvmPublicClient.js";
+import * as Client from "../PublicClient.js";
+import * as PS from "../Schema.js";
+
+/** @internal */
+export const TypeId: EvmPublicClient.TypeId = Symbol.for(
+  "@unionlabs/payments/EvmPublicClient",
+) as EvmPublicClient.TypeId;
+
+export const makeViem = (
+  client: Viem.PublicClient,
+): Effect.Effect<EvmPublicClient.EvmPublicClient, Error.SdkError, never> =>
+  Effect.gen(function* () {
+    // const Viem = yield* Effect.tryPromise({
+    //   try: () => import("viem").then((x) => x.default),
+    //   catch: (cause) =>
+    //     new Error.SystemError({
+    //       reason: "DynamicImport",
+    //       method: "makeViem",
+    //       module: "EvmPublicClient",
+    //       cause,
+    //       description: "could not import viem",
+    //     }),
+    // });
+
+    const readContract = Effect.fn("readContract")(
+      <
+        TAbi extends Viem.Abi,
+        A,
+        I,
+        R = never,
+        TFunctionName extends Viem.ContractFunctionName<
+          TAbi,
+          "pure" | "view"
+        > = Viem.ContractFunctionName<TAbi, "pure" | "view">,
+        TArgs extends Viem.ContractFunctionArgs<
+          TAbi,
+          "pure" | "view",
+          TFunctionName
+        > = Viem.ContractFunctionArgs<TAbi, "pure" | "view", TFunctionName>,
+      >(
+        params: Viem.ReadContractParameters<TAbi, TFunctionName, TArgs>,
+        schema: S.Schema<A, I, R>,
+      ): Effect.Effect<A, Error.SdkError, R> =>
+        pipe(
+          Effect.tryPromise({
+            try: () => client.readContract(params),
+            catch: (cause) =>
+              new Error.SystemError({
+                method: "readContract",
+                module: "EvmPublicClient",
+                reason: "ReadContract",
+                cause,
+              }),
+          }),
+          Effect.flatMap(S.decodeUnknown(schema)),
+          Effect.catchTag(
+            "ParseError",
+            (cause) =>
+              new Error.SystemError({
+                method: "readContract",
+                module: "EvmPublicClient",
+                reason: "InvalidData",
+                cause,
+              }),
+          ),
+        ),
+    );
+
+    const getLatestHeight = Effect.fn("getLatestHeight")(
+      (lightClientAddress: Domain.LightClientAddress, clientId: number) =>
+        readContract(
+          {
+            address: lightClientAddress,
+            abi: Abi.LIGHT_CLIENT_ABI,
+            functionName: "getLatestHeight",
+            args: [clientId],
+          },
+          S.BigIntFromSelf,
+        ),
+    );
+
+    const getLightClientAddress = Effect.fn("getLightClientAddress")(function* (
+      ibcStoreAddress: Domain.IbcCoreAddress,
+      clientId: number,
+    ) {
+      const res = yield* readContract(
+        {
+          address: ibcStoreAddress,
+          abi: Abi.IBC_STORE_ABI,
+          functionName: "getClient",
+          args: [clientId],
+        },
+        PS.Hex,
+      );
+
+      return Domain.LightClientAddress(res);
+    });
+
+    const getStateRootIndex = Effect.fn("getStateRootIndex")(
+      (zAssetAddress: Domain.ZAssetAddress, clientId: number) =>
+        readContract(
+          {
+            address: zAssetAddress,
+            abi: Abi.ZASSET_ABI,
+            functionName: "stateRootIndex",
+            args: [clientId],
+          },
+          S.BigIntFromSelf,
+        ),
+    );
+
+    const getConsensusState = Effect.fn("getConsensusState")(
+      (
+        lightClientAddress: Domain.LightClientAddress,
+        clientId: number,
+        height: bigint,
+        stateRootIndex: bigint,
+      ) =>
+        pipe(
+          readContract(
+            {
+              address: lightClientAddress,
+              abi: Abi.LIGHT_CLIENT_ABI,
+              functionName: "getConsensusState",
+              args: [clientId, height],
+            },
+            PS.Hex,
+          ),
+          // XXX: this can definitely fail
+          Effect.map((consensusBytes) => {
+            const bytes: Uint8Array = hexToBytes(consensusBytes);
+            const idx = Number(stateRootIndex);
+            const stateRoot = bytesToHex(bytes.slice(idx, idx + 32));
+            return { stateRoot } as const;
+          }),
+        ),
+    );
+
+    const getIbcHandlerAddress = Effect.fn("getIbcHandlerAddress")(function* (
+      zAssetAddress: Domain.ZAssetAddress,
+    ) {
+      return Domain.IbcCoreAddress(
+        yield* readContract(
+          {
+            address: zAssetAddress,
+            abi: Abi.ZASSET_ABI,
+            functionName: "ibcHandler",
+          },
+          PS.Hex,
+        ),
+      );
+    });
+
+    const readZAssetTokenBalance = Effect.fn("readZAssetTokenBalance")(
+      (
+        tokenAddress: Domain.ZAssetAddress,
+        accountAddress: `0x${string}`,
+        blockNumber?: bigint,
+      ) =>
+        readContract(
+          {
+            address: tokenAddress,
+            abi: [
+              {
+                inputs: [{ name: "account", type: "address" }],
+                name: "balanceOf",
+                outputs: [{ name: "", type: "uint256" }],
+                stateMutability: "view",
+                type: "function",
+              },
+            ] as const,
+            functionName: "balanceOf",
+            args: [accountAddress],
+            blockNumber,
+          },
+          S.BigIntFromSelf,
+        ),
+    );
+
+    const readNullifierBalance = Effect.fn("readNullifierBalance")(
+      (zAssetAddress: Domain.ZAssetAddress, nullifier: bigint) =>
+        readContract(
+          {
+            address: zAssetAddress,
+            abi: Abi.ZASSET_ABI,
+            functionName: "nullifierBalance",
+            args: [nullifier],
+          },
+          S.BigIntFromSelf,
+        ),
+    );
+
+    const getLatestBlockNumber = Effect.tryPromise({
+      try: () => client.getBlockNumber(),
+      catch: (cause) =>
+        new Error.SystemError({
+          method: "getLatestBlockNumber",
+          module: "EvmPublicClient",
+          reason: "InvalidData",
+          cause,
+        }),
+    });
+
+    const readBalanceAtHeight = Effect.fn("readBalanceAtHeight")(
+      (
+        opts: Client.PublicClient.ReadBalanceAtHeightOptions,
+      ): Effect.Effect<
+        Client.PublicClient.BalanceAtHeightInfo,
+        Error.SdkError
+      > =>
+        Effect.gen(function* () {
+          const latestHeight = yield* getLatestBlockNumber;
+
+          const srcZAssetAddress = yield* ZAssetRegistry.getZAsset(
+            opts.srcChainId,
+            opts.srcErc20Address,
+          ).pipe(
+            Effect.mapError(
+              (cause) =>
+                new Error.SystemError({
+                  method: "readBalanceAtHeight",
+                  module: "EvmPublicClient",
+                  reason: "InvalidData",
+                  cause,
+                }),
+            ),
+          );
+
+          const dstZAssetAddress = yield* ZAssetRegistry.getZAsset(
+            opts.dstChainId,
+            opts.dstErc20Address,
+          ).pipe(
+            Effect.mapError(
+              (cause) =>
+                new Error.SystemError({
+                  method: "readBalanceAtHeight",
+                  module: "EvmPublicClient",
+                  reason: "InvalidData",
+                  cause,
+                }),
+            ),
+          );
+
+          const [balanceAtTip, confirmed, redeemed] = yield* Effect.all(
+            [
+              // ZAsset balance of the deposit address ZAsset on the source chain at the tip of the chain
+              readZAssetTokenBalance(
+                srcZAssetAddress,
+                opts.depositAddress,
+                latestHeight,
+              ),
+              // ZAsset balance of the deposit address on the source chain at the (latest) light client height
+              readZAssetTokenBalance(
+                srcZAssetAddress,
+                opts.depositAddress,
+                opts.height,
+              ),
+              // amount that has already been redeemed under the specified nullifier
+              readNullifierBalance(dstZAssetAddress, opts.nullifier),
+            ],
+            { concurrency: "unbounded" },
+          );
+
+          const available = confirmed > redeemed ? confirmed - redeemed : 0n;
+          const pending =
+            balanceAtTip > confirmed ? balanceAtTip - confirmed : 0n;
+
+          return { confirmed, redeemed, available, pending, latestHeight };
+        }),
+    );
+
+    const readBalance = Effect.fn("readBalance")(
+      (
+        opts: Client.PublicClient.ReadBalanceOptions,
+      ): Effect.Effect<Client.PublicClient.BalanceInfo, Error.SdkError> =>
+        Effect.gen(function* () {
+          const dstZAssetAddress = yield* ZAssetRegistry.getZAsset(
+            opts.dstChainId,
+            opts.dstErc20Address,
+          ).pipe(
+            Effect.mapError(
+              (cause) =>
+                new Error.SystemError({
+                  method: "readBalance",
+                  module: "EvmPublicClient",
+                  reason: "InvalidData",
+                  cause,
+                }),
+            ),
+          );
+
+          yield* Effect.log({ opts, dstZAssetAddress });
+
+          const ibcHandlerAddress =
+            yield* getIbcHandlerAddress(dstZAssetAddress);
+
+          const lightClientAddress = yield* getLightClientAddress(
+            ibcHandlerAddress,
+            opts.clientId,
+          );
+          const lightClientHeight = yield* getLatestHeight(
+            lightClientAddress,
+            opts.clientId,
+          );
+
+          const balance = yield* readBalanceAtHeight({
+            srcErc20Address: opts.srcErc20Address,
+            srcChainId: opts.srcChainId,
+            dstErc20Address: opts.dstErc20Address,
+            dstChainId: opts.dstChainId,
+            depositAddress: opts.depositAddress,
+            nullifier: opts.nullifier,
+            height: lightClientHeight,
+          });
+
+          return { ...balance, lightClientHeight };
+        }),
+    );
+
+    const getCounterparty = Effect.fn("getCounterparty")(
+      (zAssetAddress: Domain.ZAssetAddress, clientId: number) =>
+        readContract(
+          {
+            address: zAssetAddress,
+            abi: Abi.ZASSET_ABI,
+            functionName: "counterparty",
+            args: [clientId],
+          },
+          Domain.CounterpartyInfo,
+        ),
+    );
+
+    const getProof = Effect.fn("getProof")(
+      (options: {
+        address: `0x${string}`;
+        storageKeys: `0x${string}`[];
+        blockNumber: bigint;
+      }) =>
+        Effect.tryPromise({
+          try: () => client.getProof(options),
+          catch: (cause) =>
+            new Error.SystemError({
+              method: "getProof",
+              module: "EvmPublicClient",
+              reason: "InvalidData",
+              cause,
+            }),
+        }),
+    );
+
+    const waitForTransactionReceipt = Effect.fn("waitForTransactionReceipt")(
+      (hash: Domain.TxHash) =>
+        pipe(
+          Effect.tryPromise({
+            try: () => client.waitForTransactionReceipt({ hash }),
+            catch: (cause) =>
+              new Error.SystemError({
+                method: "waitForTransactionReceipt",
+                module: "EvmPublicClient",
+                reason: "InvalidData",
+                cause,
+              }),
+          }),
+          Effect.flatMap((x) =>
+            x.status === "success"
+              ? Effect.succeed(x)
+              : Effect.fail(
+                  new Error.SystemError({
+                    method: "waitForTransactionReceipt",
+                    module: "EvmPublicClient",
+                    reason: "InvalidData",
+                    description: "contract reverted",
+                  }),
+                ),
+          ),
+        ),
+    );
+
+    const waitForBlock = Effect.fn("waitForBlock")(
+      (targetHeight: bigint): Effect.Effect<bigint, Error.SdkError> =>
+        pipe(
+          getLatestBlockNumber,
+          Effect.flatMap((initial) =>
+            Effect.iterate(initial, {
+              // one block extra to avoid loadbalancer issues
+              while: (height) => height <= targetHeight,
+              body: () =>
+                pipe(
+                  Effect.sleep(Duration.seconds(1)),
+                  Effect.andThen(getLatestBlockNumber),
+                ),
+            }),
+          ),
+        ),
+    );
+
+    const simulateCalls = Effect.fn("simulateCalls")(
+      (params: {
+        calls: Array<{
+          to: `0x${string}`;
+          data: `0x${string}`;
+          value?: bigint | undefined;
+        }>;
+        account?: `0x${string}` | undefined;
+      }) =>
+        Effect.tryPromise({
+          try: async () => {
+            const { simulateCalls } = await import("viem/actions");
+            return simulateCalls(client, {
+              calls: params.calls.map((call) => ({
+                to: call.to,
+                data: call.data,
+                value: call.value,
+              })),
+              account: params.account,
+            });
+          },
+          catch: (cause) =>
+            new Error.SystemError({
+              method: "simulateCalls",
+              module: "EvmPublicClient",
+              reason: "InvalidData",
+              cause,
+            }),
+        }),
+    );
+
+    return Object.assign(
+      yield* Client.make({
+        getLatestHeight,
+        getLatestBlockNumber,
+        readBalance,
+        readBalanceAtHeight,
+        getLightClientAddress,
+        getStateRootIndex,
+        getConsensusState,
+        getIbcHandlerAddress,
+        getCounterparty,
+        getProof,
+        waitForBlock,
+      }),
+      {
+        [TypeId]: TypeId as EvmPublicClient.TypeId,
+        waitForTransactionReceipt,
+        simulateCalls,
+      },
+    );
+  });