@unionlabs/payments 0.1.0 → 0.2.0

package/src/legacy/prover.ts

@@ -0,0 +1,135 @@
+import { create } from "@bufbuild/protobuf";
+import { type Client, createClient } from "@connectrpc/connect";
+import { createGrpcWebTransport } from "@connectrpc/connect-web";
+import {
+  LightClientDataSchema,
+  MPTProofDataSchema,
+  ProofRequestSchema,
+  type WitnessData as ProtoWitnessData,
+  ProverService,
+  WitnessDataSchema,
+} from "../gen/prover_pb.js";
+import type { ProofResult, WitnessData } from "../types.js";
+
+/**
+ * Prover client for communicating with the prover gRPC-web server
+ *
+ * Uses `@connectrpc/connect-web` to communicate with the gRPC-web server.
+ * @public
+ */
+export class ProverClient {
+  private client: Client<typeof ProverService>;
+  private pollIntervalMs: number;
+  private maxPollAttempts: number;
+
+  constructor(
+    proverUrl: string,
+    options?: {
+      pollIntervalMs?: number;
+      maxPollAttempts?: number;
+    },
+  ) {
+    const transport = createGrpcWebTransport({
+      baseUrl: proverUrl,
+    });
+
+    this.client = createClient(ProverService, transport);
+    this.pollIntervalMs = options?.pollIntervalMs ?? 2000;
+    this.maxPollAttempts = options?.maxPollAttempts ?? 300; // 10 minutes with 2s interval
+  }
+
+  /**
+   * Generate a proof by sending witness data to the prover server
+   *
+   * The server handles witness transformation internally, so we send
+   * the structured WitnessData instead of pre-serialized circuit witness bytes.
+   */
+  async generateProof(witness: WitnessData): Promise<ProofResult> {
+    const protoWitness = this.witnessToProto(witness);
+    const request = create(ProofRequestSchema, {
+      witness: protoWitness,
+    });
+
+    let attempts = 0;
+    while (attempts < this.maxPollAttempts) {
+      try {
+        const response = await this.client.poll(request);
+
+        switch (response.result.case) {
+          case "done":
+            return {
+              success: true,
+              proofJson: response.result.value.proofJson,
+              createdAt: new Date(
+                Number(response.result.value.createdAt) * 1000,
+              ),
+            };
+
+          case "failed":
+            return {
+              success: false,
+              error: response.result.value.errorMessage,
+            };
+
+          case "pending":
+            await this.sleep(this.pollIntervalMs);
+            attempts++;
+            break;
+
+          default:
+            await this.sleep(this.pollIntervalMs);
+            attempts++;
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `RPC error: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      }
+    }
+
+    return {
+      success: false,
+      error: "Proof generation timed out",
+    };
+  }
+
+  /**
+   * Export the verifier contract from the prover server
+   */
+  async exportVerifier(): Promise<string> {
+    const response = await this.client.exportVerifier({});
+    return response.verifierContract;
+  }
+
+  private witnessToProto(witness: WitnessData): ProtoWitnessData {
+    return create(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(LightClientDataSchema, {
+          clientId: lc.clientId,
+          height: lc.height,
+          stateRoot: lc.stateRoot,
+        }),
+      ),
+      selectedClientIndex: witness.selectedClientIndex,
+      mptProof: create(MPTProofDataSchema, {
+        accountProof: [...witness.mptProof.accountProof],
+        storageProof: [...witness.mptProof.storageProof],
+        storageValue: witness.mptProof.storageValue,
+        storageRoot: witness.mptProof.storageRoot,
+      }),
+      tokenAddress: witness.srcZAssetAddress,
+      mappingSlot: witness.mappingSlot,
+    });
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/poseidon2.ts

@@ -0,0 +1,246 @@
+import type { Address, Hex } from "viem";
+
+const PRIME =
+  0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n; // BN254 Fr order
+const NULLIFIER_DOMAIN = 0xdeadn;
+const ADDRESS_DOMAIN = 0xdeafn;
+
+// Poseidon2 round constants for BN254 (T=2)
+// External rounds (0-2, 53-55) have pairs; internal rounds (3-52) have single constants
+const RC_EXT_0: [bigint, bigint][] = [
+  [
+    0x1da4d6adfb0d0b494584f763db50a81908580a5f5e295e168b9b8d31770fac4fn,
+    0x0946129a2e33b4e819707a56a3b3790eab80d0a0c7a0c63451fab2a59acc074cn,
+  ],
+  [
+    0x2a39b9d5376afd35580abd6952986570867b87303b07140268794dad4b8f82ean,
+    0x27605717d1245c20c546b3c7014e5fa3e4a70e66ecd6de5d32448eea5e3069b2n,
+  ],
+  [
+    0x24c896cb2594e17b973653193a470ed7e771ebb09a228d638e50809c03773632n,
+    0x0911096c45dd9cda0d61d783957003db6d8701c7869a919ad8042e1b7d597a49n,
+  ],
+];
+
+// Internal round 3-52 constants (single)
+const RC_INT: bigint[] = [
+  0x26ff6166f1e4b99e27eee6d352a8ce26f1daba01aad28021f11f38a70603afdcn, // 3
+  0x008e2faedcf76d08ad6591ff90e50fea79bcb5e18cfb7d954d5b89437bf64b7en, // 4
+  0x19c9da2379b598ace3ad4d1872470830f6184a3cec71eeb632f98820eb353d78n, // 5
+  0x0f7c4eb15d8b0b62a8f6a090ec9610a2ab3dfcdb57e2539aa459a40583dfe96bn, // 6
+  0x18b99417dc26b5e079750eba282362d1d46900b47dd5ff809171588b08ac3983n, // 7
+  0x1ee044081160b3eee2d4493feab82141c73f1c054b76320a8848af08a8d91a26n, // 8
+  0x29bb95c8763efd3e0e87f5df12ee8a150455b6d7a14780d19122220366c258dcn, // 9
+  0x22c23eec9cb13ff8a3ee9a363d740653215e8991f7f9ec12067b4705e9a5c9fbn, // 10
+  0x23589e033a31a667680c8b18926c3be09115c7644c4f905cc7deefc1690b42dcn, // 11
+  0x304e99b887f2e1e92c9c0cde5f2bdd4764f60b98a219f1f0dd64ec938a6a247cn, // 12
+  0x22e817865236ad3a76fbe88bbdf31fcae792f326271d53a3a493b2de7f7d8b4cn, // 13
+  0x10c9efe573e86fa5b238a3f5c70a00bf02bc7dcfcc4878e026b77c881dc8b1c9n, // 14
+  0x0a94f16be920d85f4d6f80e745c6bddbc084f309edffef023ea283c72b89bbb6n, // 15
+  0x23ed72b4d01d14e3c7888fedb770494abc2c1ea81d6465b5df3da0ebcd69101an, // 16
+  0x17c5115640e4cebeed0e6cbb511ac38498df815a77cb162de8d8f1022eb6bb74n, // 17
+  0x2e507fcca290d0d9cf765245750eb04773e09e1fc813959fb99680a82772e4fcn, // 18
+  0x0d4a98999f5b39176af6cce65c8d12162433f055cb71d70dfc8803013292bbbfn, // 19
+  0x238d8022cc09c21ab3c01261a03dc125321d829e22a7a3b7a1bd3c335eccfa21n, // 20
+  0x010cd8e4c2b7051cb81dc8292e35d8e943ce365613d5b39770e454ed9f4ae165n, // 21
+  0x088027e54f2a3604b11178cf0ea3c6aa861173a90fb231238e03539590ecc027n, // 22
+  0x1b840f5311a2b1d4b4cd7aa7e5a9a6d161165468daa938108302b73e464819dbn, // 23
+  0x2bf51a5da1828a1cf9b764b1e16c15929a3a346e44198ea0cb366fcd8db78dc1n, // 24
+  0x206ad089d8d296ffe68a6a86767a7fe726b8872f9c7beef9d56a3a50f6f23827n, // 25
+  0x24d19193171494fa1a54e0a99ac16d05eaec4b6d617c7c199fc07ff88eac550cn, // 26
+  0x1dd654a2ca9d9f24f33d88246a40dfb32c40662278b9c0b995d9f9fbaf152138n, // 27
+  0x0d171025c925f6e259d20ecbd3a601108c85f05b0fe7793b8acf57f3789785e4n, // 28
+  0x055bef435a43aec245cd99ccb0f7c8791d9e8cf2b80d95dd98b9908fed877d55n, // 29
+  0x10d2ac8c61c8a2e88a2a3f42d9359a14be63d0ad4cfd9f203b75765d0e595f0en, // 30
+  0x103479710e70996982a84057ec3ba6b2254d7966ddc41e85296e3d0790dcfa56n, // 31
+  0x2a366f0448fda3c05914ffb48c765da8de96f9aa340db1638225f8372921807bn, // 32
+  0x16be0fb8ef62da17919b6e0378d00594153bb8899aeb686c04626b63285837a4n, // 33
+  0x0417038500e9d06c60abbc7f0d0d24c32dec8a0b2aa5a4d52cfd8c78a15bc370n, // 34
+  0x26a6873b43ffd2ccf66ec6f4493ff9b54f4d76480bc486a3e5a0308fdd013812n, // 35
+  0x0a3314a838f32630a96251914fe5ad262f3db9b2aa8aa9f7391922d36278c498n, // 36
+  0x0fde0c5429a6beb07f462d4821f48f86aeadb46a090b15a044f4b59399027da4n, // 37
+  0x0abc2d5049972a6b9b357e4163793b0bb517e1eb535a984df11a1c89cda2c8a9n, // 38
+  0x0dab51d6e3ebfa661d21722fb21e55051b427a5f173f7f17735205dbb77c464en, // 39
+  0x29c36622598b511d51af6cc37123652fb21be5c2d68fb8efe9b92e70a8c1ae03n, // 40
+  0x2c03ec80adac2a33ae846bc0b700d0bcc41c4096e53ac6990d6bbe7ea2fbc85cn, // 41
+  0x0918fdbe9cf3a59fbdb4c6852d065105317303116017d893b8b521e3cebe1e0dn, // 42
+  0x1f19ec22e69ca33f599dd13cd7e495a8176a79df4f7acf79a9d2135acabe2359n, // 43
+  0x1c4b037c8ae85ee1eb32b872eb7f76928c4c76b29ceb001346447b2911080704n, // 44
+  0x2b68900ed906616d6c826d0bde341766ba3131e04d420de5af0a69c534efd8dbn, // 45
+  0x20ca92aa222fcc69448f8dac653c8daaa180ff6dfb397cef723d4f0c782bc7f0n, // 46
+  0x10d22d05bdff6bb375276fc82057db337045a5ab7ac053941f6186289b66b2b6n, // 47
+  0x0b1ffdbb529367bb98f32ba45784cb435aa910b4a00636d1e5ca79e88bdd6cd9n, // 48
+  0x2da32b38e7984bc2ed757ec705eccf8282c7b4f82e5e515f6f89bcc33022ce9fn, // 49
+  0x042593ad87403f6d2674b8b55a886725b87eb33958031e94d292cecc6abed1bbn, // 50
+  0x181fa1b4d067783a19d7367bf49b3f01051faedab463a6de9308fbd6e7d419f1n, // 51
+  0x15aaa6cc9b7900b15683c95515c26028a8e35b00ed8a815c34927188c60de660n, // 52
+];
+
+const RC_EXT_1: [bigint, bigint][] = [
+  [
+    0x1bf28a93209084bbbc63234f057254c280b1a636f5a0eced6787320212f75a7an,
+    0x1cdb8c8bee5426f02cd9e229776118f156273b312f805c8e6f8c9d81a620cb6fn,
+  ],
+  [
+    0x08299c0abf196d53162e0facb5f1876f516df2505cc387a0f8ea0e8760d5ca7en,
+    0x221643d205fe82778a7b7b58cb65c4962d76c0072cabd1124117269d7c710b8an,
+  ],
+  [
+    0x2d036a95f81cf49bb7a0143a28c88767f6bd10c3f74b22db487920d43343dbffn,
+    0x08a50897c06aafe6ea414fb1bceca2267cd4a39486729fbc6d5d1bb7a172ebd2n,
+  ],
+];
+
+function addMod(a: bigint, b: bigint): bigint {
+  return (((a + b) % PRIME) + PRIME) % PRIME;
+}
+
+function mulMod(a: bigint, b: bigint): bigint {
+  return (((a * b) % PRIME) + PRIME) % PRIME;
+}
+
+function sbox(x: bigint): bigint {
+  const x2 = mulMod(x, x);
+  const x4 = mulMod(x2, x2);
+  return mulMod(x4, x);
+}
+
+// M_ext = circ(2,1)
+function matMulExternal(s0: bigint, s1: bigint): [bigint, bigint] {
+  const sum = addMod(s0, s1);
+  return [addMod(sum, s0), addMod(sum, s1)];
+}
+
+// M_int = [[2,1],[1,3]]
+function matMulInternal(s0: bigint, s1: bigint): [bigint, bigint] {
+  const sum = addMod(s0, s1);
+  return [addMod(s0, sum), addMod(addMod(s1, s1), sum)];
+}
+
+// Poseidon2 permutation (T=2, 56 rounds) - matches gnark-crypto BN254
+function permutation(state0: bigint, state1: bigint): [bigint, bigint] {
+  let s0 = state0;
+  let s1 = state1;
+
+  [s0, s1] = matMulExternal(s0, s1);
+
+  // External rounds 0-2
+  for (let i = 0; i < 3; i++) {
+    s0 = addMod(s0, RC_EXT_0[i]![0]);
+    s1 = addMod(s1, RC_EXT_0[i]![1]);
+    s0 = sbox(s0);
+    s1 = sbox(s1);
+    [s0, s1] = matMulExternal(s0, s1);
+  }
+
+  // Internal rounds 3-52
+  for (let i = 0; i < 50; i++) {
+    s0 = addMod(s0, RC_INT[i]!);
+    s0 = sbox(s0);
+    [s0, s1] = matMulInternal(s0, s1);
+  }
+
+  // External rounds 53-55
+  for (let i = 0; i < 3; i++) {
+    s0 = addMod(s0, RC_EXT_1[i]![0]);
+    s1 = addMod(s1, RC_EXT_1[i]![1]);
+    s0 = sbox(s0);
+    s1 = sbox(s1);
+    [s0, s1] = matMulExternal(s0, s1);
+  }
+
+  return [s0, s1];
+}
+
+// Merkle-Damgård with Davies-Meyer compression (matches gnark)
+function poseidon2Hash(inputs: bigint[]): bigint {
+  let hashState = 0n;
+
+  for (const block of inputs) {
+    const [, permutedState1] = permutation(hashState, block);
+    hashState = addMod(block, permutedState1);
+  }
+
+  return hashState;
+}
+
+function hexToBigInt(hex: Hex): bigint {
+  return BigInt(hex);
+}
+
+function validateSecret(secret: bigint): void {
+  if (secret >= PRIME) {
+    throw new Error(
+      `Secret must be less than the BN254 scalar field prime (${PRIME.toString(16)})`,
+    );
+  }
+  if (secret < 0n) {
+    throw new Error("Secret must be non-negative");
+  }
+}
+
+function addressToBigInt(address: Address): bigint {
+  return BigInt(address);
+}
+
+/**
+ * Compute the nullifier: Poseidon2(0xDEAD || chainId || secret)
+ * @public
+ */
+export function computeNullifier(secret: Hex, dstChainId: bigint): bigint {
+  const secretBigInt = hexToBigInt(secret);
+  validateSecret(secretBigInt);
+
+  return poseidon2Hash([NULLIFIER_DOMAIN, dstChainId, secretBigInt]);
+}
+
+/**
+ * Generate a random secret valid for BN254 scalar field
+ * @public
+ */
+export function generatePaymentKey(): Hex {
+  while (true) {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    const value = BigInt(
+      "0x" +
+        Array.from(bytes)
+          .map((b) => b.toString(16).padStart(2, "0"))
+          .join(""),
+    );
+    if (value < PRIME) {
+      return ("0x" +
+        Array.from(bytes)
+          .map((b) => b.toString(16).padStart(2, "0"))
+          .join("")) as Hex;
+    }
+  }
+}
+
+/**
+ * Compute the unspendable address: bottom 160 bits of
+ * Poseidon2(0xDEAF || dstChainId || secret || beneficiary1..4)
+ * @public
+ */
+export function computeUnspendableAddress(
+  secret: Hex,
+  dstChainId: bigint,
+  beneficiaries: [Address, Address, Address, Address],
+): Address {
+  const secretBigInt = hexToBigInt(secret);
+  validateSecret(secretBigInt);
+
+  const hash = poseidon2Hash([
+    ADDRESS_DOMAIN,
+    dstChainId,
+    secretBigInt,
+    addressToBigInt(beneficiaries[0]),
+    addressToBigInt(beneficiaries[1]),
+    addressToBigInt(beneficiaries[2]),
+    addressToBigInt(beneficiaries[3]),
+  ]);
+
+  const addressMask = (1n << 160n) - 1n;
+  const addressBigInt = hash & addressMask;
+  return `0x${addressBigInt.toString(16).padStart(40, "0")}` as Address;
+}

package/src/promises/Attestor.ts

@@ -0,0 +1,25 @@
+import { Context, Effect, Layer } from "effect";
+import { flow, pipe } from "effect/Function";
+import * as attestor from "../Attestor.js";
+
+export class Attestor {
+  readonly attestor: attestor.Attestor;
+  constructor(attestor: attestor.Attestor) {
+    this.attestor = attestor;
+  }
+  get get() {
+    return flow(this.attestor.get, Effect.runPromise);
+  }
+}
+
+export const make = (
+  options: Parameters<typeof attestor.Attestor.Default>[0],
+) =>
+  pipe(
+    attestor.Attestor.Default(options),
+    Layer.build,
+    Effect.map(Context.get(attestor.Attestor)),
+    Effect.map((client) => new Attestor(client)),
+    Effect.scoped,
+    Effect.runPromise,
+  );

package/src/promises/EvmPublicClient.ts

@@ -0,0 +1,39 @@
+import { Context, Effect, Layer } from "effect";
+import { flow } from "effect/Function";
+import * as evmPublicClient from "../EvmPublicClient.js";
+import * as publicClient from "../PublicClient.js";
+import * as PublicClient from "./PublicClient.js";
+
+export class EvmPublicClient extends PublicClient.PublicClient {
+  private evmClient: evmPublicClient.EvmPublicClient;
+
+  constructor({
+    client,
+    evmClient,
+  }: {
+    client: publicClient.PublicClient;
+    evmClient: evmPublicClient.EvmPublicClient;
+  }) {
+    super(client);
+    this.evmClient = evmClient;
+  }
+
+  get waitForTransactionReceipt() {
+    return flow(this.evmClient.waitForTransactionReceipt, Effect.runPromise);
+  }
+  get simulateCalls() {
+    return flow(this.evmClient.simulateCalls, Effect.runPromise);
+  }
+}
+
+export const fromViem = flow(
+  evmPublicClient.layerFromViem,
+  Layer.build,
+  Effect.map((ctx) => ({
+    evmClient: Context.get(ctx, evmPublicClient.EvmPublicClient),
+    client: Context.get(ctx, publicClient.PublicClient),
+  })),
+  Effect.map((args) => new EvmPublicClient(args)),
+  Effect.scoped,
+  Effect.runPromise,
+);

package/src/promises/EvmWalletClient.ts

@@ -0,0 +1,63 @@
+import { Context, Effect, Layer } from "effect";
+import { flow } from "effect/Function";
+import * as evmWalletClient from "../EvmWalletClient.js";
+import * as walletClient from "../WalletClient.js";
+import * as WalletClient from "./WalletClient.js";
+// import type * as ThirdwebAdaptersViem from "thirdweb/adapters/viem"
+
+export class EvmWalletClient extends WalletClient.WalletClient {
+  constructor({
+    client,
+  }: {
+    client: walletClient.WalletClient;
+    evmClient: evmWalletClient.EvmWalletClient;
+  }) {
+    super(client);
+  }
+}
+
+export const fromViem = flow(
+  evmWalletClient.layerFromViem,
+  Layer.build,
+  Effect.map((ctx) => ({
+    evmClient: Context.get(ctx, evmWalletClient.EvmWalletClient),
+    client: Context.get(ctx, walletClient.WalletClient),
+  })),
+  Effect.map((args) => new EvmWalletClient(args)),
+  Effect.scoped,
+  Effect.runPromise,
+);
+
+/**
+ * @category layers
+ * @since 1.0.0
+ */
+export const fromBrowser = flow(
+  evmWalletClient.layerFromBrowser,
+  Layer.build,
+  Effect.map((ctx) => ({
+    evmClient: Context.get(ctx, evmWalletClient.EvmWalletClient),
+    client: Context.get(ctx, walletClient.WalletClient),
+  })),
+  Effect.map((args) => new EvmWalletClient(args)),
+  Effect.scoped,
+  Effect.runPromise,
+);
+
+// /**
+//  * @category layers
+//  * @since 1.0.0
+//  */
+// export const fromThirdweb = (
+//   ...options: Parameters<typeof ThirdwebAdaptersViem['viemAdapter']['wallet']['toViem']>
+// ) => pipe(
+//   Evm.layerFromThirdweb(...options),
+//   Layer.build,
+//   Effect.map((ctx) => ({
+//     evmClient: Context.get(ctx, Evm.EvmWalletClient),
+//     client: Context.get(ctx, Client.WalletClient),
+//   })),
+//   Effect.map((args) => new EvmWalletClient(args)),
+//   Effect.scoped,
+//   Effect.runPromise
+// )

package/src/promises/Payment.ts

@@ -0,0 +1,86 @@
+import { Effect, Layer, Struct } from "effect";
+import { constant, flow, pipe } from "effect/Function";
+import * as attestor from "../Attestor.js";
+import * as payment from "../Payment.js";
+import * as prover from "../Prover.js";
+import * as publicClient from "../PublicClient.js";
+import * as walletClient from "../WalletClient.js";
+import type * as Attestor from "./Attestor.js";
+import type * as Prover from "./Prover.js";
+import type * as PublicClient from "./PublicClient.js";
+import type * as WalletClient from "./WalletClient.js";
+
+export const generateKey = constant(
+  pipe(payment.generateKey, Effect.runPromise),
+);
+
+export const prepareDeposit = (
+  options: {
+    sourceWalletClient: WalletClient.WalletClient;
+  } & Parameters<typeof payment.prepareDeposit>[0],
+) =>
+  pipe(
+    payment.prepareDeposit(pipe(options, Struct.omit("sourceWalletClient"))),
+    Effect.provide(
+      Layer.succeed(
+        walletClient.SourceWalletClient,
+        options.sourceWalletClient.client,
+      ),
+    ),
+    Effect.runPromise,
+  );
+
+export const prepareRedemption = (
+  options: {
+    sourceWalletClient: WalletClient.WalletClient;
+    destinationWalletClient: WalletClient.WalletClient;
+    destinationPublicClient: PublicClient.PublicClient;
+    sourcePublicClient: PublicClient.PublicClient;
+    publicClient: PublicClient.PublicClient;
+    attestor: Attestor.Attestor;
+    prover: Prover.Prover;
+  } & Parameters<typeof payment.prepareRedemption>[0],
+) =>
+  pipe(
+    payment.prepareRedemption(
+      pipe(
+        options,
+        Struct.omit("sourceWalletClient"),
+        Struct.omit("publicClient"),
+        Struct.omit("destinationWalletClient"),
+        Struct.omit("destinationPublicClient"),
+        Struct.omit("sourcePublicClient"),
+        Struct.omit("attestor"),
+        Struct.omit("prover"),
+      ),
+    ),
+    Effect.provide([
+      Layer.succeed(
+        walletClient.SourceWalletClient,
+        options.sourceWalletClient.client,
+      ),
+      Layer.succeed(publicClient.PublicClient, options.publicClient.client),
+      Layer.succeed(
+        walletClient.DestinationWalletClient,
+        options.destinationWalletClient.client,
+      ),
+      Layer.succeed(
+        publicClient.DestinationPublicClient,
+        options.destinationPublicClient.client,
+      ),
+      Layer.succeed(
+        publicClient.SourcePublicClient,
+        options.sourcePublicClient.client,
+      ),
+      Layer.succeed(attestor.Attestor, options.attestor.attestor),
+      Layer.succeed(prover.Prover, options.prover.prover),
+    ]),
+    Effect.runPromise,
+  );
+
+export const getNullifier = flow(payment.getNullifier, Effect.runPromise);
+
+export const getDepositAddress = flow(
+  payment.getDepositAddress,
+  Effect.runPromise,
+);

package/src/promises/Prover.ts

@@ -0,0 +1,26 @@
+import { Context, Effect, Layer } from "effect";
+import { flow, pipe } from "effect/Function";
+import * as prover from "../Prover.js";
+
+export class Prover {
+  readonly prover: prover.Prover;
+  constructor(prover: prover.Prover) {
+    this.prover = prover;
+  }
+  get exportVerifier() {
+    return pipe(this.prover.exportVerifier, Effect.runPromise);
+  }
+  get generateProof() {
+    return flow(this.prover.generateProof, Effect.runPromise);
+  }
+}
+
+export const make = (options: Parameters<typeof prover.Prover.Default>[0]) =>
+  pipe(
+    prover.Prover.Default(options),
+    Layer.build,
+    Effect.map(Context.get(prover.Prover)),
+    Effect.map((client) => new Prover(client)),
+    Effect.scoped,
+    Effect.runPromise,
+  );

package/src/promises/PublicClient.ts

@@ -0,0 +1,47 @@
+import { Effect } from "effect";
+import { flow } from "effect/Function";
+import * as client from "../PublicClient.js";
+
+export class PublicClient {
+  readonly [client.TypeId] = client.TypeId;
+  readonly safe = this;
+  client: client.PublicClient;
+
+  constructor(client: client.PublicClient) {
+    this.client = client;
+  }
+
+  get waitForBlock() {
+    return flow(this.client.waitForBlock, Effect.runPromise);
+  }
+  get getLatestHeight() {
+    return flow(this.client.getLatestHeight, Effect.runPromise);
+  }
+  get getLatestBlockNumber() {
+    return flow(this.client.getLatestBlockNumber, Effect.runPromise);
+  }
+  get readBalance() {
+    return flow(this.client.readBalance, Effect.runPromise);
+  }
+  get readBalanceAtHeight() {
+    return flow(this.client.readBalanceAtHeight, Effect.runPromise);
+  }
+  get getLightClientAddress() {
+    return flow(this.client.getLightClientAddress, Effect.runPromise);
+  }
+  get getStateRootIndex() {
+    return flow(this.client.getStateRootIndex, Effect.runPromise);
+  }
+  get getConsensusState() {
+    return flow(this.client.getConsensusState, Effect.runPromise);
+  }
+  get getIbcHandlerAddress() {
+    return flow(this.client.getIbcHandlerAddress, Effect.runPromise);
+  }
+  get getCounterparty() {
+    return flow(this.client.getCounterparty, Effect.runPromise);
+  }
+  get getProof() {
+    return flow(this.client.getProof, Effect.runPromise);
+  }
+}