@unionlabs/payments 0.1.0 → 0.2.0

package/src/Abi.ts

@@ -0,0 +1,195 @@
+export const ERC20_ABI = [
+  {
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" },
+    ],
+    name: "approve",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;
+
+// export const ZASSET_ABI = [
+//   {
+//     inputs: [{ name: "amount", type: "uint256" }],
+//     name: "deposit",
+//     outputs: [],
+//     stateMutability: "nonpayable",
+//     type: "function",
+//   },
+//   {
+//     inputs: [
+//       { name: "to", type: "address" },
+//       { name: "amount", type: "uint256" },
+//     ],
+//     name: "transfer",
+//     outputs: [{ name: "", type: "bool" }],
+//     stateMutability: "nonpayable",
+//     type: "function",
+//   },
+//   {
+//     inputs: [
+//       { name: "proof", type: "uint256[8]" },
+//       { name: "commitments", type: "uint256[2]" },
+//       { name: "commitmentPok", type: "uint256[2]" },
+//       {
+//         name: "lightClients",
+//         type: "tuple[]",
+//         components: [
+//           { name: "clientId", type: "uint32" },
+//           { name: "height", type: "uint64" },
+//         ],
+//       },
+//       { name: "nullifier", type: "uint256" },
+//       { name: "value", type: "uint256" },
+//       { name: "beneficiary", type: "address" },
+//       { name: "attestedMessage", type: "bytes32" },
+//       { name: "signature", type: "bytes" },
+//       { name: "unwrap", type: "bool" },
+//     ],
+//     name: "redeem",
+//     outputs: [],
+//     stateMutability: "nonpayable",
+//     type: "function",
+//   },
+// ] as const;
+
+export const ZASSET_ABI = [
+  {
+    inputs: [{ name: "nullifier", type: "uint256" }],
+    name: "nullifierBalance",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ name: "clientId", type: "uint32" }],
+    name: "counterparty",
+    outputs: [
+      {
+        components: [
+          { name: "tokenAddressKey", type: "bytes32" },
+          { name: "balanceSlot", type: "bytes32" },
+        ],
+        type: "tuple",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "ibcHandler",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ name: "clientId", type: "uint32" }],
+    name: "stateRootIndex",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "underlying",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ name: "amount", type: "uint256" }],
+    name: "deposit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" },
+    ],
+    name: "transfer",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { name: "proof", type: "uint256[8]" },
+      { name: "commitments", type: "uint256[2]" },
+      { name: "commitmentPok", type: "uint256[2]" },
+      {
+        name: "lightClients",
+        type: "tuple[]",
+        components: [
+          { name: "clientId", type: "uint32" },
+          { name: "height", type: "uint64" },
+        ],
+      },
+      { name: "nullifier", type: "uint256" },
+      { name: "value", type: "uint256" },
+      { name: "beneficiary", type: "address" },
+      { name: "attestedMessage", type: "bytes32" },
+      { name: "signature", type: "bytes" },
+      { name: "unwrap", type: "bool" },
+    ],
+    name: "redeem",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: false, name: "value", type: "uint256" },
+    ],
+    name: "Transfer",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "nullifier", type: "uint256" },
+      { indexed: true, name: "redeemAmount", type: "uint256" },
+      { indexed: true, name: "beneficiary", type: "address" },
+    ],
+    name: "Redeemed",
+    type: "event",
+  },
+] as const;
+
+export const LIGHT_CLIENT_ABI = [
+  {
+    inputs: [{ name: "clientId", type: "uint32" }],
+    name: "getLatestHeight",
+    outputs: [{ name: "", type: "uint64" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { name: "clientId", type: "uint32" },
+      { name: "height", type: "uint64" },
+    ],
+    name: "getConsensusState",
+    outputs: [{ name: "", type: "bytes" }],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export const IBC_STORE_ABI = [
+  {
+    inputs: [{ name: "clientId", type: "uint32" }],
+    name: "getClient",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;

package/src/Attestor.ts

@@ -0,0 +1,113 @@
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import { Effect, flow, pipe, Redacted } from "effect";
+import { constTrue } from "effect/Function";
+import * as S from "effect/Schema";
+import { DEFAULT_ATTESTOR_URL } from "./constants/services.js";
+import * as Error from "./Error.js";
+import * as PS from "./Schema.js";
+
+const Options = S.Struct({
+  baseUrl: S.optionalWith(S.Union(S.URLFromSelf, S.URL), {
+    default: () => new globalThis.URL(DEFAULT_ATTESTOR_URL),
+  }),
+  apiKey: S.Redacted(S.NonEmptyTrimmedString),
+});
+type Options = typeof Options.Type;
+
+export const AttestationServiceResponse = S.Struct({
+  id: S.String,
+  hash: PS.Hex,
+  signature: S.Struct({
+    r: PS.Hex,
+    s: PS.Hex,
+    v: S.Number,
+  }),
+  signerAddress: PS.Address,
+});
+export type AttestationServiceResponse = typeof AttestationServiceResponse.Type;
+
+/**
+ * Client for attestation service that signs poseidon(unspendable_address, beneficiary)
+ * @public
+ */
+export class Attestor extends Effect.Service<Attestor>()(
+  "@unionlabs/payments/Attestor",
+  {
+    scoped: Effect.fn(function* (options: S.Schema.Encoded<typeof Options>) {
+      const { baseUrl, apiKey } = yield* pipe(
+        options,
+        S.decode(Options),
+        Effect.mapError(
+          (cause) =>
+            new Error.SystemError({
+              method: "Prover",
+              module: "Prover",
+              reason: "InvalidData",
+              cause,
+            }),
+        ),
+      );
+
+      const client = yield* pipe(
+        HttpClient.HttpClient,
+        Effect.map(HttpClient.withTracerDisabledWhen(constTrue)),
+        Effect.map(
+          HttpClient.mapRequest(
+            flow(
+              HttpClientRequest.setUrl(baseUrl),
+              HttpClientRequest.setHeaders({
+                "x-api-key": Redacted.value(apiKey),
+              }),
+              HttpClientRequest.acceptJson,
+            ),
+          ),
+        ),
+      );
+
+      const get = Effect.fn("get")(
+        (payload: {
+          unspendableAddress: PS.Address;
+          beneficiary: PS.Address;
+        }) =>
+          pipe(
+            HttpClientRequest.post(""),
+            HttpClientRequest.bodyJson(payload),
+            Effect.flatMap(client.execute),
+            Effect.flatMap(
+              HttpClientResponse.schemaBodyJson(AttestationServiceResponse),
+            ),
+            Effect.map((a) => ({
+              ...a,
+              signature: (() => {
+                // Combine r, s, v into 65-byte signature
+                const r = a.signature.r.slice(2);
+                const s = a.signature.s.slice(2);
+                const v = a.signature.v.toString(16).padStart(2, "0");
+                const signature = `0x${r}${s}${v}` as const;
+
+                return signature;
+              })(),
+              attestedMessage: a.hash,
+            })),
+            Effect.mapError(
+              (cause) =>
+                new Error.SystemError({
+                  method: "get",
+                  module: "Attestor",
+                  reason: "InvalidData",
+                  cause,
+                }),
+            ),
+          ),
+      );
+
+      return {
+        get,
+      } as const;
+    }),
+    dependencies: [FetchHttpClient.layer],
+  },
+) {}

package/src/Constants.ts

@@ -0,0 +1,4 @@
+import type * as PS from "./Schema.js";
+
+export const ZERO_ADDRESS: PS.Address =
+  "0x0000000000000000000000000000000000000000" as PS.Address;

package/src/Domain.ts

@@ -0,0 +1,52 @@
+import { Brand } from "effect";
+import type * as A from "effect/Array";
+import * as Data from "effect/Data";
+import * as S from "effect/Schema";
+import type * as Viem from "viem";
+import * as PS from "./Schema.js";
+
+export type RequestKind = "approval" | "deposit" | "transfer";
+
+export type PreparedRequest = Data.TaggedEnum<{
+  viem: {
+    kind: RequestKind;
+    request: Viem.PrepareTransactionRequestReturnType;
+  };
+}>;
+export const PreparedRequest = Data.taggedEnum<PreparedRequest>();
+
+export type PreparedRequests = A.NonEmptyReadonlyArray<PreparedRequest>;
+
+export type SignedRequest = Data.TaggedEnum<{
+  viem: {
+    value: Viem.SignTransactionReturnType;
+  };
+}>;
+export const SignedRequest = Data.taggedEnum<SignedRequest>();
+
+export type SubmissionResult = Data.TaggedEnum<{
+  viemWriteContract: {
+    hash: TxHash;
+  };
+}>;
+
+export const SubmissionResult = Data.taggedEnum<SubmissionResult>();
+
+export const CounterpartyInfo = S.Struct({
+  tokenAddressKey: PS.Hex,
+  balanceSlot: PS.Hex,
+});
+export type CounterpartyInfo = typeof CounterpartyInfo.Type;
+
+export type Erc20Address = `0x${string}` & Brand.Brand<"Erc20Address">;
+export const Erc20Address = Brand.nominal<Erc20Address>();
+export type IbcHandlerAddress = `0x${string}` &
+  Brand.Brand<"IbcHandlerAddress">;
+export const IbcHandlerAddress = Brand.nominal<IbcHandlerAddress>();
+export type LightClientAddress = `0x${string}` &
+  Brand.Brand<"LightClientAddress">;
+export const LightClientAddress = Brand.nominal<LightClientAddress>();
+export type TxHash = `0x${string}` & Brand.Brand<"TxHash">;
+export const TxHash = Brand.nominal<TxHash>();
+export type ZAssetAddress = `0x${string}` & Brand.Brand<"ZAssetAddress">;
+export const ZAssetAddress = Brand.nominal<ZAssetAddress>();

package/src/Error.ts

@@ -0,0 +1,163 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Cause from "effect/Cause";
+import * as Data from "effect/Data";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import type { Simplify } from "effect/Types";
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+export const TypeId: unique symbol = Symbol.for("@unionlabs/payments/Error");
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+export type TypeId = typeof TypeId;
+
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isSdkError = (u: unknown): u is SdkError =>
+  Predicate.hasProperty(u, TypeId);
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export const TypeIdError = <
+  const TypeId extends symbol,
+  const Tag extends string,
+>(
+  typeId: TypeId,
+  tag: Tag,
+): (new <A extends Record<string, any>>(
+  args: Simplify<A>,
+) => Cause.YieldableError &
+  Record<TypeId, TypeId> & { readonly _tag: Tag } & Readonly<A>) => {
+  class Base extends Data.Error<{}> {
+    readonly _tag = tag;
+  }
+  (Base.prototype as any)[typeId] = typeId;
+  (Base.prototype as any).name = tag;
+  return Base as any;
+};
+
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+export const Module = Schema.Literal(
+  "EvmWalletClient",
+  "EvmPublicClient",
+  "PaymentClient",
+  "Prover",
+  "Attestor",
+  "IbcCoreRegistry",
+  // "Clipboard",
+  // "Command",
+  // "FileSystem",
+  // "KeyValueStore",
+  // "Path",
+  // "Stream",
+  // "Terminal"
+);
+
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+export class BadArgument extends Schema.TaggedError<BadArgument>(
+  "@unionlabs/payments/Error/BadArgument",
+)("BadArgument", {
+  module: Module,
+  method: Schema.String,
+  description: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect),
+}) {
+  /**
+   * @since 1.0.0
+   */
+  readonly [TypeId]: typeof TypeId = TypeId;
+
+  /**
+   * @since 1.0.0
+   */
+  get message(): string {
+    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category Model
+ */
+export const SystemErrorReason = Schema.Literal(
+  "DynamicImport",
+  "ReadContract",
+  // "BadResource",
+  // "Busy",
+  "InvalidData",
+  "SimulateCalls",
+  // "NotFound",
+  // "PermissionDenied",
+  // "TimedOut",
+  // "UnexpectedEof",
+  // "Unknown",
+  // "WouldBlock",
+  // "WriteZero"
+);
+
+/**
+ * @since 1.0.0
+ * @category Model
+ */
+export type SystemErrorReason = typeof SystemErrorReason.Type;
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export class SystemError extends Schema.TaggedError<SystemError>(
+  "@unionlabs/payments/Error/SystemError",
+)("SystemError", {
+  reason: SystemErrorReason,
+  module: Module,
+  method: Schema.String,
+  description: Schema.optional(Schema.String),
+  syscall: Schema.optional(Schema.String),
+  pathOrDescriptor: Schema.optional(Schema.Union(Schema.String, Schema.Number)),
+  cause: Schema.optional(Schema.Defect),
+}) {
+  /**
+   * @since 1.0.0
+   */
+  readonly [TypeId]: typeof TypeId = TypeId;
+
+  /**
+   * @since 1.0.0
+   */
+  get message(): string {
+    return `${this.reason}: ${this.module}.${this.method}${
+      this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""
+    }${this.description ? `: ${this.description}` : ""}`;
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+export type SdkError = BadArgument | SystemError;
+
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+export const SdkError: Schema.Union<[typeof BadArgument, typeof SystemError]> =
+  Schema.Union(BadArgument, SystemError);