mmn-client-js 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-import { AxiosRequestConfig } from 'axios';
-
 interface JsonRpcRequest {
     jsonrpc: '2.0';
     method: string;
@@ -91,7 +89,6 @@ interface MmnClientConfig {
     baseUrl: string;
     timeout?: number;
     headers?: Record<string, string>;
-    axiosConfig?: AxiosRequestConfig;
 }
 interface Transaction {
     chain_id: string;
@@ -170,19 +167,28 @@ interface ZkClientConfig {
 }
 
 declare class IndexerClient {
-    private axiosInstance;
     private endpoint;
     private chainId;
+    private timeout;
+    private headers;
     constructor(config: IndexerClientConfig);
+    /**
+     * Make HTTP request with automatic CORS handling
+     * Works out-of-the-box without CORS configuration
+     * @param method - HTTP method (GET or POST)
+     * @param path - API endpoint path
+     * @param params - URL query parameters
+     * @param body - Request body for POST requests
+     * @returns Promise resolving to response data
+     */
     private makeRequest;
     getTransactionByHash(hash: string): Promise<Transaction>;
-    getTransactionByWallet(wallet: string, page: number | undefined, limit: number | undefined, filter: number): Promise<ListTransactionResponse>;
+    getTransactionByWallet(wallet: string, page: number | undefined, limit: number | undefined, filter: number, sortBy?: string, sortOrder?: 'asc' | 'desc'): Promise<ListTransactionResponse>;
     getWalletDetail(wallet: string): Promise<WalletDetail>;
 }
 
 declare class MmnClient {
     private config;
-    private axiosInstance;
     private requestId;
     constructor(config: MmnClientConfig);
     private makeRequest;
@@ -193,6 +199,14 @@ declare class MmnClient {
      * @throws Error if input validation fails
      */
     private rawEd25519ToPkcs8Hex;
+    /**
+     * Encode length in ASN.1 DER format
+     * ASN.1 length encoding rules:
+     * - Short form (0-127): single byte with the length value
+     * - Long form (128+): first byte is 0x80 + number of length bytes, followed by length bytes
+     * @param length - The length value to encode
+     * @returns ASN.1 DER encoded length bytes
+     */
     private encodeLength;
     /**
      * Generate secure entropy using multiple sources for maximum compatibility
@@ -241,8 +255,9 @@ declare class MmnClient {
 declare function createMmnClient(config: MmnClientConfig): MmnClient;
 
 declare class ZkClient {
-    private axiosInstance;
     private endpoint;
+    private timeout;
+    private headers;
     constructor(config: ZkClientConfig);
     private makeRequest;
     getZkProofs({ userId, ephemeralPublicKey, jwt, address, }: {

package/dist/index.esm.js

@@ -1,4 +1,3 @@
-import axios from 'axios';
 import bs58 from 'bs58';
 import nacl from 'tweetnacl';
 
@@ -11,31 +10,81 @@ class IndexerClient {
     constructor(config) {
         this.endpoint = config.endpoint;
         this.chainId = config.chainId;
-        this.axiosInstance = axios.create({
-            baseURL: this.endpoint,
-            timeout: config.timeout || 30000,
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-                ...(config.headers || {}),
-            },
-        });
+        this.timeout = config.timeout || 30000;
+        // Minimal headers to avoid CORS preflight issues
+        this.headers = {
+            Accept: 'application/json',
+            ...(config.headers || {}),
+        };
     }
+    /**
+     * Make HTTP request with automatic CORS handling
+     * Works out-of-the-box without CORS configuration
+     * @param method - HTTP method (GET or POST)
+     * @param path - API endpoint path
+     * @param params - URL query parameters
+     * @param body - Request body for POST requests
+     * @returns Promise resolving to response data
+     */
     async makeRequest(method, path, params, body) {
-        const resp = await this.axiosInstance.request({
-            method,
-            url: path,
-            params,
-            data: body,
-        });
-        return resp.data;
+        // Build full URL
+        let url = `${this.endpoint}/${path}`;
+        // Add query parameters
+        if (params && Object.keys(params).length > 0) {
+            const searchParams = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                searchParams.append(key, String(value));
+            });
+            url += `?${searchParams.toString()}`;
+        }
+        // Create AbortController for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            // Simple fetch with automatic CORS handling
+            const requestOptions = {
+                method,
+                mode: 'cors',
+                credentials: 'omit',
+                signal: controller.signal,
+                headers: {
+                    Accept: 'application/json',
+                    ...this.headers,
+                },
+            };
+            // Add body and Content-Type for POST requests
+            if (method === 'POST' && body) {
+                requestOptions.body = JSON.stringify(body);
+                requestOptions.headers['Content-Type'] =
+                    'application/json';
+            }
+            const response = await fetch(url, requestOptions);
+            clearTimeout(timeoutId);
+            // Handle response errors
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            // Parse JSON response
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new Error(`Request timeout after ${this.timeout}ms`);
+                }
+                throw error;
+            }
+            throw new Error('Request failed');
+        }
     }
     async getTransactionByHash(hash) {
         const path = `${this.chainId}/tx/${hash}/detail`;
         const res = await this.makeRequest('GET', path);
         return res.data.transaction;
     }
-    async getTransactionByWallet(wallet, page = 1, limit = 50, filter) {
+    async getTransactionByWallet(wallet, page = 1, limit = 50, filter, sortBy = 'transaction_timestamp', sortOrder = 'desc') {
         if (!wallet) {
             throw new Error('wallet address cannot be empty');
         }
@@ -48,8 +97,8 @@ class IndexerClient {
         const params = {
             page: page - 1,
             limit,
-            sort_by: 'block_timestamp',
-            sort_order: 'desc',
+            sort_by: sortBy,
+            sort_order: sortOrder,
         };
         switch (filter) {
             case API_FILTER_PARAMS.ALL:
@@ -7604,9 +7653,28 @@ const CRYPTO_CONSTANTS = {
     ED25519_PUBLIC_KEY_LENGTH: 32,
     MNEMONIC_ENTROPY_BITS: 128,
     PKCS8_VERSION: 0,
+    // ASN.1 DER encoding
     ASN1_SEQUENCE_TAG: 0x30,
     ASN1_OCTET_STRING_TAG: 0x04,
     ASN1_INTEGER_TAG: 0x02,
+    ASN1_LENGTH: 0x80,
+    // Ed25519 OID bytes: 1.3.101.112 (RFC 8410)
+    ED25519_OID_BYTES: [0x06, 0x03, 0x2b, 0x65, 0x70],
+    // PKCS#8 structure length constants
+    PKCS8_ALGORITHM_ID_LENGTH: 0x0b, // SEQUENCE length for algorithm identifier
+    PKCS8_PRIVATE_KEY_OCTET_OUTER_LENGTH: 0x22, // Outer OCTET STRING length (34 bytes)
+    PKCS8_PRIVATE_KEY_OCTET_INNER_LENGTH: 0x20, // Inner OCTET STRING length (32 bytes)
+};
+// PRNG (Pseudo-Random Number Generator) constants
+const PRNG_CONSTANTS = {
+    // Numerical Recipes LCG
+    LCG_MULTIPLIER: 1664525, // LCG multiplier (from Numerical Recipes)
+    LCG_INCREMENT: 1013904223, // LCG increment
+    LCG_MODULUS: 4294967296, // 2^32 modulus for LCG
+    TIMESTAMP_MULTIPLIER: 2654435761, // Golden Ratio constant
+    HASH_SUBSTRING_LENGTH: 8,
+    BYTE_SHIFT: 24,
+    BYTE_MASK: 0xff,
 };
 const TX_TYPE = {
     TRANSFER: 0,
@@ -7620,15 +7688,10 @@ class MmnClient {
             timeout: 30000,
             headers: {
                 'Content-Type': 'application/json',
+                Accept: 'application/json',
             },
             ...config,
         };
-        this.axiosInstance = axios.create({
-            baseURL: this.config.baseUrl,
-            timeout: this.config.timeout || 30000,
-            headers: this.config.headers || {},
-            ...(this.config.axiosConfig || {}),
-        });
     }
     async makeRequest(method, params) {
         const request = {
@@ -7637,30 +7700,36 @@ class MmnClient {
             params,
             id: ++this.requestId,
         };
+        // Create AbortController for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout || 30000);
         try {
-            const response = await this.axiosInstance.post('', request);
-            const result = response.data;
+            const requestOptions = {
+                method: 'POST',
+                mode: 'cors',
+                credentials: 'omit',
+                signal: controller.signal,
+                headers: this.config.headers || {},
+                body: JSON.stringify(request),
+            };
+            const response = await fetch(this.config.baseUrl, requestOptions);
+            console.log('🚀 ~ MmnClient ~ makeRequest ~ response:', response);
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const result = await response.json();
             if (result.error) {
                 throw new Error(`JSON-RPC Error ${result.error.code}: ${result.error.message}`);
             }
             return result.result;
         }
         catch (error) {
-            if (axios.isAxiosError(error)) {
-                if (error.response) {
-                    // Server responded with error status
-                    throw new Error(`HTTP ${error.response.status}: ${error.response.statusText}`);
-                }
-                else if (error.request) {
-                    // Request was made but no response received
-                    throw new Error('Network error: No response received');
-                }
-                else {
-                    // Something else happened
-                    throw new Error(`Request error: ${error.message}`);
-                }
-            }
+            clearTimeout(timeoutId);
             if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new Error(`Request timeout after ${this.config.timeout || 30000}ms`);
+                }
                 throw error;
             }
             throw new Error('Unknown error occurred');
@@ -7681,22 +7750,31 @@ class MmnClient {
             throw new Error(`Ed25519 private key must be exactly ${CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH} bytes`);
         }
         try {
-            // Ed25519 OID: 1.3.101.112 (constant-time)
-            const ED25519_OID = BufferCompat.from([0x06, 0x03, 0x2b, 0x65, 0x70]);
+            // Ed25519 OID: 1.3.101.112 (RFC 8410 - Algorithm Identifiers for Ed25519)
+            const ED25519_OID = BufferCompat.from(CRYPTO_CONSTANTS.ED25519_OID_BYTES);
             const VERSION_BYTES = BufferCompat.from([
                 CRYPTO_CONSTANTS.ASN1_INTEGER_TAG,
-                0x01,
+                0x01, // Length of integer (1 byte)
                 CRYPTO_CONSTANTS.PKCS8_VERSION,
-            ]); // INTEGER 0
-            // Create algorithm identifier sequence
+            ]);
+            // Create algorithm identifier sequence (AlgorithmIdentifier)
             const algorithmId = BufferCompat.concat([
-                BufferCompat.from([0x30, 0x0b]), // SEQUENCE, length 11
+                BufferCompat.from([
+                    CRYPTO_CONSTANTS.ASN1_SEQUENCE_TAG,
+                    CRYPTO_CONSTANTS.PKCS8_ALGORITHM_ID_LENGTH,
+                ]),
                 ED25519_OID,
             ]);
-            // Create private key octet string
+            // Create private key octet string (wrapped Ed25519 private key)
             const privateKeyOctetString = BufferCompat.concat([
-                BufferCompat.from([CRYPTO_CONSTANTS.ASN1_OCTET_STRING_TAG, 0x22]), // OCTET STRING, length 34
-                BufferCompat.from([CRYPTO_CONSTANTS.ASN1_OCTET_STRING_TAG, 0x20]), // inner OCTET STRING, length 32
+                BufferCompat.from([
+                    CRYPTO_CONSTANTS.ASN1_OCTET_STRING_TAG,
+                    CRYPTO_CONSTANTS.PKCS8_PRIVATE_KEY_OCTET_OUTER_LENGTH,
+                ]), // OCTET STRING, length 34
+                BufferCompat.from([
+                    CRYPTO_CONSTANTS.ASN1_OCTET_STRING_TAG,
+                    CRYPTO_CONSTANTS.PKCS8_PRIVATE_KEY_OCTET_INNER_LENGTH,
+                ]), // inner OCTET STRING, length 32
                 raw,
             ]);
             // Create PKCS#8 body
@@ -7725,17 +7803,28 @@ class MmnClient {
             throw new Error(`Failed to convert private key to PKCS#8: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    /**
+     * Encode length in ASN.1 DER format
+     * ASN.1 length encoding rules:
+     * - Short form (0-127): single byte with the length value
+     * - Long form (128+): first byte is 0x80 + number of length bytes, followed by length bytes
+     * @param length - The length value to encode
+     * @returns ASN.1 DER encoded length bytes
+     */
     encodeLength(length) {
-        if (length < 0x80) {
+        if (length < CRYPTO_CONSTANTS.ASN1_LENGTH) {
             return BufferCompat.from([length]);
         }
         const bytes = [];
         let len = length;
         while (len > 0) {
-            bytes.unshift(len & 0xff);
+            bytes.unshift(len & PRNG_CONSTANTS.BYTE_MASK);
             len >>= 8;
         }
-        return BufferCompat.from([0x80 | bytes.length, ...bytes]);
+        return BufferCompat.from([
+            CRYPTO_CONSTANTS.ASN1_LENGTH | bytes.length,
+            ...bytes,
+        ]);
     }
     /**
      * Generate secure entropy using multiple sources for maximum compatibility
@@ -7752,19 +7841,25 @@ class MmnClient {
         const random = Math.random();
         // Create initial seed from timestamp and random
         let seed = now + performance + random;
-        // Generate bytes using linear congruential generator with multiple mixing
+        // Generate bytes using Linear Congruential Generator (LCG) with multiple entropy sources
+        // This provides a fallback Pseudorandom Number Generator (PRNG) when crypto.getRandomValues is not available
         for (let i = 0; i < targetLength; i++) {
-            // Mix multiple sources
-            seed = (seed * 1664525 + 1013904223) % 4294967296; // LCG
-            seed ^= (now + i) * 2654435761; // Mix with timestamp
-            seed ^= Math.floor(Math.random() * 4294967296); // Mix with Math.random
-            // Additional mixing with crypto-js if available
+            // Xₙ₊₁ = (a * Xₙ + c) mod m
+            seed =
+                (seed * PRNG_CONSTANTS.LCG_MULTIPLIER + PRNG_CONSTANTS.LCG_INCREMENT) %
+                    PRNG_CONSTANTS.LCG_MODULUS;
+            // Mix with timestamp to add time-based entropy
+            seed ^= (now + i) * PRNG_CONSTANTS.TIMESTAMP_MULTIPLIER;
+            // Mix with Math.random() for additional browser-provided randomness
+            seed ^= Math.floor(Math.random() * PRNG_CONSTANTS.LCG_MODULUS);
+            // Additional cryptographic mixing using SHA256 if CryptoJS is available
             if (typeof CryptoJS !== 'undefined') {
                 const hashInput = seed.toString() + i.toString() + now.toString();
                 const hash = CryptoJS.SHA256(hashInput).toString();
-                seed ^= parseInt(hash.substring(0, 8), 16);
+                // Extract first 8 hex characters (32 bits) from hash for mixing
+                seed ^= parseInt(hash.substring(0, PRNG_CONSTANTS.HASH_SUBSTRING_LENGTH), 16);
             }
-            entropy.push((seed >>> 24) & 0xff);
+            entropy.push((seed >>> PRNG_CONSTANTS.BYTE_SHIFT) & PRNG_CONSTANTS.BYTE_MASK);
         }
         return entropy;
     }
@@ -7969,24 +8064,56 @@ var ETransferType;
 class ZkClient {
     constructor(config) {
         this.endpoint = config.endpoint;
-        this.axiosInstance = axios.create({
-            baseURL: this.endpoint,
-            timeout: config.timeout || 30000,
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-                ...(config.headers || {}),
-            },
-        });
+        this.timeout = config.timeout || 30000;
+        this.headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            ...(config.headers || {}),
+        };
     }
     async makeRequest(method, path, params, body) {
-        const resp = await this.axiosInstance.request({
-            method,
-            url: path,
-            params,
-            data: body,
-        });
-        return resp.data;
+        let url = `${this.endpoint}/${path}`;
+        // Add query parameters for GET requests
+        if (params && Object.keys(params).length > 0) {
+            const searchParams = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                searchParams.append(key, String(value));
+            });
+            url += `?${searchParams.toString()}`;
+        }
+        // Create AbortController for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const requestOptions = {
+                method,
+                mode: 'cors',
+                credentials: 'omit',
+                signal: controller.signal,
+                headers: this.headers,
+            };
+            // Add body for POST requests
+            if (method === 'POST' && body) {
+                requestOptions.body = JSON.stringify(body);
+            }
+            const response = await fetch(url, requestOptions);
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new Error(`Request timeout after ${this.timeout}ms`);
+                }
+                throw error;
+            }
+            throw new Error('Request failed');
+        }
     }
     async getZkProofs({ userId, ephemeralPublicKey, jwt, address, }) {
         const path = `prove`;