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

package/src/data.service.ts

@@ -1,46 +1,30 @@
-import {
-  DepositEvent,
-  Hash,
-  PoolInfo,
-  RagequitEvent,
-  WithdrawalEvent,
-} from "@0xbow/privacy-pools-core-sdk";
-import {
-  AbiParser2,
-  EmittedEvent,
-  EventFilter,
-  RpcProvider,
-  events,
-  hash,
-  num,
-} from "starknet";
+import { DepositEvent, Hash, PoolInfo, RagequitEvent, WithdrawalEvent } from "@0xbow/privacy-pools-core-sdk";
+import { AbiParser2, EventFilter, RPC, RpcProvider, events, hash, num } from "starknet";
 import { PrivacyPoolABI } from "./abis/PrivacyPool.abi.js";
-import {
-  SNBaseErrorCode,
-  SNDataError,
-  StarknetSDKError,
-} from "./errors/index.js";
+import { AuditEvent } from "./auditor.js";
+import { SNBaseErrorCode, SNDataError, StarknetSDKError } from "./errors/index.js";
+
+type StarknetEventChunk = RPC.RPCSPEC010.EVENTS_CHUNK;
+type StarknetEmittedEvent = RPC.RPCSPEC010.EmittedEvent;
 
 // Calculate event selectors using Starknet keccak
-export const DEPOSIT_EVENT_SELECTOR = num.toHex(
-  hash.starknetKeccak("Deposited")
-); // 0x69105484e3b5f553164aa6de1f67321ea2757275a5e614365c90b9ed0a5e9b
-export const WITHDRAWAL_EVENT_SELECTOR = num.toHex(
-  hash.starknetKeccak("Withdrawn")
-); // 0x36a4d15ab9e146faab90d4abc1c0cad17c4ded24551c781ba100392b5a70248
-export const RAGEQUIT_EVENT_SELECTOR = num.toHex(
-  hash.starknetKeccak("RageQuit")
-); // 0x2a2469e4569da9d3c3df9bc1a2ddece1e640a89b8ecd537da96f064d64c8183
+export const DEPOSIT_EVENT_SELECTOR = num.toHex(hash.starknetKeccak("Deposited")); // 0x69105484e3b5f553164aa6de1f67321ea2757275a5e614365c90b9ed0a5e9b
+export const WITHDRAWAL_EVENT_SELECTOR = num.toHex(hash.starknetKeccak("Withdrawn")); // 0x36a4d15ab9e146faab90d4abc1c0cad17c4ded24551c781ba100392b5a70248
+export const RAGEQUIT_EVENT_SELECTOR = num.toHex(hash.starknetKeccak("RageQuit")); // 0x2a2469e4569da9d3c3df9bc1a2ddece1e640a89b8ecd537da96f064d64c8183
+
+export const AUDIT_EVENT_SELECTOR = num.toHex(hash.starknetKeccak("AuditEvent"));
 
 // ABI event names for direct selection
 export const DEPOSIT_EVENT_ABI_NAME = "privacy_pools::interfaces::IPool::Deposited";
 export const WITHDRAWAL_EVENT_ABI_NAME = "privacy_pools::interfaces::IPool::Withdrawn";
 export const RAGEQUIT_EVENT_ABI_NAME = "privacy_pools::interfaces::IPool::RageQuit";
+export const AUDIT_EVENT_ABI_NAME = "privacy_pools::interfaces::IPool::AuditEvent";
 
 export const AbiEventName = {
   Deposit: DEPOSIT_EVENT_ABI_NAME,
   Withdraw: WITHDRAWAL_EVENT_ABI_NAME,
   Ragequit: RAGEQUIT_EVENT_ABI_NAME,
+  Audit: AUDIT_EVENT_ABI_NAME,
 } as const;
 
 type AbiEventName = (typeof AbiEventName)[keyof typeof AbiEventName];
@@ -59,6 +43,7 @@ export interface StarknetWithdrawnEventData {
   newCommitmentHash: bigint;
   withdrawnValue: bigint;
   existingNullifierHash: bigint;
+  auditorData: string;
 }
 
 export interface StarknetRageQuitEventData {
@@ -68,15 +53,24 @@ export interface StarknetRageQuitEventData {
   value: bigint;
 }
 
+export interface StarknetAuditEventData {
+  tag: bigint;
+  ciphertext: string;
+  prevNullifierHash: bigint;
+  newCommitment: bigint;
+}
+
 type AbiToEvent = {
   [AbiEventName.Deposit]: StarknetDepositedEventData;
   [AbiEventName.Withdraw]: StarknetWithdrawnEventData;
   [AbiEventName.Ragequit]: StarknetRageQuitEventData;
+  [AbiEventName.Audit]: StarknetAuditEventData;
 };
 
 export type StarknetEvent =
   | StarknetDepositedEventData
   | StarknetWithdrawnEventData
+  | StarknetAuditEventData
   | StarknetRageQuitEventData;
 
 /**
@@ -101,12 +95,12 @@ export class StarknetDataService {
   }
 
   private async getEvents(eventFilter: EventFilter) {
-    let { continuation_token, events } = await this.provider.getEvents(
-      eventFilter
-    );
+    let { continuation_token, events } = (await this.provider.getEvents(eventFilter)) as StarknetEventChunk;
     while (continuation_token) {
-      const { continuation_token: newToken, events: newEvents } =
-        await this.provider.getEvents({ ...eventFilter, continuation_token });
+      const { continuation_token: newToken, events: newEvents } = (await this.provider.getEvents({
+        ...eventFilter,
+        continuation_token,
+      })) as StarknetEventChunk;
       events = [...events, ...newEvents];
       continuation_token = newToken;
     }
@@ -121,58 +115,45 @@ export class StarknetDataService {
    * @returns Array of deposit events compatible with AccountService interface
    * @throws {StarknetSDKError} If provider is not configured or network error occurs
    */
-  async getDeposits(
-    pool: PoolInfo,
-    fromBlock: bigint = pool.deploymentBlock
-  ): Promise<DepositEvent[]> {
+  async getDeposits(pool: PoolInfo, fromBlock: bigint = pool.deploymentBlock, label?: bigint): Promise<DepositEvent[]> {
     try {
+      const keys = label ? [[DEPOSIT_EVENT_SELECTOR], [], [String(label)]] : [[DEPOSIT_EVENT_SELECTOR]];
       // Fetch events using Starknet provider
       const eventsResult = await this.getEvents({
         from_block: { block_number: Number(fromBlock) },
         to_block: "latest",
         address: pool.address,
-        keys: [[DEPOSIT_EVENT_SELECTOR]], // Filter by deposit event selector
+        keys, // Filter by deposit event selector
         chunk_size: 1000, // Starknet pagination
       });
 
       // Parse all events at once using starknet.js event parser
       const abiEvents = events.getAbiEvents(PrivacyPoolABI);
-      const parsedEvents = events.parseEvents(
-        eventsResult,
-        abiEvents,
-        {},
-        {},
-        this.abiParser
-      );
+      const parsedEvents = events.parseEvents(eventsResult, abiEvents, {}, {}, this.abiParser);
 
       return parsedEvents
-        .filter(
-          (parsedEvent) => parsedEvent[DEPOSIT_EVENT_ABI_NAME] !== undefined
-        )
+        .filter((parsedEvent) => parsedEvent[DEPOSIT_EVENT_ABI_NAME] !== undefined)
         .map((parsedEvent) => ({
-          eventData: parsedEvent[
-            DEPOSIT_EVENT_ABI_NAME
-          ] as unknown as StarknetDepositedEventData,
+          eventData: parsedEvent[DEPOSIT_EVENT_ABI_NAME] as unknown as StarknetDepositedEventData,
           blockNumber: parsedEvent.block_number,
           transactionHash: parsedEvent.transaction_hash,
         }))
         .map(
           ({ eventData, blockNumber, transactionHash }) =>
-          ({
-            depositor: num.toHex(eventData.depositor),
-            commitment: eventData.commitment as Hash,
-            label: eventData.label as Hash,
-            value: eventData.value,
-            precommitment: eventData.preCommitmentHash as Hash,
-            blockNumber: BigInt(blockNumber || 0),
-            transactionHash: transactionHash || "0x0",
-          } as DepositEvent)
+            ({
+              depositor: num.toHex(eventData.depositor),
+              commitment: eventData.commitment as Hash,
+              label: eventData.label as Hash,
+              value: eventData.value,
+              precommitment: eventData.preCommitmentHash as Hash,
+              blockNumber: BigInt(blockNumber || 0),
+              transactionHash: transactionHash || "0x0",
+            }) as DepositEvent
         );
     } catch (error) {
       if (error instanceof StarknetSDKError) throw error;
       throw new StarknetSDKError(
-        `Failed to fetch deposits: ${error instanceof Error ? error.message : "Unknown error"
-        }`,
+        `Failed to fetch deposits: ${error instanceof Error ? error.message : "Unknown error"}`,
         SNBaseErrorCode.UNKNOWN
       );
     }
@@ -186,10 +167,7 @@ export class StarknetDataService {
    * @returns Array of withdrawal events compatible with AccountService interface
    * @throws {StarknetSDKError} If provider is not configured or network error occurs
    */
-  async getWithdrawals(
-    pool: PoolInfo,
-    fromBlock: bigint = pool.deploymentBlock
-  ): Promise<WithdrawalEvent[]> {
+  async getWithdrawals(pool: PoolInfo, fromBlock: bigint = pool.deploymentBlock): Promise<WithdrawalEvent[]> {
     try {
       const eventsResult = await this.getEvents({
         from_block: { block_number: Number(fromBlock) },
@@ -201,40 +179,29 @@ export class StarknetDataService {
 
       // Parse all events at once using starknet.js event parser
       const abiEvents = events.getAbiEvents(PrivacyPoolABI);
-      const parsedEvents = events.parseEvents(
-        eventsResult,
-        abiEvents,
-        {},
-        {},
-        this.abiParser
-      );
+      const parsedEvents = events.parseEvents(eventsResult, abiEvents, {}, {}, this.abiParser);
 
       return parsedEvents
-        .filter(
-          (parsedEvent) => parsedEvent[WITHDRAWAL_EVENT_ABI_NAME] !== undefined
-        )
+        .filter((parsedEvent) => parsedEvent[WITHDRAWAL_EVENT_ABI_NAME] !== undefined)
         .map((parsedEvent) => ({
-          eventData: parsedEvent[
-            WITHDRAWAL_EVENT_ABI_NAME
-          ] as unknown as StarknetWithdrawnEventData,
+          eventData: parsedEvent[WITHDRAWAL_EVENT_ABI_NAME] as unknown as StarknetWithdrawnEventData,
           blockNumber: parsedEvent.block_number,
           transactionHash: parsedEvent.transaction_hash,
         }))
         .map(
           ({ eventData, blockNumber, transactionHash }) =>
-          ({
-            withdrawn: eventData.withdrawnValue,
-            spentNullifier: eventData.existingNullifierHash as Hash,
-            newCommitment: eventData.newCommitmentHash as Hash,
-            blockNumber: BigInt(blockNumber || 0),
-            transactionHash: transactionHash || "0x0",
-          } as WithdrawalEvent)
+            ({
+              withdrawn: eventData.withdrawnValue,
+              spentNullifier: eventData.existingNullifierHash as Hash,
+              newCommitment: eventData.newCommitmentHash as Hash,
+              blockNumber: BigInt(blockNumber || 0),
+              transactionHash: transactionHash || "0x0",
+            }) as WithdrawalEvent
         );
     } catch (error) {
       if (error instanceof StarknetSDKError) throw error;
       throw new StarknetSDKError(
-        `Failed to fetch withdrawals: ${error instanceof Error ? error.message : "Unknown error"
-        }`,
+        `Failed to fetch withdrawals: ${error instanceof Error ? error.message : "Unknown error"}`,
         SNBaseErrorCode.UNKNOWN
       );
     }
@@ -248,10 +215,7 @@ export class StarknetDataService {
    * @returns Array of ragequit events compatible with AccountService interface
    * @throws {StarknetSDKError} If provider is not configured or network error occurs
    */
-  async getRagequits(
-    pool: PoolInfo,
-    fromBlock: bigint = pool.deploymentBlock
-  ): Promise<RagequitEvent[]> {
+  async getRagequits(pool: PoolInfo, fromBlock: bigint = pool.deploymentBlock): Promise<RagequitEvent[]> {
     try {
       const eventsResult = await this.getEvents({
         from_block: { block_number: Number(fromBlock) },
@@ -263,41 +227,71 @@ export class StarknetDataService {
 
       // Parse all events at once using starknet.js event parser
       const abiEvents = events.getAbiEvents(PrivacyPoolABI);
-      const parsedEvents = events.parseEvents(
-        eventsResult,
-        abiEvents,
-        {},
-        {},
-        this.abiParser
+      const parsedEvents = events.parseEvents(eventsResult, abiEvents, {}, {}, this.abiParser);
+
+      return parsedEvents
+        .filter((parsedEvent) => parsedEvent[RAGEQUIT_EVENT_ABI_NAME] !== undefined)
+        .map((parsedEvent) => ({
+          eventData: parsedEvent[RAGEQUIT_EVENT_ABI_NAME] as unknown as StarknetRageQuitEventData,
+          blockNumber: parsedEvent.block_number,
+          transactionHash: parsedEvent.transaction_hash,
+        }))
+        .map(
+          ({ eventData, blockNumber, transactionHash }) =>
+            ({
+              ragequitter: num.toHex(eventData.depositor),
+              commitment: eventData.commitment as Hash,
+              label: eventData.label as Hash,
+              value: eventData.value,
+              blockNumber: BigInt(blockNumber || 0),
+              transactionHash: transactionHash || "0x0",
+            }) as RagequitEvent
+        );
+    } catch (error) {
+      if (error instanceof StarknetSDKError) throw error;
+      throw new StarknetSDKError(
+        `Failed to fetch ragequits: ${error instanceof Error ? error.message : "Unknown error"}`,
+        SNBaseErrorCode.UNKNOWN
       );
+    }
+  }
+
+  async getAuditEventForTag(tag: bigint, pool: PoolInfo, fromBlock: bigint = pool.deploymentBlock) {
+    try {
+      const eventsResult = await this.getEvents({
+        from_block: { block_number: Number(fromBlock) },
+        to_block: "latest",
+        address: pool.address,
+        keys: [[AUDIT_EVENT_SELECTOR], [String(tag)]],
+        chunk_size: 1000,
+      });
+
+      // Parse all events at once using starknet.js event parser
+      const abiEvents = events.getAbiEvents(PrivacyPoolABI);
+      const parsedEvents = events.parseEvents(eventsResult, abiEvents, {}, {}, this.abiParser);
 
       return parsedEvents
-        .filter(
-          (parsedEvent) => parsedEvent[RAGEQUIT_EVENT_ABI_NAME] !== undefined
-        )
+        .filter((parsedEvent) => parsedEvent[AUDIT_EVENT_ABI_NAME] !== undefined)
         .map((parsedEvent) => ({
-          eventData: parsedEvent[
-            RAGEQUIT_EVENT_ABI_NAME
-          ] as unknown as StarknetRageQuitEventData,
+          eventData: parsedEvent[AUDIT_EVENT_ABI_NAME] as unknown as StarknetAuditEventData,
           blockNumber: parsedEvent.block_number,
           transactionHash: parsedEvent.transaction_hash,
         }))
         .map(
           ({ eventData, blockNumber, transactionHash }) =>
-          ({
-            ragequitter: num.toHex(eventData.depositor),
-            commitment: eventData.commitment as Hash,
-            label: eventData.label as Hash,
-            value: eventData.value,
-            blockNumber: BigInt(blockNumber || 0),
-            transactionHash: transactionHash || "0x0",
-          } as RagequitEvent)
+            ({
+              tag: eventData.tag as Hash,
+              ciphertext: eventData.ciphertext,
+              prevNullifierHash: eventData.prevNullifierHash as Hash,
+              newCommitment: eventData.newCommitment as Hash,
+              blockNumber: BigInt(blockNumber || 0),
+              transactionHash: transactionHash || "0x0",
+            }) as AuditEvent
         );
     } catch (error) {
       if (error instanceof StarknetSDKError) throw error;
       throw new StarknetSDKError(
-        `Failed to fetch ragequits: ${error instanceof Error ? error.message : "Unknown error"
-        }`,
+        `Failed to fetch ragequits: ${error instanceof Error ? error.message : "Unknown error"}`,
         SNBaseErrorCode.UNKNOWN
       );
     }
@@ -305,14 +299,12 @@ export class StarknetDataService {
 
   private static parseGenericEvents<K extends AbiEventName>(
     abiEventName: K,
-    emittedEvents: EmittedEvent[],
+    emittedEvents: StarknetEmittedEvent[],
     pool: PoolInfo
   ) {
     const poolAbiEvents = events.getAbiEvents(PrivacyPoolABI);
     const parsedEvents = events.parseEvents(
-      emittedEvents.filter(
-        (e) => num.toBigInt(e.from_address) === num.toBigInt(pool.address)
-      ),
+      emittedEvents.filter((e) => num.toBigInt(e.from_address) === num.toBigInt(pool.address)),
       poolAbiEvents,
       {},
       {},
@@ -330,28 +322,16 @@ export class StarknetDataService {
       });
   }
 
-  static parseDepositEvents(emittedEvents: EmittedEvent[], pool: PoolInfo) {
-    return StarknetDataService.parseGenericEvents(
-      AbiEventName.Deposit,
-      emittedEvents,
-      pool
-    );
+  static parseDepositEvents(emittedEvents: StarknetEmittedEvent[], pool: PoolInfo) {
+    return StarknetDataService.parseGenericEvents(AbiEventName.Deposit, emittedEvents, pool);
   }
 
-  static parseWithdrawalEvents(emittedEvents: EmittedEvent[], pool: PoolInfo) {
-    return StarknetDataService.parseGenericEvents(
-      AbiEventName.Withdraw,
-      emittedEvents,
-      pool
-    );
+  static parseWithdrawalEvents(emittedEvents: StarknetEmittedEvent[], pool: PoolInfo) {
+    return StarknetDataService.parseGenericEvents(AbiEventName.Withdraw, emittedEvents, pool);
   }
 
-  static parseRagequitEvents(emittedEvents: EmittedEvent[], pool: PoolInfo) {
-    return StarknetDataService.parseGenericEvents(
-      AbiEventName.Ragequit,
-      emittedEvents,
-      pool
-    );
+  static parseRagequitEvents(emittedEvents: StarknetEmittedEvent[], pool: PoolInfo) {
+    return StarknetDataService.parseGenericEvents(AbiEventName.Ragequit, emittedEvents, pool);
   }
 
   async getTxEvents<K extends AbiEventName>(
@@ -360,21 +340,18 @@ export class StarknetDataService {
     pool: PoolInfo
   ): Promise<AbiToEvent[K][]> {
     const receipt = await this.provider.getTransactionReceipt(transactionHash);
-    if (!receipt.isSuccess())
-      throw SNDataError.noEventsToParse("Tx was not succesful");
+    if (!receipt.isSuccess()) throw SNDataError.noEventsToParse("Tx was not succesful");
 
-    const emmitedEvents: EmittedEvent[] = receipt.value.events.map((e) => {
+    const emmitedEvents: StarknetEmittedEvent[] = receipt.value.events.map((e, event_index) => {
       return {
         ...e,
         block_hash: receipt.value.block_hash,
         block_number: receipt.value.block_number,
         transaction_hash: transactionHash,
+        event_index,
+        transaction_index: 0,
       };
     });
-    return StarknetDataService.parseGenericEvents<K>(
-      abiEventName,
-      emmitedEvents,
-      pool
-    );
+    return StarknetDataService.parseGenericEvents<K>(abiEventName, emmitedEvents, pool);
   }
 }

package/src/errors/contracts.errors.ts

@@ -1,10 +1,10 @@
 /**
  * Mapping of hexadecimal error codes to human-readable error messages.
- * 
+ *
  * These error codes correspond to custom errors thrown by Privacy Pool smart contracts
  * on Starknet. The hex codes are the encoded error messages that appear in transaction
  * failure reasons.
- * 
+ *
  * @constant
  */
 export const CONTRACT_ERROR_CODES = {
@@ -31,19 +31,19 @@ export const CONTRACT_ERROR_CODES = {
   "0x506f6f6c206e6f742072656769737465726564": "Pool not registered",
   "0x507265636f6d6d69746d656e742075736564": "Precommitment used",
   "0x72656c617965722066656520544f2048494748": "relayer fee TO HIGH",
-  "0x56616c7565206c6573732074686174206d696e696d756d": "Value less that minimum"
+  "0x56616c7565206c6573732074686174206d696e696d756d": "Value less that minimum",
 } as const;
 
 /**
  * Parses a contract error string to extract a human-readable error message.
- * 
+ *
  * This function searches through the error string for known hexadecimal error codes
  * and returns the corresponding human-readable description. This is useful for
  * providing better error messages to users when transactions fail.
- * 
+ *
  * @param errorString - The error string from a failed transaction
  * @returns The human-readable error message if found, null otherwise
- * 
+ *
  * @example
  * ```typescript
  * const error = "execution failed with error: 0x496e76616c69642050726f6f66";

package/src/errors/index.ts

@@ -1,32 +1,30 @@
-
 /** Base error codes for fundamental SDK errors */
 export enum SNBaseErrorCode {
   UNKNOWN,
   UNREACHABLE,
-  INTERNAL
+  INTERNAL,
 }
 
 /** Error codes specific to privacy pool validation */
 export enum SNPoolErrorCode {
-  AMOUNT_TOO_SMALL
+  AMOUNT_TOO_SMALL,
 }
 
 /** Error codes for contract interaction failures */
 export enum SNContractErrorCode {
   DEPOSIT_FAILED,
   INVALID_IPFS_CID,
-  REVERT
+  REVERT,
 }
 
 /** Error codes for data format and conversion issues */
 export enum SNFormatErrorCode {
   CONVERSION,
-  PARSE
+  PARSE,
 }
 
-
 export enum SNDataErrorCode {
-  NO_EVENTS
+  NO_EVENTS,
 }
 
 /** Union type of all possible error codes in the Starknet SDK */
@@ -34,22 +32,24 @@ export type SNErrorCode = SNBaseErrorCode | SNPoolErrorCode | SNContractErrorCod
 
 /**
  * Base error class for all Starknet SDK errors.
- * 
+ *
  * This class extends the standard Error class and provides additional context
  * through error codes. All SDK-specific errors should inherit from this class.
  */
 export class StarknetSDKError extends Error {
-
   override readonly name: string;
   override message: string;
 
   /**
    * Creates a new StarknetSDKError.
-   * 
+   *
    * @param message - The error message
    * @param code - The specific error code for categorization
    */
-  constructor(message: string, readonly code: SNErrorCode) {
+  constructor(
+    message: string,
+    readonly code: SNErrorCode
+  ) {
     super();
     this.message = message;
     this.name = this.constructor.name;
@@ -80,17 +80,15 @@ export class StarknetSDKError extends Error {
   public static internal(msg?: string) {
     return new this(msg || "Internal error", SNBaseErrorCode.INTERNAL);
   }
-
 }
 
 /**
  * Error class for data format and conversion issues.
- * 
+ *
  * This error is thrown when data conversion operations fail, such as
  * converting between different proof formats or parsing verification keys.
  */
 export class SNFormatError extends StarknetSDKError {
-
   /**
    * Creates a conversion error instance.
    * @param context - Optional context about what conversion failed
@@ -110,17 +108,15 @@ export class SNFormatError extends StarknetSDKError {
     const _context = context || "Parse failed";
     return new this(_context, SNFormatErrorCode.PARSE);
   }
-
 }
 
 /**
  * Error class for privacy pool validation failures.
- * 
+ *
  * This error is thrown when privacy pool operations fail validation,
  * such as insufficient deposit amounts or invalid pool parameters.
  */
 export class SNPoolError extends StarknetSDKError {
-
   /**
    * Creates an error for deposit amounts that are too small.
    * @param context - Optional context about the minimum amount requirement
@@ -130,17 +126,15 @@ export class SNPoolError extends StarknetSDKError {
     const _context = context || "Amount is less than expected by pool";
     return new this(_context, SNPoolErrorCode.AMOUNT_TOO_SMALL);
   }
-
 }
 
 /**
  * Error class for smart contract interaction failures.
- * 
+ *
  * This error is thrown when contract calls fail or return unexpected results,
  * including transaction reverts and invalid parameters.
  */
 export class SNContractError extends StarknetSDKError {
-
   /**
    * Creates an error for failed deposit operations.
    * @returns SNContractError with DEPOSIT_FAILED code
@@ -155,7 +149,10 @@ export class SNContractError extends StarknetSDKError {
    * @returns SNContractError with INVALID_IPFS_CID code
    */
   public static invalidIPFSsize(ipfsCID: string) {
-    return new this(`Invalid IPFS CID size: expected >32 & <64, got ${ipfsCID.length}`, SNContractErrorCode.INVALID_IPFS_CID);
+    return new this(
+      `Invalid IPFS CID size: expected >32 & <64, got ${ipfsCID.length}`,
+      SNContractErrorCode.INVALID_IPFS_CID
+    );
   }
 
   /**
@@ -166,11 +163,9 @@ export class SNContractError extends StarknetSDKError {
   public static revert(reason: string) {
     return new this(reason, SNContractErrorCode.REVERT);
   }
-
 }
 
 export class SNDataError extends StarknetSDKError {
-
   /**
    * Creates a conversion error instance.
    * @param context - Optional context about what conversion failed
@@ -180,5 +175,4 @@ export class SNDataError extends StarknetSDKError {
     const _context = context || "Tx may be incomplete";
     return new this(_context, SNDataErrorCode.NO_EVENTS);
   }
-
 }

package/src/garaga.ts

@@ -1,17 +1,23 @@
 import { Groth16VerifyingKey, Groth16Proof } from "./types/garaga.js";
 import * as garaga from "garaga";
 
-let _initialized = false;
-garaga.init().then(() => _initialized = true);
+let _initialized: boolean = false;
+let _error: null | Error = null;
+garaga.init()
+  .then(() => _initialized = true)
+  .catch((e: Error) => _error = e);
 
 function sleep(ms: number) {
-  return new Promise(res => setTimeout(res, ms));
+  return new Promise((res) => setTimeout(res, ms));
 }
 
 async function _waitUntilReady() {
-  while (!_initialized) {
+  while ((!_initialized) && (_error === null)) {
     await sleep(100);
   }
+  if (_error !== null) {
+    throw _error;
+  }
 }
 
 export async function getGroth16CallData(proof: Groth16Proof, verifyingKey: Groth16VerifyingKey) {