@unionlabs/payments 0.2.1 → 0.3.1

package/src/EvmPublicClient.ts

@@ -1,34 +1,23 @@
 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 type * as Domain from "./Domain.js";
+import type * as Error from "./Error.js";
+import * as internal from "./internal/evmPublicClient.js";
 import * as Client from "./PublicClient.js";
-import * as PS from "./Schema.js";
 
 /**
+ * @since 0.0.0
  * @category type ids
- * @since 1.0.0
  */
-export const TypeId: TypeId = "@unionlabs/payments/EvmPublicClient";
+export const TypeId: unique symbol = internal.TypeId;
 
 /**
+ * @since 0.0.0
  * @category type ids
- * @since 1.0.0
  */
-export type TypeId = "@unionlabs/payments/EvmPublicClient";
+export type TypeId = typeof TypeId;
 
 /**
  * @category models
@@ -38,7 +27,7 @@ export interface EvmPublicClient extends Client.PublicClient {
   readonly [TypeId]: TypeId;
 
   readonly waitForTransactionReceipt: (
-    hash: TxHash,
+    hash: Domain.TxHash,
   ) => Effect.Effect<Viem.TransactionReceipt, Error.SdkError, never>;
 
   readonly simulateCalls: (params: {
@@ -65,474 +54,6 @@ export const EvmPublicClient = Context.GenericTag<EvmPublicClient>(
  */
 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
@@ -541,7 +62,7 @@ export const layerFromViem = (
   config: Viem.PublicClient,
 ): Layer.Layer<EvmPublicClient | Client.PublicClient, Error.SdkError> =>
   Layer.scopedContext(
-    Effect.map(makeViem(config), (client) =>
+    Effect.map(internal.makeViem(config), (client) =>
       Context.make(EvmPublicClient, client).pipe(
         Context.add(Client.PublicClient, client),
       ),