@unionlabs/payments 0.1.0 → 0.2.0

package/src/EvmPublicClient.ts

@@ -0,0 +1,549 @@
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+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 type {
+  IbcHandlerAddress,
+  LightClientAddress,
+  TxHash,
+} from "./Domain.js";
+import * as Domain from "./Domain.js";
+import * as Error from "./Error.js";
+import * as Client from "./PublicClient.js";
+import * as PS from "./Schema.js";
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export const TypeId: TypeId = "@unionlabs/payments/EvmPublicClient";
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export type TypeId = "@unionlabs/payments/EvmPublicClient";
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface EvmPublicClient extends Client.PublicClient {
+  readonly [TypeId]: TypeId;
+
+  readonly waitForTransactionReceipt: (
+    hash: TxHash,
+  ) => Effect.Effect<Viem.TransactionReceipt, Error.SdkError, never>;
+
+  readonly simulateCalls: (params: {
+    calls: Array<{
+      to: `0x${string}`;
+      data: `0x${string}`;
+      value?: bigint | undefined;
+    }>;
+    account?: `0x${string}`;
+  }) => Effect.Effect<any, Error.SdkError, never>;
+}
+
+/**
+ * @category tags
+ * @since 1.0.0
+ */
+export const EvmPublicClient = Context.GenericTag<EvmPublicClient>(
+  "@unionlabs/payments/EvmPublicClient",
+);
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+export type EvmPublicClientConfig = {};
+
+// /**
+//  * @category layers
+//  * @since 1.0.0
+//  */
+// export const layer = (
+//   config: PgClientConfig
+// ): Layer.Layer<PgClient | Client.SqlClient, SqlError> =>
+//   Layer.scopedContext(
+//     Effect.map(make(config), (client) =>
+//       Context.make(PgClient, client).pipe(
+//         Context.add(Client.SqlClient, client)
+//       ))
+//   ).pipe(Layer.provide(Reactivity.layer))
+
+/**
+ * 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 PublicClient 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 = (
+  client: Viem.PublicClient,
+): Effect.Effect<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: LightClientAddress, clientId: number) =>
+        readContract(
+          {
+            address: lightClientAddress,
+            abi: Abi.LIGHT_CLIENT_ABI,
+            functionName: "getLatestHeight",
+            args: [clientId],
+          },
+          S.BigIntFromSelf,
+        ),
+    );
+
+    const getLightClientAddress = Effect.fn("getLightClientAddress")(function* (
+      ibcStoreAddress: IbcHandlerAddress,
+      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: 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.IbcHandlerAddress(
+        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.fn("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: "EvmWalletClient",
+              reason: "InvalidData",
+              cause,
+            }),
+        }),
+    );
+
+    const waitForTransactionReceipt = Effect.fn("waitForTransactionReceipt")(
+      (hash: TxHash) =>
+        pipe(
+          Effect.tryPromise({
+            try: () => client.waitForTransactionReceipt({ hash }),
+            catch: (cause) =>
+              new Error.SystemError({
+                method: "waitForTransactionReceipt",
+                module: "EvmWalletClient",
+                reason: "InvalidData",
+                cause,
+              }),
+          }),
+          Effect.flatMap((x) =>
+            x.status === "success"
+              ? Effect.succeed(x)
+              : Effect.fail(
+                  new Error.SystemError({
+                    method: "waitForTransactionReceipt",
+                    module: "EvmWalletClient",
+                    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 TypeId,
+        waitForTransactionReceipt,
+        simulateCalls,
+      },
+    );
+  });
+
+/**
+ * @category layers
+ * @since 1.0.0
+ */
+export const layerFromViem = (
+  config: Viem.PublicClient,
+): Layer.Layer<EvmPublicClient | Client.PublicClient, Error.SdkError> =>
+  Layer.scopedContext(
+    Effect.map(makeViem(config), (client) =>
+      Context.make(EvmPublicClient, client).pipe(
+        Context.add(Client.PublicClient, client),
+      ),
+    ),
+  );