@unionlabs/payments 0.1.0 → 0.2.0

package/src/internal/evm.ts

@@ -0,0 +1,361 @@
+/**
+ * This module handles EVM related functionality.
+ *
+ * @since 0.0.0
+ */
+
+import type {} from "effect";
+import { Context, Data, Effect, flow, Layer, pipe } from "effect";
+import type {
+  Abi,
+  Address,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  CreatePublicClientErrorType,
+  CreateWalletClientErrorType,
+  Hash,
+  ReadContractErrorType,
+  ReadContractParameters,
+  SimulateContractErrorType,
+  Account as ViemAccount,
+  Chain as ViemChain,
+  PublicClient as ViemPublicClient,
+  WalletClient as ViemWalletClient,
+  WaitForTransactionReceiptTimeoutErrorType,
+  WriteContractErrorType,
+  WriteContractParameters,
+} from "viem";
+import * as V from "viem";
+
+/** @internal */
+export const publicClientLayer =
+  <Id>(tag: Context.Tag<Id, Evm.PublicClient>) =>
+  (
+    ...options: Parameters<typeof V.createPublicClient>
+  ): Layer.Layer<Id, CreatePublicClientError> =>
+    Layer.effect(
+      tag,
+      pipe(
+        Effect.try({
+          try: () => V.createPublicClient(...options),
+          catch: (err) =>
+            new CreatePublicClientError({
+              cause: err as V.CreatePublicClientErrorType,
+            }),
+        }),
+        Effect.map((client) => ({ client })),
+      ),
+    );
+
+/** @internal */
+export const walletClientLayer =
+  <Id>(tag: Context.Tag<Id, Evm.WalletClient>) =>
+  (
+    options: Parameters<typeof V.createWalletClient>[0] & {
+      account: V.Account;
+      chain: V.Chain;
+    },
+  ): Layer.Layer<Id, CreateWalletClientError> =>
+    Layer.effect(
+      tag,
+      pipe(
+        Effect.try({
+          try: () => V.createWalletClient(options),
+          catch: (err) =>
+            new CreateWalletClientError({
+              cause: err as V.CreateWalletClientErrorType,
+            }),
+        }),
+        Effect.map((client) => ({
+          client,
+          account: options.account,
+          chain: options.chain,
+        })),
+      ),
+    );
+
+/**
+ * @category models
+ * @since 0.0.0
+ */
+export namespace Evm {
+  /**
+   * @category models
+   * @since 0.0.0
+   */
+  export interface PublicClient {
+    readonly client: ViemPublicClient;
+  }
+
+  /**
+   * @category models
+   * @since 0.0.0
+   */
+  export interface WalletClient {
+    readonly client: ViemWalletClient;
+    readonly account: ViemAccount;
+    readonly chain: ViemChain;
+  }
+
+  /**
+   * @category models
+   * @since 0.0.0
+   */
+  export interface Channel {
+    readonly ucs03address: Address;
+    readonly channelId: number;
+  }
+}
+
+/**
+ * @category errors
+ * @since 0.0.0
+ */
+export class WaitForTransactionReceiptError extends Data.TaggedError(
+  "WaitForTransactionReceiptError",
+)<{
+  cause: WaitForTransactionReceiptTimeoutErrorType;
+}> {}
+
+/**
+ * Wait for a transaction receipt
+ * @param hash The transaction hash for which to wait
+ * @returns An Effect that resolves to the transaction receipt
+ *
+ * @category utils
+ * @since 0.0.0
+ */
+export const waitForTransactionReceipt = Effect.fn("waitForTransactionReceipt")(
+  (hash: Hash) =>
+    pipe(
+      PublicClient,
+      Effect.andThen(({ client }) =>
+        Effect.tryPromise({
+          try: () => client.waitForTransactionReceipt({ hash }),
+          catch: (err) =>
+            new WaitForTransactionReceiptError({
+              cause: err as WaitForTransactionReceiptTimeoutErrorType,
+            }),
+        }),
+      ),
+    ),
+);
+
+/**
+ * A type-safe wrapper around viem's readContract 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 call
+ * @param params - The parameters for the contract call
+ * @returns An Effect that resolves to the properly typed return value
+ *
+ * @category utils
+ * @since 0.0.0
+ */
+export const readContract = Effect.fn("readContract")(
+  <
+    TAbi extends Abi,
+    TFunctionName extends ContractFunctionName<
+      TAbi,
+      "pure" | "view"
+    > = ContractFunctionName<TAbi, "pure" | "view">,
+    TArgs extends ContractFunctionArgs<
+      TAbi,
+      "pure" | "view",
+      TFunctionName
+    > = ContractFunctionArgs<TAbi, "pure" | "view", TFunctionName>,
+  >(
+    params: ReadContractParameters<TAbi, TFunctionName, TArgs>,
+  ) =>
+    pipe(
+      PublicClient,
+      Effect.andThen(({ client }) =>
+        Effect.tryPromise({
+          try: () => client.readContract(params),
+          catch: (error) =>
+            new ReadContractError({
+              cause: error as ReadContractErrorType,
+            }),
+        }),
+      ),
+    ),
+);
+
+/**
+ * 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 writeContract = Effect.fn("writeContract")(
+  <
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, "payable" | "nonpayable">,
+    args extends ContractFunctionArgs<
+      abi,
+      "payable" | "nonpayable",
+      functionName
+    >,
+  >(
+    params: WriteContractParameters<abi, functionName, args>,
+  ) =>
+    pipe(
+      WalletClient,
+      Effect.andThen(({ client }) =>
+        Effect.tryPromise({
+          try: () => client.writeContract(params),
+          catch: (error) =>
+            new WriteContractError({
+              cause: error as WriteContractErrorType,
+            }),
+        }),
+      ),
+    ),
+);
+
+export const getBlockNumber = Effect.fn("writeContract")(
+  <
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, "payable" | "nonpayable">,
+    args extends ContractFunctionArgs<
+      abi,
+      "payable" | "nonpayable",
+      functionName
+    >,
+  >(
+    params: WriteContractParameters<abi, functionName, args>,
+  ) =>
+    pipe(
+      WalletClient,
+      Effect.andThen(({ client }) =>
+        Effect.tryPromise({
+          try: () => client.writeContract(params),
+          catch: (error) =>
+            new WriteContractError({
+              cause: error as WriteContractErrorType,
+            }),
+        }),
+      ),
+    ),
+);
+
+/**
+ * @category context
+ * @since 0.0.0
+ */
+export class ChannelDestination extends Context.Tag(
+  "@unionlabs/sdk/Evm/ChannelDestination",
+)<ChannelDestination, Evm.Channel>() {
+  static Live = flow(ChannelDestination.of, Layer.succeed(this));
+}
+
+/**
+ * @category context
+ * @since 0.0.0
+ */
+export class ChannelSource extends Context.Tag(
+  "@unionlabs/sdk/Evm/ChannelSource",
+)<ChannelSource, Evm.Channel>() {
+  static Live = flow(ChannelSource.of, Layer.succeed(this));
+}
+
+/**
+ * @category context
+ * @since 0.0.0
+ */
+
+export class PublicClientSource extends Context.Tag(
+  "@unionlabs/sdk/Evm/PublicClientSource",
+)<PublicClientSource, Evm.PublicClient>() {
+  static Live = publicClientLayer(this);
+}
+
+/**
+ * @category context
+ * @since 0.0.0
+ */
+export class PublicClientDestination extends Context.Tag(
+  "@unionlabs/sdk/Evm/PublicClientDestination",
+)<PublicClientDestination, Evm.PublicClient>() {
+  static Live = publicClientLayer(this);
+}
+
+/**
+ * A neutral public client that can be used for general-purpose operations
+ * that don't specifically target source or destination chains
+ *
+ * @category context
+ * @since 0.0.0
+ */
+export class PublicClient extends Context.Tag(
+  "@unionlabs/sdk-evm/Evm/PublicClient",
+)<PublicClient, Evm.PublicClient>() {
+  static Live = publicClientLayer(this);
+}
+
+/**
+ * A wallet client that can be used for signing transactions
+ *
+ * @category context
+ * @since 0.0.0
+ */
+export class WalletClient extends Context.Tag(
+  "@unionlabs/sdk/Evm/WalletClient",
+)<WalletClient, Evm.WalletClient>() {
+  static Live = walletClientLayer(this);
+}
+
+/**
+ * @category errors
+ * @since 0.0.0
+ */
+export class ReadContractError extends Data.TaggedError(
+  "@unionlabs/sdk/Evm/ReadContractError",
+)<{
+  cause: ReadContractErrorType;
+}> {}
+
+/**
+ * @category errors
+ * @since 0.0.0
+ */
+export class WriteContractError extends Data.TaggedError(
+  "@unionlabs/sdk/Evm/WriteContractError",
+)<{
+  cause: WriteContractErrorType;
+}> {}
+
+/**
+ * @category errors
+ * @since 0.0.0
+ */
+export class SimulateContractError extends Data.TaggedError(
+  "@unionlabs/sdk/Evm/SimulateContractError",
+)<{
+  cause: SimulateContractErrorType;
+}> {}
+
+/**
+ * @category errors
+ * @since 0.0.0
+ */
+export class CreatePublicClientError extends Data.TaggedError(
+  "@unionlabs/sdk/Evm/CreatePublicClientError",
+)<{
+  cause: CreatePublicClientErrorType;
+}> {}
+
+/**
+ * @category errors
+ * @since 0.0.0
+ */
+export class CreateWalletClientError extends Data.TaggedError(
+  "@unionlabs/sdk/Evm/CreateWalletClientError",
+)<{
+  cause: CreateWalletClientErrorType;
+}> {}

package/src/internal/publicClient.ts

@@ -0,0 +1,57 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as Client from "../PublicClient.js";
+
+/** @internal */
+export const TypeId: Client.TypeId = Symbol.for(
+  "@unionlabs/payments/PublicClient",
+) as Client.TypeId;
+
+/** @internal */
+export const clientTag = Context.GenericTag<Client.PublicClient>(
+  "@unionlabs/payments/PublicClient",
+);
+
+/** @internal */
+export function make({
+  getLatestHeight,
+  getLatestBlockNumber,
+  readBalance,
+  readBalanceAtHeight,
+  getLightClientAddress,
+  getStateRootIndex,
+  getConsensusState,
+  getIbcHandlerAddress,
+  getCounterparty,
+  getProof,
+  waitForBlock,
+}: Client.PublicClient.MakeOptions): Effect.Effect<
+  Client.PublicClient,
+  never,
+  never
+> {
+  return Effect.gen(function* () {
+    const client: Client.PublicClient = Object.assign(
+      {},
+      {
+        [TypeId as Client.TypeId]: TypeId as Client.TypeId,
+        safe: undefined as any,
+        getLatestHeight,
+        getLatestBlockNumber,
+        readBalance,
+        readBalanceAtHeight,
+        getLightClientAddress,
+        getStateRootIndex,
+        getConsensusState,
+        getIbcHandlerAddress,
+        getCounterparty,
+        getProof,
+        waitForBlock,
+      },
+    );
+
+    (client as any).safe = client;
+
+    return client;
+  });
+}

package/src/internal/walletClient.ts

@@ -0,0 +1,50 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as Client from "../WalletClient.js";
+
+/** @internal */
+export const TypeId: Client.TypeId = Symbol.for(
+  "@unionlabs/payments/WalletClient",
+) as Client.TypeId;
+
+/** @internal */
+export const clientTag = Context.GenericTag<Client.WalletClient>(
+  "@unionlabs/payments/WalletClient",
+);
+
+/** @internal */
+export function make({
+  sign,
+  submit,
+  approveZAssetToSpendErc20,
+  updateLoopbackClient,
+  depositUnderlyingZAsset,
+  transferZAsset,
+  prepareDeposit,
+  prepareRedemption,
+  signAndSubmit,
+}: Client.WalletClient.MakeOptions): Effect.Effect<
+  Client.WalletClient,
+  never,
+  never
+> {
+  return Effect.gen(function* () {
+    const client: Client.WalletClient = Object.assign(
+      {},
+      {
+        [TypeId as Client.TypeId]: TypeId as Client.TypeId,
+        sign,
+        submit,
+        approveZAssetToSpendErc20,
+        updateLoopbackClient,
+        depositUnderlyingZAsset,
+        transferZAsset,
+        prepareDeposit,
+        prepareRedemption,
+        signAndSubmit,
+      },
+    );
+
+    return client;
+  });
+}