@fatsolutions/privacy-pools-core-starknet-sdk 0.0.1

package/src/errors/contracts.errors.ts

@@ -0,0 +1,35 @@
+export const CONTRACT_ERROR_CODES = {
+  "0x4173736574204d6973736d61746368": "Asset Missmatch",
+  "0x43616c6c6572206973206e6f7420456e747279706f696e74": "Caller is not Entrypoint",
+  "0x436f6d6d69746d656e74206e6f7420666f756e64": "Commitment not found",
+  "0x436f6d6d69746d656e742070726573656e74": "Commitment present",
+  "0x496e636f72726563742041535020726f6f74": "Incorrect ASP root",
+  "0x496e76616c696420416d6f756e74": "Invalid Amount",
+  "0x496e76616c696420436f6e74657874": "Invalid Context",
+  "0x496e76616c696420456e747279706f696e74": "Invalid Entrypoint",
+  "0x496e76616c696420506f6f6c205374617465": "Invalid Pool State",
+  "0x496e76616c69642050726f636573736f72": "Invalid Processor",
+  "0x496e76616c69642050726f6f66": "Invalid Proof",
+  "0x496e76616c696420526f6f74": "Invalid Root",
+  "0x496e76616c69642054726565204465707468": "Invalid Tree Depth",
+  "0x4e6f2041535020726f6f742073746f726564": "No ASP root stored",
+  "0x4e6f74204f726967696e616c204465706f7369746f72": "Not Original Depositor",
+  "0x4e756c6c69666965722075736564": "Nullifier used",
+  "0x506f6f6c20616c72656164792072656769737465726564": "Pool already registered",
+  "0x506f6f6c20646f6573206e6f74206578697374": "Pool does not exist",
+  "0x506f6f6c2069732064656164": "Pool is dead",
+  "0x506f6f6c206e6f7420666f756e64": "Pool not found",
+  "0x506f6f6c206e6f742072656769737465726564": "Pool not registered",
+  "0x507265636f6d6d69746d656e742075736564": "Precommitment used",
+  "0x72656c617965722066656520544f2048494748": "relayer fee TO HIGH",
+  "0x56616c7565206c6573732074686174206d696e696d756d": "Value less that minimum"
+} as const;
+
+export function parseContractError(errorString: string): string | null {
+  for (const [hexCode, description] of Object.entries(CONTRACT_ERROR_CODES)) {
+    if (errorString.includes(hexCode)) {
+      return description;
+    }
+  }
+  return null;
+}

package/src/errors/index.ts

@@ -0,0 +1,69 @@
+
+export enum SNBaseErrorCode {
+  UNKNOWN,
+  UNREACHABLE,
+  INTERNAL
+}
+
+export enum SNContractErrorCode {
+  DEPOSIT_FAILED,
+  INVALID_IPFS_CID,
+  REVERT
+}
+
+export enum SNFormatErrorCode {
+  CONVERSION
+}
+
+export type SNErrorCode = SNBaseErrorCode | SNContractErrorCode | SNFormatErrorCode;
+
+export class StarknetSDKError extends Error {
+
+  override readonly name: string;
+  override message: string;
+
+  constructor(message: string, readonly code: SNErrorCode) {
+    super();
+    this.message = message;
+    this.name = this.constructor.name;
+    this.code = code;
+  }
+
+  public static unknown() {
+    return new this("Unknown error", SNBaseErrorCode.UNKNOWN);
+  }
+
+  public static unreachable() {
+    return new this("Ureachable code", SNBaseErrorCode.UNREACHABLE);
+  }
+
+  public static internal(msg?: string) {
+    return new this(msg || "Internal error", SNBaseErrorCode.INTERNAL);
+  }
+
+}
+
+export class SNFormatError extends StarknetSDKError {
+
+  public static conversion(conetxt?: string) {
+    const _context = conetxt || "Conversion failed";
+    return new this(_context, SNFormatErrorCode.CONVERSION);
+  }
+
+}
+
+export class SNContractError extends StarknetSDKError {
+
+  public static depositFailed() {
+    return new this("Deposit failed", SNContractErrorCode.DEPOSIT_FAILED);
+  }
+
+  public static invalidIPFSsize(ipfsCID: string) {
+    return new this(`Invalid IPFS CID size: expected >32 & <64, got ${ipfsCID.length}`, SNContractErrorCode.INVALID_IPFS_CID);
+  }
+
+  public static revert(reason: string) {
+    return new this(reason, SNContractErrorCode.REVERT);
+  }
+
+}

package/src/garaga.ts

@@ -0,0 +1,20 @@
+import { Groth16VerifyingKey, Groth16Proof } from "./types/garaga.js";
+import * as garaga from "garaga";
+
+let _initialized = false;
+garaga.init().then(() => _initialized = true);
+
+function sleep(ms: number) {
+  return new Promise(res => setTimeout(res, ms));
+}
+
+async function _waitUntilReady() {
+  while (!_initialized) {
+    await sleep(100);
+  }
+}
+
+export async function getGroth16CallData(proof: Groth16Proof, verifyingKey: Groth16VerifyingKey) {
+  await _waitUntilReady();
+  return garaga.getGroth16CallData(proof, verifyingKey, garaga.CurveId.BN254);
+}

package/src/index.ts

@@ -0,0 +1,46 @@
+export {
+  generateMerkleProof,
+  getCommitment,
+  hashPrecommitment
+} from "@0xbow/privacy-pools-core-sdk";
+
+// Re-export core SDK
+export * from "@0xbow/privacy-pools-core-sdk";
+
+// Main SDK class
+export { PrivacyPoolStarknetSDK } from "./sdk.js";
+
+// Contract interactions
+export * from "./contracts/index.js";
+
+// Types and interfaces - rename conflicting exports
+export type {
+  Withdrawal as StarknetWithdrawal,
+  RelayData
+} from "./types/entrypoint.js";
+
+// Functions from entrypoint types
+export {
+  serializeRelayData,
+  serializeWithdrawal
+} from "./types/entrypoint.js";
+export * from "./types/conversions.js";
+export * from "./types/garaga.js";
+export * from "./types/snarkjs.js";
+
+// Error classes
+export * from "./errors/index.js";
+
+// ABIs for contract interactions
+export * from "./abis/index.js";
+
+// Utility functions
+export * from "./utils.js";
+
+// Constants
+export * from "./constants.js";
+
+// Data service
+export {
+  StarknetDataService,
+} from "./data.service.js";

package/src/sdk.ts

@@ -0,0 +1,44 @@
+import { Address } from "viem";
+import { CircuitName, CircuitsInterface, Commitment, CommitmentProof, PrivacyPoolSDK, WithdrawalProof, WithdrawalProofInput } from "@0xbow/privacy-pools-core-sdk";
+import { SNContractInteractionsService } from "./contracts/contracts.service";
+import { withdrawalProofToGaragaCalldata } from "./utils";
+import { RpcProvider, Account as SNAccount } from "starknet";
+
+export class PrivacyPoolStarknetSDK extends PrivacyPoolSDK {
+  circuits: CircuitsInterface;
+
+  constructor(circuits: CircuitsInterface) {
+    super(circuits);
+    this.circuits = circuits;
+  }
+
+  public createSNContractInstance(
+    entrypointAddress: Address,
+    providerOrAccount: SNAccount | RpcProvider,
+  ): SNContractInteractionsService {
+    return new SNContractInteractionsService(
+      entrypointAddress,
+      providerOrAccount
+    );
+  }
+
+  async proveWithdrawalSN(commitment: Commitment, input: WithdrawalProofInput): Promise<{ withdrawalProof: WithdrawalProof, calldata: bigint[]; }> {
+    const withdrawalProof: WithdrawalProof = await super.proveWithdrawal(commitment, input);
+    const vkeyRaw = await this.circuits.getVerificationKey(CircuitName.Withdraw);
+    return {
+      withdrawalProof,
+      calldata: await withdrawalProofToGaragaCalldata(withdrawalProof, vkeyRaw)
+    };
+  }
+
+  async proveCommitmentSN(commitment: Commitment): Promise<{ commitmentProof: CommitmentProof, calldata: bigint[]; }> {
+    const { preimage: { label, value, precommitment: { nullifier, secret } } } = commitment;
+    const commitmentProof: WithdrawalProof = await super.proveCommitment(value, label, nullifier, secret);
+    const vkeyRaw = await this.circuits.getVerificationKey(CircuitName.Commitment);
+    return {
+      commitmentProof,
+      calldata: await withdrawalProofToGaragaCalldata(commitmentProof, vkeyRaw)
+    };
+  }
+
+}

package/src/types/conversions.ts

@@ -0,0 +1,59 @@
+import { SNFormatError } from "../errors";
+import { G1Point$1, G2Point$1, Groth16Proof, Groth16VerifyingKey } from "./garaga";
+import { SnarkJsGroth16Proof, SnarkJsVkey } from "./snarkjs";
+
+
+export function G1StoG1G(s: string[]): G1Point$1 {
+  const [x, y] = s;
+  if (x === undefined || y === undefined)
+    throw SNFormatError.conversion(`Invalid G1 point: missing x or y coordinate pair. Input (${x}, ${y})`);
+  return {
+    x: BigInt(x),
+    y: BigInt(y),
+    curveId: 0,
+  };
+}
+
+export function G2StoG2G(s: string[][]): G2Point$1 {
+  const [x, y] = s;
+
+  if (!x || !y) {
+    throw SNFormatError.conversion("Invalid G2 point: missing x or y coordinate pair");
+  }
+
+  const [x0, x1] = x;
+  const [y0, y1] = y;
+
+  if (x0 === undefined || x1 === undefined || y0 === undefined || y1 === undefined) {
+    throw SNFormatError.conversion(`Invalid G2 point: incomplete coordinate pair. Input ((${x0}, ${x1}), (${y0}, ${y1}))`);
+  }
+
+  return {
+    x: [BigInt(x0), BigInt(x1)],
+    y: [BigInt(y0), BigInt(y1)],
+    curveId: 0,
+  };
+}
+
+export function snarkJsKeyIntoGaraga(vkey: SnarkJsVkey): Groth16VerifyingKey {
+  return {
+    alpha: G1StoG1G(vkey.vk_alpha_1),
+    beta: G2StoG2G(vkey.vk_beta_2),
+    gamma: G2StoG2G(vkey.vk_gamma_2),
+    delta: G2StoG2G(vkey.vk_delta_2),
+    ic: vkey.IC.map(G1StoG1G),
+  };
+}
+
+export function snarkJsProofIntoGaraga(
+  proof: SnarkJsGroth16Proof,
+  publicInputs: string[]
+): Groth16Proof {
+  return {
+    a: G1StoG1G(proof.pi_a),
+    b: G2StoG2G(proof.pi_b),
+    c: G1StoG1G(proof.pi_c),
+    publicInputs: publicInputs.map(BigInt),
+    curveId: 0,
+  };
+}

package/src/types/entrypoint.ts

@@ -0,0 +1,23 @@
+import { BigNumberish, cairo } from "starknet";
+
+export interface Withdrawal {
+  processor: BigNumberish,
+  data: BigNumberish[];
+}
+
+export interface RelayData {
+  recipient: BigNumberish,
+  feeRecipient: BigNumberish,
+  relayFeeBPS: BigNumberish,
+}
+
+export function serializeRelayData(data: RelayData) {
+  const { recipient, feeRecipient, relayFeeBPS } = data;
+  const { low, high } = cairo.uint256(relayFeeBPS);
+  return [recipient.toString(), feeRecipient.toString(), low.toString(), high.toString()];
+}
+
+export function serializeWithdrawal(withdrawal: Withdrawal) {
+  const { processor, data } = withdrawal;
+  return [processor.toString(), data.length.toString(), ...data.map(x => x.toString())];
+}

package/src/types/garaga.ts

@@ -0,0 +1,29 @@
+type CurveId = 0;
+
+export interface G1Point$1 {
+    x: bigint;
+    y: bigint;
+    curveId: CurveId;
+}
+
+export interface G2Point$1 {
+    x: [bigint, bigint];
+    y: [bigint, bigint];
+    curveId: CurveId;
+}
+
+export interface Groth16Proof {
+    a: G1Point$1;
+    b: G2Point$1;
+    c: G1Point$1;
+    publicInputs: bigint[];
+    curveId?: CurveId;
+}
+
+export interface Groth16VerifyingKey {
+    alpha: G1Point$1;
+    beta: G2Point$1;
+    gamma: G2Point$1;
+    delta: G2Point$1;
+    ic: G1Point$1[];
+}

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from "./conversions.js";
+export * from "./entrypoint.js";
+export * from "./garaga.js";
+export * from "./snarkjs.js";

package/src/types/snarkjs.ts

@@ -0,0 +1,26 @@
+import { type Groth16Proof } from "snarkjs";
+
+export type SnarkJsGroth16Proof = Groth16Proof;
+
+export interface SnarkJsVkey {
+  protocol: 'groth16',
+  curve: 'bn128',
+  nPublic: number,
+  vk_alpha_1: [string, string, '1'],
+  vk_beta_2: [
+    [string, string],
+    [string, string,],
+    ['1', '0']
+  ],
+  vk_gamma_2: [
+    [string, string],
+    [string, string],
+    ['1', '0']
+  ],
+  vk_delta_2: [
+    [string, string],
+    [string, string],
+    ['1', '0']
+  ],
+  IC: [string, string, '1'][];
+}

package/src/utils.ts

@@ -0,0 +1,49 @@
+import { WithdrawalProof } from "@0xbow/privacy-pools-core-sdk";
+import { poseidonHashMany } from "@scure/starknet";
+import { BigNumberish, cairo, num, uint256, Uint256 } from "starknet";
+
+import { getGroth16CallData } from "./garaga";
+import { snarkJsKeyIntoGaraga, snarkJsProofIntoGaraga } from "./types/conversions";
+import { serializeWithdrawal, Withdrawal } from "./types/entrypoint";
+import { SnarkJsVkey } from "./types/snarkjs";
+const { toBigInt } = num;
+
+
+export function computeScope(poolAddress: BigNumberish, chainId: BigNumberish, assetAddress: BigNumberish) {
+  return poseidonHashMany([toBigInt(poolAddress), toBigInt(chainId), toBigInt(assetAddress)]);
+}
+
+export function computeContext(withdrawal: Withdrawal, scope: BigNumberish) {
+  const numberArray = serializeWithdrawal(withdrawal).map(toBigInt);
+  const { low, high } = cairo.uint256(scope);
+  return poseidonHashMany([...numberArray, toBigInt(low), toBigInt(high)]);
+}
+
+export function rawKeyIntoSnarkJs(vkeyRaw: Uint8Array): SnarkJsVkey {
+  const vkeyString = (new TextDecoder("utf-8")).decode(vkeyRaw);
+  return JSON.parse(vkeyString);
+}
+
+export async function withdrawalProofToGaragaCalldata(withdrawalProof: WithdrawalProof, vkeyRaw: Uint8Array) {
+  const vkey = rawKeyIntoSnarkJs(vkeyRaw);
+  const vkeyGaraga = snarkJsKeyIntoGaraga(vkey);
+  const proofGaraga = snarkJsProofIntoGaraga(withdrawalProof.proof, withdrawalProof.publicSignals);
+  const calldata = await getGroth16CallData(proofGaraga, vkeyGaraga);
+  return calldata.slice(1);
+}
+
+export function castBigInt(x: number | bigint | Uint256) {
+  if (num.isBigNumberish(x)) {
+    return num.toBigInt(x);
+  } else {
+    return uint256.uint256ToBN(x);
+  }
+}
+
+export function anyToBigInt(value: BigNumberish | Uint256): bigint {
+  // If it's a Uint256 structure with low/high
+  if (value && typeof value === 'object' && 'low' in value && 'high' in value) {
+    return uint256.uint256ToBN(value);
+  }
+  return toBigInt(value);
+}