@silentswap/sdk 0.0.52 → 0.0.53

package/dist/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createSilentSwapClient } from './client.js';
+import { ENVIRONMENT } from './constants.js';
+// Mock fetch globally
+global.fetch = vi.fn();
+describe('SilentSwapClient', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('createSilentSwapClient', () => {
+        it('should create a client with MAINNET environment', () => {
+            const client = createSilentSwapClient({
+                environment: ENVIRONMENT.MAINNET,
+            });
+            expect(client).toBeDefined();
+            expect(client.gatewayAddress).toBeDefined();
+            expect(client.baseUrl).toBeDefined();
+        });
+        it('should create a client with STAGING environment', () => {
+            const client = createSilentSwapClient({
+                environment: ENVIRONMENT.STAGING,
+            });
+            expect(client).toBeDefined();
+            expect(client.gatewayAddress).toBeDefined();
+        });
+        it('should throw error for unsupported environment', () => {
+            expect(() => {
+                createSilentSwapClient({
+                    environment: 'INVALID',
+                });
+            }).toThrow('Unsupported environment');
+        });
+        it('should use custom baseUrl when provided', () => {
+            const customUrl = 'https://custom-api.example.com';
+            const client = createSilentSwapClient({
+                environment: ENVIRONMENT.MAINNET,
+                baseUrl: customUrl,
+            });
+            expect(client.baseUrl).toBe(customUrl);
+        });
+    });
+    describe('nonce', () => {
+        it('should fetch nonce successfully', async () => {
+            const client = createSilentSwapClient({
+                environment: ENVIRONMENT.STAGING,
+            });
+            const mockResponse = {
+                nonce: 'test-nonce-123',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                text: async () => JSON.stringify(mockResponse),
+            });
+            const [error, result] = await client.nonce('0x1234567890123456789012345678901234567890');
+            expect(error).toBeUndefined();
+            expect(result).toBeDefined();
+        });
+        it('should handle API errors', async () => {
+            const client = createSilentSwapClient({
+                environment: ENVIRONMENT.STAGING,
+            });
+            const mockError = {
+                type: 'AUTH_ERROR',
+                error: 'Invalid address',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                text: async () => JSON.stringify(mockError),
+            });
+            const [error, result] = await client.nonce('invalid-address');
+            expect(error).toBeDefined();
+            expect(result).toBeUndefined();
+            expect(error?.type).toBe('AUTH_ERROR');
+        });
+    });
+});

package/dist/errors.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Custom error classes for SilentSwap SDK
+ */
+/**
+ * Base error class for all SDK errors
+ */
+export declare class SilentSwapError extends Error {
+    readonly code?: string | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code?: string | undefined, cause?: Error | undefined);
+}
+/**
+ * Error thrown when API request fails
+ */
+export declare class ApiError extends SilentSwapError {
+    readonly statusCode?: number | undefined;
+    readonly response?: unknown | undefined;
+    constructor(message: string, statusCode?: number | undefined, response?: unknown | undefined, cause?: Error);
+}
+/**
+ * Error thrown when network request fails
+ */
+export declare class NetworkError extends SilentSwapError {
+    readonly originalError?: Error | undefined;
+    constructor(message: string, originalError?: Error | undefined);
+}
+/**
+ * Error thrown when authentication fails
+ */
+export declare class AuthenticationError extends SilentSwapError {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+/**
+ * Error thrown when quote request fails
+ */
+export declare class QuoteError extends SilentSwapError {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+/**
+ * Error thrown when order creation fails
+ */
+export declare class OrderError extends SilentSwapError {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+/**
+ * Error thrown when validation fails
+ */
+export declare class ValidationError extends SilentSwapError {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+/**
+ * Error thrown when configuration is invalid
+ */
+export declare class ConfigurationError extends SilentSwapError {
+    readonly config?: unknown | undefined;
+    constructor(message: string, config?: unknown | undefined);
+}
+/**
+ * Error thrown when wallet operation fails
+ */
+export declare class WalletError extends SilentSwapError {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+/**
+ * Error thrown when transaction fails
+ */
+export declare class TransactionError extends SilentSwapError {
+    readonly transactionHash?: string | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, transactionHash?: string | undefined, cause?: Error | undefined);
+}
+/**
+ * Helper function to convert ErrorResponse to appropriate error class
+ */
+export declare function createErrorFromResponse(errorResponse: {
+    type: string;
+    error: string;
+}, statusCode?: number): SilentSwapError;

package/dist/errors.js

@@ -0,0 +1,144 @@
+/**
+ * Custom error classes for SilentSwap SDK
+ */
+/**
+ * Base error class for all SDK errors
+ */
+export class SilentSwapError extends Error {
+    code;
+    cause;
+    constructor(message, code, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = 'SilentSwapError';
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, SilentSwapError);
+        }
+    }
+}
+/**
+ * Error thrown when API request fails
+ */
+export class ApiError extends SilentSwapError {
+    statusCode;
+    response;
+    constructor(message, statusCode, response, cause) {
+        super(message, 'API_ERROR', cause);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = 'ApiError';
+    }
+}
+/**
+ * Error thrown when network request fails
+ */
+export class NetworkError extends SilentSwapError {
+    originalError;
+    constructor(message, originalError) {
+        super(message, 'NETWORK_ERROR', originalError);
+        this.originalError = originalError;
+        this.name = 'NetworkError';
+    }
+}
+/**
+ * Error thrown when authentication fails
+ */
+export class AuthenticationError extends SilentSwapError {
+    cause;
+    constructor(message, cause) {
+        super(message, 'AUTHENTICATION_ERROR', cause);
+        this.cause = cause;
+        this.name = 'AuthenticationError';
+    }
+}
+/**
+ * Error thrown when quote request fails
+ */
+export class QuoteError extends SilentSwapError {
+    cause;
+    constructor(message, cause) {
+        super(message, 'QUOTE_ERROR', cause);
+        this.cause = cause;
+        this.name = 'QuoteError';
+    }
+}
+/**
+ * Error thrown when order creation fails
+ */
+export class OrderError extends SilentSwapError {
+    cause;
+    constructor(message, cause) {
+        super(message, 'ORDER_ERROR', cause);
+        this.cause = cause;
+        this.name = 'OrderError';
+    }
+}
+/**
+ * Error thrown when validation fails
+ */
+export class ValidationError extends SilentSwapError {
+    field;
+    constructor(message, field) {
+        super(message, 'VALIDATION_ERROR');
+        this.field = field;
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Error thrown when configuration is invalid
+ */
+export class ConfigurationError extends SilentSwapError {
+    config;
+    constructor(message, config) {
+        super(message, 'CONFIGURATION_ERROR');
+        this.config = config;
+        this.name = 'ConfigurationError';
+    }
+}
+/**
+ * Error thrown when wallet operation fails
+ */
+export class WalletError extends SilentSwapError {
+    cause;
+    constructor(message, cause) {
+        super(message, 'WALLET_ERROR', cause);
+        this.cause = cause;
+        this.name = 'WalletError';
+    }
+}
+/**
+ * Error thrown when transaction fails
+ */
+export class TransactionError extends SilentSwapError {
+    transactionHash;
+    cause;
+    constructor(message, transactionHash, cause) {
+        super(message, 'TRANSACTION_ERROR', cause);
+        this.transactionHash = transactionHash;
+        this.cause = cause;
+        this.name = 'TransactionError';
+    }
+}
+/**
+ * Helper function to convert ErrorResponse to appropriate error class
+ */
+export function createErrorFromResponse(errorResponse, statusCode) {
+    const { type, error } = errorResponse;
+    switch (type) {
+        case 'AUTHENTICATION_ERROR':
+        case 'AUTH_ERROR':
+            return new AuthenticationError(error);
+        case 'QUOTE_ERROR':
+            return new QuoteError(error);
+        case 'ORDER_ERROR':
+            return new OrderError(error);
+        case 'VALIDATION_ERROR':
+            return new ValidationError(error);
+        case 'NETWORK_ERROR':
+            return new NetworkError(error);
+        default:
+            return new ApiError(error, statusCode, errorResponse);
+    }
+}

package/dist/index.d.ts

@@ -26,3 +26,4 @@ export { bytes_to_base58, base58_to_bytes, bytes_to_base93, base93_to_bytes, byt
 export * from './address.js';
 export * from './asset-utils.js';
 export * from './solana-utils.js';
+export * from './errors.js';

package/dist/index.js

@@ -25,3 +25,4 @@ export * from './address.js';
 // TypeScript will use the parameter type to distinguish them at call sites.
 export * from './asset-utils.js';
 export * from './solana-utils.js';
+export * from './errors.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/sdk",
   "type": "module",
-  "version": "0.0.52",
+  "version": "0.0.53",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [
@@ -13,7 +13,10 @@
     "clean": "rm -rf dist",
     "dev": "tsc --watch",
     "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix"
+    "lint:fix": "eslint src --ext .ts --fix",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest --coverage"
   },
   "dependencies": {
     "@cosmjs/amino": "0.36.2",
@@ -32,11 +35,13 @@
     "@types/node": "24.9.1",
     "@types/web": "0.0.283",
     "@typescript-eslint/parser": "8.46.2",
+    "@vitest/coverage-v8": "^2.1.0",
     "abitype": "1.1.1",
     "eslint": "9.38.0",
     "eslint-import-resolver-typescript": "4.4.4",
     "eslint-plugin-import-x": "4.16.1",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.46.2"
+    "typescript-eslint": "8.46.2",
+    "vitest": "^2.1.0"
   }
 }