@unionlabs/payments 0.1.0 → 0.2.0

package/src/Prover.ts

@@ -0,0 +1,240 @@
+import { create } from "@bufbuild/protobuf";
+import { createClient } from "@connectrpc/connect";
+import { createGrpcWebTransport } from "@connectrpc/connect-web";
+import { Data, Effect, Match, pipe, Schedule } from "effect";
+import type * as P from "effect/Predicate";
+import * as S from "effect/Schema";
+import type { Address, Hex } from "viem";
+import { DEFAULT_PROVER_URL } from "./constants/services.js";
+import type * as Domain from "./Domain.js";
+import * as Error from "./Error.js";
+import * as GenProver from "./gen/prover_pb.js";
+import type { LightClientData, MptProofData } from "./types.js";
+
+const Options = S.Struct({
+  proverUrl: S.optionalWith(S.Union(S.URLFromSelf, S.URL), {
+    default: () => new globalThis.URL(DEFAULT_PROVER_URL),
+  }),
+});
+type Options = typeof Options.Type;
+
+/**
+ * Result from the prover server after proof generation.
+ * @public
+ */
+export interface ProofResult {
+  /** Whether proof generation succeeded */
+  success: boolean;
+  /** Serialized proof data (only present on success) */
+  proofJson?: Uint8Array;
+  /** Error message (only present on failure) */
+  error?: string;
+  /** Timestamp when the proof was created */
+  createdAt?: Date;
+}
+
+/**
+ * @public
+ */
+export interface WitnessData {
+  secret: Hex;
+  dstChainId: bigint;
+  beneficiaries: [Address, Address, Address, Address];
+  beneficiary: Address;
+  redeemAmount: bigint;
+  alreadyRedeemed: bigint;
+  lightClients: LightClientData[];
+  selectedClientIndex: number;
+  mptProof: MptProofData;
+  srcZAssetAddress: Domain.ZAssetAddress;
+  mappingSlot: Hex;
+}
+
+type PollResult = GenProver.PollResponse["result"];
+type PendingResult = Extract<PollResult, { case: "pending" }>;
+type DoneResult = Extract<PollResult, { case: "done" }>;
+type FailedResult = Extract<PollResult, { case: "failed" }>;
+
+export const isPending: P.Refinement<PollResult, PendingResult> = (
+  result,
+): result is PendingResult => result.case === "pending";
+
+export const isDone: P.Refinement<PollResult, DoneResult> = (
+  result,
+): result is DoneResult => result.case === "done";
+
+export const isFailed: P.Refinement<PollResult, FailedResult> = (
+  result,
+): result is FailedResult => result.case === "failed";
+
+class PollPending extends Data.TaggedError("PollPending")<{}> {}
+class PollFailed extends Data.TaggedError("PollFailed")<{ message: string }> {}
+
+export const Proof = S.Struct({
+  proof: S.Tuple(
+    S.String,
+    S.String,
+    S.String,
+    S.String,
+    S.String,
+    S.String,
+    S.String,
+    S.String,
+  ),
+  commitments: S.Tuple(S.String, S.String),
+  commitmentPok: S.Tuple(S.String, S.String),
+  publicInputs: S.Array(S.String),
+  // TODO: createdAt
+});
+export type Proof = typeof Proof.Type;
+
+export const ProofFromBytes = S.compose(
+  S.transform(S.Uint8ArrayFromSelf, S.String, {
+    decode: (bytes) => new globalThis.TextDecoder().decode(bytes),
+    encode: (text) => new globalThis.TextEncoder().encode(text),
+  }),
+  S.parseJson(Proof),
+);
+
+/**
+ * Prover client for communicating with the prover gRPC-web server
+ *
+ * Uses `@connectrpc/connect-web` to communicate with the gRPC-web server.
+ * @public
+ */
+export class Prover extends Effect.Service<Prover>()("Prover", {
+  scoped: Effect.fn(function* (options: S.Schema.Encoded<typeof Options>) {
+    const { proverUrl } = yield* pipe(
+      options,
+      S.decode(Options),
+      Effect.mapError(
+        (cause) =>
+          new Error.SystemError({
+            method: "Prover",
+            module: "Prover",
+            reason: "InvalidData",
+            cause,
+          }),
+      ),
+    );
+
+    const transport = createGrpcWebTransport({
+      baseUrl: proverUrl.toString(),
+    });
+
+    const client = createClient(GenProver.ProverService, transport);
+
+    const matchPollResult = Match.type<GenProver.PollResponse["result"]>().pipe(
+      Match.when({ case: "done" }, ({ value }) => Effect.succeed(value)),
+      Match.when({ case: "pending" }, () => Effect.fail(new PollPending())),
+      Match.when({ case: "failed" }, ({ value }) =>
+        Effect.fail(new PollFailed({ message: value.errorMessage })),
+      ),
+      Match.when({ case: undefined }, () =>
+        Effect.fail(new PollFailed({ message: "Unset result" })),
+      ),
+      Match.exhaustive,
+    );
+
+    const poll = Effect.fn("poll")(
+      (...[request, options]: Parameters<(typeof client)["poll"]>) =>
+        pipe(
+          Effect.tryPromise({
+            try: () => client.poll(request, options),
+            catch: (cause) =>
+              new Error.SystemError({
+                module: "Prover",
+                method: "poll",
+                reason: "InvalidData",
+                cause,
+              }),
+          }),
+          Effect.map((response) => response.result),
+          Effect.flatMap(matchPollResult),
+          Effect.retry({
+            while: (error) => error._tag === "PollPending",
+            schedule: Schedule.spaced("1 second"),
+          }),
+          Effect.flatMap((x) => S.decode(ProofFromBytes)(x.proofJson)),
+          Effect.catchTags({
+            ParseError: (cause) =>
+              new Error.SystemError({
+                method: "poll",
+                module: "Prover",
+                reason: "InvalidData",
+                cause,
+              }),
+            PollFailed: (cause) =>
+              new Error.SystemError({
+                method: "poll",
+                module: "Prover",
+                reason: "InvalidData",
+                cause,
+              }),
+            PollPending: (cause) =>
+              new Error.SystemError({
+                method: "poll",
+                module: "Prover",
+                reason: "InvalidData",
+                cause,
+              }),
+          }),
+        ),
+    );
+
+    const witnessToProto = (witness: WitnessData): GenProver.WitnessData =>
+      create(GenProver.WitnessDataSchema, {
+        secret: witness.secret,
+        dstChainId: witness.dstChainId,
+        beneficiaries: [...witness.beneficiaries],
+        beneficiary: witness.beneficiary,
+        redeemAmount: witness.redeemAmount.toString(),
+        alreadyRedeemed: witness.alreadyRedeemed.toString(),
+        lightClients: witness.lightClients.map((lc) =>
+          create(GenProver.LightClientDataSchema, {
+            clientId: lc.clientId,
+            height: lc.height,
+            stateRoot: lc.stateRoot,
+          }),
+        ),
+        selectedClientIndex: witness.selectedClientIndex,
+        mptProof: create(GenProver.MPTProofDataSchema, {
+          accountProof: [...witness.mptProof.accountProof],
+          storageProof: [...witness.mptProof.storageProof],
+          storageValue: witness.mptProof.storageValue,
+          storageRoot: witness.mptProof.storageRoot,
+        }),
+        tokenAddress: witness.srcZAssetAddress,
+        mappingSlot: witness.mappingSlot,
+      });
+
+    const generateProof = Effect.fn("generateProof")(function* (
+      witness: WitnessData,
+    ) {
+      const protoWitness = witnessToProto(witness);
+      const request = create(GenProver.ProofRequestSchema, {
+        witness: protoWitness,
+      });
+      return yield* poll(request);
+    });
+
+    const exportVerifier = pipe(
+      Effect.tryPromise({
+        try: () => client.exportVerifier({}),
+        catch: (cause) =>
+          new Error.SystemError({
+            module: "Prover",
+            method: "exportVerifier",
+            reason: "InvalidData",
+            cause,
+          }),
+      }),
+      Effect.map((response) => response.verifierContract),
+    );
+
+    return {
+      generateProof,
+      exportVerifier,
+    } as const;
+  }),
+}) {}

package/src/PublicClient.ts

@@ -0,0 +1,196 @@
+import { Layer } from "effect";
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import type { GetProofReturnType } from "viem";
+import type * as Domain from "./Domain.js";
+import type { SdkError } from "./Error.js";
+import * as internal from "./internal/publicClient.js";
+import type { ConsensusState, CounterpartyInfo } from "./types.js";
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export const TypeId: unique symbol = internal.TypeId;
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export type TypeId = typeof TypeId;
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface PublicClient {
+  readonly [TypeId]: TypeId;
+
+  /**
+   * Copy of the client for safeql etc.
+   */
+  readonly safe: this;
+
+  readonly getLatestHeight: (
+    lightClientAddress: Domain.LightClientAddress,
+    clientId: number,
+  ) => Effect.Effect<bigint, SdkError, never>;
+  readonly getLatestBlockNumber: () => Effect.Effect<bigint, SdkError>;
+
+  readonly readBalance: (
+    options: PublicClient.ReadBalanceOptions,
+  ) => Effect.Effect<PublicClient.BalanceInfo, SdkError>;
+  readonly readBalanceAtHeight: (
+    options: PublicClient.ReadBalanceAtHeightOptions,
+  ) => Effect.Effect<PublicClient.BalanceAtHeightInfo, SdkError>;
+  readonly getLightClientAddress: (
+    ibcStoreAddress: Domain.IbcHandlerAddress,
+    clientId: number,
+  ) => Effect.Effect<Domain.LightClientAddress, SdkError, never>;
+  readonly getStateRootIndex: (
+    zAssetAddress: Domain.ZAssetAddress,
+    clientId: number,
+  ) => Effect.Effect<bigint, SdkError, never>;
+  readonly getConsensusState: (
+    lightClientAddress: Domain.LightClientAddress,
+    clientId: number,
+    height: bigint,
+    satteRootIndex: bigint,
+  ) => Effect.Effect<ConsensusState, SdkError, never>;
+  readonly getIbcHandlerAddress: (
+    zAssetAddress: Domain.ZAssetAddress,
+  ) => Effect.Effect<Domain.IbcHandlerAddress, SdkError, never>;
+  readonly getCounterparty: (
+    zAssetAddress: Domain.ZAssetAddress,
+    clientId: number,
+  ) => Effect.Effect<CounterpartyInfo, SdkError, never>;
+  readonly getProof: (options: {
+    address: `0x${string}`;
+    storageKeys: `0x${string}`[];
+    blockNumber: bigint;
+  }) => Effect.Effect<GetProofReturnType, SdkError, never>;
+
+  readonly waitForBlock: (
+    targetHeight: bigint,
+  ) => Effect.Effect<bigint, SdkError, never>;
+}
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export const PublicClient: Context.Tag<PublicClient, PublicClient> =
+  internal.clientTag;
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export class SourcePublicClient extends Context.Tag("SourcePublicClient")<
+  SourcePublicClient,
+  PublicClient
+>() {
+  static layer = <E, R>(layer: Layer.Layer<PublicClient, E, R>) =>
+    Layer.project(layer, PublicClient, SourcePublicClient, identity);
+}
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export class DestinationPublicClient extends Context.Tag(
+  "DestinationPublicClient",
+)<DestinationPublicClient, PublicClient>() {
+  static layer = <E, R>(layer: Layer.Layer<PublicClient, E, R>) =>
+    Layer.project(layer, PublicClient, DestinationPublicClient, identity);
+}
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export namespace PublicClient {
+  /**
+   * Consensus state from a light client
+   * @category models
+   * @since 1.0.0
+   */
+  export interface ConsensusState {
+    readonly stateRoot: `0x${string}`;
+  }
+
+  /**
+   * Options for readBalance
+   * @category models
+   * @since 1.0.0
+   */
+  export interface ReadBalanceOptions {
+    readonly srcErc20Address: Domain.Erc20Address;
+    readonly srcChainId: bigint;
+    readonly dstErc20Address: Domain.Erc20Address;
+    readonly dstChainId: bigint;
+    readonly depositAddress: `0x${string}`;
+    readonly nullifier: bigint;
+    readonly clientId: number;
+  }
+
+  /**
+   * Options for readBalanceAtHeight
+   * @category models
+   * @since 1.0.0
+   */
+  export interface ReadBalanceAtHeightOptions {
+    readonly srcErc20Address: Domain.Erc20Address;
+    readonly dstErc20Address: Domain.Erc20Address;
+    readonly srcChainId: bigint;
+    readonly dstChainId: bigint;
+    readonly depositAddress: `0x${string}`;
+    readonly nullifier: bigint;
+    readonly height: bigint;
+  }
+
+  /**
+   * Balance information at a specific height
+   * @category models
+   * @since 1.0.0
+   */
+  export interface BalanceAtHeightInfo {
+    readonly confirmed: bigint;
+    readonly redeemed: bigint;
+    readonly available: bigint;
+    readonly pending: bigint;
+    readonly latestHeight: bigint;
+  }
+
+  /**
+   * Full balance information including light client height
+   * @category models
+   * @since 1.0.0
+   */
+  export interface BalanceInfo extends BalanceAtHeightInfo {
+    readonly lightClientHeight: bigint;
+  }
+
+  /**
+   * @category models
+   * @since 1.0.0
+   */
+  export interface MakeOptions {
+    readonly getLatestHeight: PublicClient["getLatestHeight"];
+    readonly getLatestBlockNumber: PublicClient["getLatestBlockNumber"];
+    readonly readBalance: PublicClient["readBalance"];
+    readonly readBalanceAtHeight: PublicClient["readBalanceAtHeight"];
+    readonly getProof: PublicClient["getProof"];
+    readonly waitForBlock: PublicClient["waitForBlock"];
+    readonly getLightClientAddress: PublicClient["getLightClientAddress"];
+    readonly getStateRootIndex: PublicClient["getStateRootIndex"];
+    readonly getConsensusState: PublicClient["getConsensusState"];
+    readonly getIbcHandlerAddress: PublicClient["getIbcHandlerAddress"];
+    readonly getCounterparty: PublicClient["getCounterparty"];
+  }
+}
+
+export const make: (
+  options: PublicClient.MakeOptions,
+) => Effect.Effect<PublicClient, never> = internal.make;

package/src/Schema.ts

@@ -0,0 +1,36 @@
+import * as S from "effect/Schema";
+
+/**
+ * Describes `0x${string}` from non-empty string.
+ *
+ * Note: To be used ineroperably with `viem`.
+ */
+export const Hex = S.NonEmptyString.pipe(
+  // TODO: add `Bytes` brand separately
+  S.pattern(/^0x[0-9a-fA-F]+$/), // TODO: remove uppercase
+  S.minLength(3),
+  S.annotations({
+    title: "hex",
+    description: "hex string",
+  }),
+) as unknown as S.TemplateLiteral<`0x${string}`>;
+export type Hex = typeof Hex.Type;
+
+/**
+ * Describes `0x${string}` address from non-empty string.
+ *
+ * Note: To be used ineroperably with `viem`.
+ */
+export const Address = S.NonEmptyString.pipe(
+  // TODO: add `Bytes` brand separately
+  S.pattern(/^0x[0-9a-fA-F]+$/), // TODO: remove uppercase
+  S.minLength(3),
+  S.annotations({
+    title: "address",
+    description: "address string",
+    //   }),
+    //   S.brand("Address")
+    // ) as unknown as S.brand<S.refine<S.TemplateLiteral<`0x${string}`>, S.filter<typeof S.NonEmptyString>>, "Address">
+  }),
+) as unknown as S.TemplateLiteral<`0x${string}`>;
+export type Address = typeof Address.Type;

package/src/Utils.ts

@@ -0,0 +1,43 @@
+import { type Hex, hexToBigInt } from "viem";
+import type { RedeemMetadata } from "./rpc.js";
+import type { ProofJSON, RedeemParams } from "./types.js";
+
+type DeepReadonly<T> = T extends (infer U)[]
+  ? readonly DeepReadonly<U>[]
+  : T extends object
+    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+    : T;
+
+/**
+ * @public
+ */
+export function proofJsonToRedeemParams(
+  proofJson: DeepReadonly<ProofJSON>,
+  metadata: Readonly<RedeemMetadata>,
+): RedeemParams {
+  const parseBigInt = (s: string): bigint => {
+    if (s.startsWith("0x")) {
+      return hexToBigInt(s as Hex);
+    }
+    return BigInt(s);
+  };
+
+  return {
+    proof: proofJson.proof.map(parseBigInt) as RedeemParams["proof"],
+    commitments: proofJson.commitments.map(
+      parseBigInt,
+    ) as RedeemParams["commitments"],
+    commitmentPok: proofJson.commitmentPok.map(
+      parseBigInt,
+    ) as RedeemParams["commitmentPok"],
+    lightClients: metadata.lightClients.map((lc) => ({
+      clientId: lc.clientId,
+      height: lc.height,
+    })),
+    nullifier: metadata.nullifier,
+    value: metadata.value,
+    beneficiary: metadata.beneficiary,
+    attestedMessage: metadata.attestedMessage,
+    signature: metadata.signature,
+  };
+}

package/src/WalletClient.ts

@@ -0,0 +1,172 @@
+import { Layer } from "effect";
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import type { Address } from "viem";
+import type * as Domain from "./Domain.js";
+import type { SdkError } from "./Error.js";
+import * as internal from "./internal/walletClient.js";
+import type { RedeemParams } from "./types.js";
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export const TypeId: unique symbol = internal.TypeId;
+
+/**
+ * @category type ids
+ * @since 1.0.0
+ */
+export type TypeId = typeof TypeId;
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface WalletClient {
+  readonly [TypeId]: TypeId;
+  /**
+   * Approve the ZAsset for the provided ERC20 token to spend the ERC20.
+   *
+   * The ZAsset address is derived from Z_ASSET_REGISTRY.
+   */
+  readonly approveZAssetToSpendErc20: (
+    args: WalletClient.ApproveZAssetToSpendErc20,
+  ) => Effect.Effect<Domain.PreparedRequest, SdkError, never>;
+
+  /**
+   * Deposit ("wrap") the ERC20 into it's ZAsset.
+   *
+   * The ZAsset address is derived from Z_ASSET_REGISTRY.
+   */
+  readonly depositUnderlyingZAsset: (
+    args: WalletClient.DepositUnderlyingZAsset,
+  ) => Effect.Effect<Domain.PreparedRequest, SdkError, never>;
+
+  /**
+   * Transfer the deposited ZAssset to the provided deposit address.
+   *
+   * The ZAsset address is derived from Z_ASSET_REGISTRY.
+   */
+  readonly transferZAsset: (
+    args: WalletClient.TransferZAsset,
+  ) => Effect.Effect<Domain.PreparedRequest, SdkError, never>;
+
+  readonly updateLoopbackClient: (
+    args: WalletClient.UpdateLoopbackClient,
+  ) => Effect.Effect<Domain.PreparedRequest, SdkError, never>;
+
+  readonly prepareDeposit: (
+    args: WalletClient.Deposit,
+  ) => Effect.Effect<Domain.PreparedRequests, SdkError, never>;
+
+  readonly prepareRedemption: (
+    args: WalletClient.Redeem,
+  ) => Effect.Effect<Domain.PreparedRequest, SdkError, never>;
+
+  readonly sign: (
+    request: Domain.PreparedRequest,
+  ) => Effect.Effect<Domain.SignedRequest, SdkError, never>;
+
+  // TODO: can be done by public client (?)
+  readonly submit: (
+    request: Domain.SignedRequest,
+  ) => Effect.Effect<Domain.SubmissionResult, SdkError, never>;
+
+  readonly signAndSubmit: (
+    request: Domain.PreparedRequest,
+  ) => Effect.Effect<Domain.SubmissionResult, SdkError, never>;
+}
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export const WalletClient: Context.Tag<WalletClient, WalletClient> =
+  internal.clientTag;
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export class SourceWalletClient extends Context.Tag("SourceWalletClient")<
+  SourceWalletClient,
+  WalletClient
+>() {
+  static layer = <E, R>(layer: Layer.Layer<WalletClient, E, R>) =>
+    Layer.project(layer, WalletClient, SourceWalletClient, identity);
+}
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export class DestinationWalletClient extends Context.Tag(
+  "DestinationWalletClient",
+)<DestinationWalletClient, WalletClient>() {
+  static layer = <E, R>(layer: Layer.Layer<WalletClient, E, R>) =>
+    Layer.project(layer, WalletClient, DestinationWalletClient, identity);
+}
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export namespace WalletClient {
+  /**
+   * @category models
+   * @since 1.0.0
+   */
+  export interface MakeOptions {
+    readonly sign: WalletClient["sign"];
+    readonly submit: WalletClient["submit"];
+    readonly signAndSubmit: WalletClient["signAndSubmit"];
+    readonly approveZAssetToSpendErc20: WalletClient["approveZAssetToSpendErc20"];
+    readonly depositUnderlyingZAsset: WalletClient["depositUnderlyingZAsset"];
+    readonly transferZAsset: WalletClient["transferZAsset"];
+    readonly updateLoopbackClient: WalletClient["updateLoopbackClient"];
+    readonly prepareDeposit: WalletClient["prepareDeposit"];
+    readonly prepareRedemption: WalletClient["prepareRedemption"];
+  }
+
+  export interface ApproveZAssetToSpendErc20 {
+    srcErc20Address: Domain.Erc20Address;
+    amount: bigint;
+  }
+
+  export interface UpdateLoopbackClient {
+    clientId: number;
+    height: bigint;
+    ibcHandlerAddress: Domain.IbcHandlerAddress;
+  }
+
+  export interface DepositUnderlyingZAsset {
+    srcErc20Address: Domain.Erc20Address;
+    amount: bigint;
+  }
+
+  export interface TransferZAsset {
+    srcErc20Address: Domain.Erc20Address;
+    depositAddress: `0x${string}`;
+    amount: bigint;
+  }
+
+  export type Deposit = {
+    srcErc20Address: Domain.Erc20Address;
+    sourceChainId: bigint;
+    readonly beneficiaries: ReadonlyArray<Address>;
+    depositAddress: Domain.ZAssetAddress;
+    destinationChainId: bigint;
+    amount: bigint;
+  };
+
+  export type Redeem = {
+    dstErc20Address: Domain.Erc20Address;
+    unwrap?: boolean | undefined;
+  } & RedeemParams;
+}
+
+export const make: (
+  options: WalletClient.MakeOptions,
+) => Effect.Effect<WalletClient, never, never> = internal.make;