@fatsolutions/privacy-pools-core-starknet-sdk 0.0.43 → 0.0.45

package/src/utils.ts

@@ -1,6 +1,15 @@
 import { WithdrawalProof } from "@0xbow/privacy-pools-core-sdk";
 import { poseidonHashMany } from "@scure/starknet";
-import { BigNumberish, cairo, num, uint256, Uint256, validateAndParseAddress, validateChecksumAddress } from "starknet";
+import {
+  BigNumberish,
+  cairo,
+  CairoOption,
+  CairoOptionVariant,
+  num,
+  uint256,
+  Uint256,
+  validateAndParseAddress
+} from "starknet";
 
 import { getGroth16CallData } from "./garaga.js";
 import { snarkJsKeyIntoGaraga, snarkJsProofIntoGaraga } from "./types/conversions.js";
@@ -11,11 +20,11 @@ const { toBigInt } = num;
 
 /**
  * Computes a unique scope identifier for a privacy pool.
- * 
+ *
  * The scope is calculated using Poseidon hash of the pool address, chain ID, and asset address.
  * This creates a unique identifier that can be used to distinguish different privacy pools
  * across different chains and assets.
- * 
+ *
  * @param poolAddress - The address of the privacy pool contract
  * @param chainId - The chain ID where the pool is deployed
  * @param assetAddress - The address of the asset (token) used in the pool
@@ -27,11 +36,11 @@ export function computeScope(poolAddress: BigNumberish, chainId: BigNumberish, a
 
 /**
  * Computes a context hash for withdrawal transactions.
- * 
+ *
  * The context combines the serialized withdrawal data with the scope to create
  * a unique identifier for the withdrawal context. This is used in privacy pool
  * operations to ensure proper transaction validation.
- * 
+ *
  * @param withdrawal - The withdrawal data to include in the context
  * @param scope - The scope identifier of the privacy pool
  * @returns The computed context as a Poseidon hash
@@ -44,23 +53,23 @@ export function computeContext(withdrawal: Withdrawal, scope: BigNumberish) {
 
 /**
  * Parses a raw verification key from Uint8Array to SnarkJS format.
- * 
+ *
  * @param vkeyRaw - The raw verification key as bytes
  * @returns The parsed verification key in SnarkJS format
  * @throws {Error} If the raw key cannot be parsed as valid JSON
  */
 export function rawKeyIntoSnarkJs(vkeyRaw: Uint8Array): SnarkJsVkey {
-  const vkeyString = (new TextDecoder("utf-8")).decode(vkeyRaw);
-  return JSON.parse(vkeyString);
+  const vkeyString = new TextDecoder("utf-8").decode(vkeyRaw);
+  return JSON.parse(vkeyString) as SnarkJsVkey;
 }
 
 /**
  * Converts a withdrawal proof to Garaga-compatible calldata format.
- * 
+ *
  * This function takes a withdrawal proof and verification key, converts them
  * to Garaga format, and generates the calldata needed for Starknet contract calls.
  * The resulting calldata can be used directly with Garaga's Groth16 verifier.
- * 
+ *
  * @param withdrawalProof - The withdrawal proof from the core SDK
  * @param vkeyRaw - The raw verification key as bytes
  * @returns Promise resolving to calldata array (excluding the first element)
@@ -76,14 +85,14 @@ export async function withdrawalProofToGaragaCalldata(withdrawalProof: Withdrawa
 
 /**
  * Safely converts various numeric types to BigInt.
- * 
+ *
  * This utility handles the conversion of different Starknet numeric types
  * (including Uint256 structs) to standard BigInt values.
- * 
+ *
  * @param x - The value to convert (number, bigint, or Uint256)
  * @returns The value as a BigInt
  */
-export function castBigInt(x: number | bigint | Uint256) {
+export function castBigInt(x: number | bigint | Uint256 | BigNumberish) {
   if (num.isBigNumberish(x)) {
     return num.toBigInt(x);
   } else {
@@ -94,3 +103,15 @@ export function castBigInt(x: number | bigint | Uint256) {
 export function toAddress(x: BigNumberish): StarknetAddress {
   return validateAndParseAddress(x) as StarknetAddress;
 }
+
+export const Some = <T>(t: T): CairoOption<T> => {
+  return new CairoOption<T>(CairoOptionVariant.Some, t);
+};
+
+export const None = <T>(): CairoOption<T> => {
+  return new CairoOption<T>(CairoOptionVariant.None);
+};
+
+export const toCairoOption = <T>(t?: T): CairoOption<T> => {
+  return t === undefined ? None() : Some(t);
+};