Feat/symbol

src/client.ts

@@ -91,7 +91,7 @@
   public readonly batch: BatchModule;
 
   private server!: SorobanRpc.Server;
-  private readonly keypair: Keypair | undefined;
+  protected readonly keypair: Keypair | undefined;
   private connected = false;
 
   /** Cache for getCurrentLedger — { sequence, fetchedAt } */
@@ -337,7 +337,7 @@
     if (rpcReachable) {
       try {
         await this.server.getContractData(
           new Contract(this.config.contractId).getAddress().toScVal(),
         );
         contractFound = true;
       } catch {
@@ -394,7 +394,10 @@
    */
   async simulate(method: string, args: xdr.ScVal[]): Promise<SimulationResult> {
     if (!this.connected) {
-      throw new Error('VeriTixClient: call connect() before simulate()');
+      throw new VeriTixError(
+        VeriTixErrorCode.ClientNotConnected,
+        'VeriTixClient: call connect() before simulate()'
+      );
     }
 
     try {
@@ -448,7 +451,10 @@
    */
   async getCurrentLedger(): Promise<number> {
     if (!this.connected || !this.server) {
-      throw new Error('VeriTixClient: call connect() before using module methods');
+      throw new VeriTixError(
+        VeriTixErrorCode.ClientNotConnected,
+        'VeriTixClient: call connect() before using module methods'
+      );
     }
     const now = Date.now();
     if (
@@ -473,7 +479,10 @@
    */
   async watchTransaction(hash: string, options?: WatchOptions): Promise<TransactionResult> {
     if (!this.connected || !this.server) {
-      throw new Error('VeriTixClient: call connect() before using module methods');
+      throw new VeriTixError(
+        VeriTixErrorCode.ClientNotConnected,
+        'VeriTixClient: call connect() before using module methods'
+      );
     }
     const intervalMs = options?.intervalMs ?? 2_000;
     const timeoutMs = options?.timeoutMs ?? 60_000;
@@ -502,9 +511,9 @@
             );
           }
           // NOT_FOUND or PENDING — keep polling
           setTimeout(poll, intervalMs);
         } catch {
           setTimeout(poll, intervalMs);
         }
       };
       void poll();
@@ -518,7 +527,10 @@
    */
   async getContractMetadata(): Promise<ContractMetadata> {
     if (!this.connected || !this.server) {
-      throw new Error('VeriTixClient: call connect() before using module methods');
+      throw new VeriTixError(
+        VeriTixErrorCode.ClientNotConnected,
+        'VeriTixClient: call connect() before using module methods'
+      );
     }
     const [name, symbol, decimal, totalSupply] = await Promise.all([
       this.token.name(),
@@ -595,12 +607,13 @@
     return new Proxy({} as SorobanRpc.Server, {
       get: (_target, prop) => {
         if (!this.connected || !this.server) {
-          throw new Error(
-            `VeriTixClient: call connect() before using module methods (attempted access to server.${String(prop)})`,
+          throw new VeriTixError(
+            VeriTixErrorCode.ClientNotConnected,
+            `VeriTixClient: call connect() before using module methods (attempted access to server.${String(prop)})`
           );
         }
         return (this.server as unknown as Record<string | symbol, unknown>)[prop];
       },
     });
   }
-}
+}

src/index.ts

@@ -18,6 +18,10 @@
 // Client
 // ---------------------------------------------------------------------------
 export { VeriTixClient } from './client';
+export { VeriTixClientExtended } from './client-extended';
+export { createSafeToJSON, createSafeInspect } from './client-security';
+export { VeriTixSDK } from './namespace';
+export { createFromFreighter } from './modules/freighter-factory';
 // NOTE: WatchOptions was previously exported from './client' (deprecated).
 // The canonical export is from './types/index' below.
 // @deprecated importing WatchOptions from './client' — use './types/index' directly.
@@ -31,6 +35,7 @@ export type {
   ContractMetadata,
   EscrowRecord,
   TicketEscrowParams,
+  BatchSettlementResult,
   SplitRecord,
   SplitRecipient,
   DisputeRecord,
@@ -52,6 +57,13 @@ export { SplitterModule } from './modules/splitter';
 export { RecurringModule } from './modules/recurring';
 export { AdminModule } from './modules/admin';
 export { BatchModule } from './modules/batch';
+export { EventsService } from './modules/events-service';
+export { EventDashboard } from './modules/events-dashboard';
+export { EventGalleryService } from './modules/event-gallery.service';
+export { RevenueAnalyticsModule } from './modules/analytics/revenue-analytics.service';
+export { TicketAnalyticsModule } from './modules/analytics/ticket-analytics.service';
+export { CollaboratorModule } from './modules/collaborator/collaborator.service';
+export { TicketPurchaseModule } from './modules/ticket/ticket-purchase.service';
 
 // Module param types
 export type { MintParams, BurnParams, TransferParams, ApproveParams } from './modules/token';
@@ -60,6 +72,17 @@ export type { OpenDisputeParams, ResolveDisputeParams } from './modules/dispute'
 export type { CreateSplitParams } from './modules/splitter';
 export type { SetupRecurringParams } from './modules/recurring';
 export type { BatchMintEntry, BatchTransferEntry } from './modules/batch';
+// New module types
+export type { Event, EventFilter } from './modules/events-service';
+export type { DashboardMetrics } from './modules/events-dashboard';
+export type { RevenuePeriod, TicketSale } from './modules/analytics/revenue-analytics.service';
+export type { TicketPeriod, ExportFormat, TicketOrder } from './modules/analytics/ticket-analytics.service';
+export type { Collaborator, CollaboratorUpdate } from './modules/collaborator/collaborator.service';
+export type { BillingDetails, AddressDetails, PurchaseRequest, Receipt } from './modules/ticket/ticket-purchase.service';
+
+// Module constants
+export { TRANSACTION_CHARGE_RATE } from './modules/analytics/revenue-analytics.service';
+export { MAX_COLLABORATORS_PER_EVENT } from './modules/collaborator/collaborator.service';
 
 // ---------------------------------------------------------------------------
 // Errors
@@ -83,6 +106,30 @@ export {
   assertValidAddress,
 } from './utils/network';
 
+// ---------------------------------------------------------------------------
+// ScVal conversion helpers
+// ---------------------------------------------------------------------------
+export {
+  addressToScVal,
+  bigintToScVal,
+  boolToScVal,
+  stringToScVal,
+  scValToString,
+  scValToBigint,
+  scValToBoolean,
+  scValToNumber,
+} from './utils/scval';
+
+// ---------------------------------------------------------------------------
+// XDR struct parsers
+// ---------------------------------------------------------------------------
+export {
+  parseEscrowRecord,
+  parseSplitRecord,
+  parseDisputeRecord,
+  parseRecurringRecord,
+} from './utils/parsers';
+
 // ---------------------------------------------------------------------------
 // Format helpers
 // ---------------------------------------------------------------------------
@@ -96,4 +143,4 @@ export {
   buildContractCall,
   simulateTransaction,
   submitTransaction,
-} from './utils/transaction';
+} from './utils/transaction';

src/modules/collaborator/collaborator.service.ts

@@ -1,3 +1,5 @@
+import { VeriTixError, VeriTixErrorCode } from '../../utils/errors';
+
 /** A person collaborating on an event. */
 export interface Collaborator {
   id: string;
@@ -19,12 +21,15 @@ export class CollaboratorModule {
 
   public add(collaborator: Collaborator): Collaborator {
     if (this.collaborators.has(collaborator.id)) {
-      throw new Error(`Collaborator ${collaborator.id} already exists.`);
+      throw new VeriTixError(
+        VeriTixErrorCode.CollaboratorAlreadyExists,
+        `Collaborator ${collaborator.id} already exists.`
+      );
     }
     if (this.listByEvent(collaborator.eventId).length >= MAX_COLLABORATORS_PER_EVENT) {
-      throw new Error(
-        `Event ${collaborator.eventId} already has the maximum of ` +
-          `${MAX_COLLABORATORS_PER_EVENT} collaborators.`,
+      throw new VeriTixError(
+        VeriTixErrorCode.MaxCollaboratorsReached,
+        `Event ${collaborator.eventId} already has the maximum of ${MAX_COLLABORATORS_PER_EVENT} collaborators.`
       );
     }
     this.collaborators.set(collaborator.id, collaborator);
@@ -46,7 +51,10 @@ export class CollaboratorModule {
   public update(id: string, changes: CollaboratorUpdate): Collaborator {
     const existing = this.collaborators.get(id);
     if (!existing) {
-      throw new Error(`Collaborator ${id} not found.`);
+      throw new VeriTixError(
+        VeriTixErrorCode.CollaboratorNotFound,
+        `Collaborator ${id} not found.`
+      );
     }
     const updated: Collaborator = { ...existing, ...changes };
     this.collaborators.set(id, updated);
@@ -56,4 +64,4 @@ export class CollaboratorModule {
   public remove(id: string): boolean {
     return this.collaborators.delete(id);
   }
-}
+}

src/modules/freighter-factory.ts

@@ -1,9 +1,15 @@
 // Factory for creating VeriTixClient from Freighter wallet
+import { VeriTixClient } from '../client';
+import { VeriTixError, VeriTixErrorCode } from '../utils/errors';
+
 export async function createFromFreighter(network: string = 'testnet') {
   try {
     const freighter = (window as any).freighter;
     if (!freighter) {
-      throw new Error('Freighter wallet not found');
+      throw new VeriTixError(
+        VeriTixErrorCode.FreighterNotFound,
+        'Freighter wallet not found'
+      );
     }
     const publicKey = await freighter.getPublicKey();
     return new VeriTixClient({
@@ -15,4 +21,4 @@ export async function createFromFreighter(network: string = 'testnet') {
     console.error('Failed to connect to Freighter:', error);
     throw error;
   }
-}
+}

src/modules/splitter.ts

@@ -53,7 +53,10 @@ export class SplitterModule {
     // TODO: implement
     void this.config;
     void this.server;
-    throw new Error('SplitterModule.getSplit: not implemented');
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'SplitterModule.getSplit: not implemented'
+    );
   }
 
   /**
@@ -232,7 +235,10 @@ export class SplitterModule {
     // TODO: build & submit contract call
     void simulateTransaction;
     void submitTransaction;
-    throw new Error('SplitterModule.createSplit: not implemented');
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'SplitterModule.createSplit: not implemented'
+    );
   }
 
   /**
@@ -381,7 +387,12 @@ export class SplitterModule {
    * ```
    */
   async distribute(_id: bigint): Promise<TransactionResult> {
-    throw new Error('SplitterModule.distribute: not implemented');
+    void this.server;
+    void _id;
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'SplitterModule.distribute: not implemented'
+    );
   }
 
   /**
@@ -415,4 +426,4 @@ export class SplitterModule {
 
     return { distributed, failed };
   }
-}
+}

src/modules/ticket/ticket-purchase.service.ts

@@ -1,3 +1,5 @@
+import { VeriTixError, VeriTixErrorCode } from '../../utils/errors';
+
 /** Billing contact captured at checkout. */
 export interface BillingDetails {
   fullName: string;
@@ -38,12 +40,15 @@ export class TicketPurchaseModule {
   /** Confirms a purchase against remaining availability and stores a receipt. */
   public purchase(orderId: string, request: PurchaseRequest, available: number): Receipt {
     if (!Number.isInteger(request.quantity) || request.quantity < 1) {
-      throw new Error('Ticket quantity must be a positive integer.');
+      throw new VeriTixError(
+        VeriTixErrorCode.InvalidAmount,
+        'Ticket quantity must be a positive integer.'
+      );
     }
     if (request.quantity > available) {
-      throw new Error(
-        `Only ${available} ticket(s) remain for event ${request.eventId}; ` +
-          `${request.quantity} requested.`,
+      throw new VeriTixError(
+        VeriTixErrorCode.InsufficientBalance,
+        `Only ${available} ticket(s) remain for event ${request.eventId}; ${request.quantity} requested.`
       );
     }
     const receipt: Receipt = {
@@ -60,4 +65,4 @@ export class TicketPurchaseModule {
   public getReceipt(orderId: string): Receipt | undefined {
     return this.receipts.get(orderId);
   }
-}
+}

src/modules/user.ts

@@ -8,6 +8,7 @@
  */
 
 import { SorobanRpc, Keypair } from '@stellar/stellar-sdk';
+import { VeriTixError, VeriTixErrorCode } from '../utils/errors';
 import type { NetworkConfig, TransactionResult } from '../types/index';
 
 /**
@@ -49,7 +50,10 @@ export class AdminModule {
     void this.config;
     void this.server;
     void this.keypair;
-    throw new Error('AdminModule.setAdmin: not implemented');
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'AdminModule.setAdmin: not implemented'
+    );
   }
 
   // -------------------------------------------------------------------------
@@ -66,7 +70,11 @@ export class AdminModule {
    */
   async freeze(_address: string): Promise<TransactionResult> {
     // TODO: implement
-    throw new Error('AdminModule.freeze: not implemented');
+    void _address;
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'AdminModule.freeze: not implemented'
+    );
   }
 
   /**
@@ -78,7 +86,11 @@ export class AdminModule {
    */
   async unfreeze(_address: string): Promise<TransactionResult> {
     // TODO: implement
-    throw new Error('AdminModule.unfreeze: not implemented');
+    void _address;
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'AdminModule.unfreeze: not implemented'
+    );
   }
 
   // -------------------------------------------------------------------------
@@ -96,7 +108,12 @@ export class AdminModule {
    */
   async clawback(_from: string, _amount: bigint): Promise<TransactionResult> {
     // TODO: implement
-    throw new Error('AdminModule.clawback: not implemented');
+    void _from;
+    void _amount;
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'AdminModule.clawback: not implemented'
+    );
   }
 
   // -------------------------------------------------------------------------
@@ -112,7 +129,10 @@ export class AdminModule {
    */
   async pause(): Promise<TransactionResult> {
     // TODO: implement
-    throw new Error('AdminModule.pause: not implemented');
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'AdminModule.pause: not implemented'
+    );
   }
 
   /**
@@ -123,6 +143,9 @@ export class AdminModule {
    */
   async unpause(): Promise<TransactionResult> {
     // TODO: implement
-    throw new Error('AdminModule.unpause: not implemented');
+    throw new VeriTixError(
+      VeriTixErrorCode.NotImplemented,
+      'AdminModule.unpause: not implemented'
+    );
   }
-}
+}