mmn-client-js 1.0.13-node14 → 1.0.14-node14

package/dist/index.esm.js

@@ -1,135 +1,160 @@
 import bs58 from 'bs58';
 import nacl from 'tweetnacl';
 
-const API_FILTER_PARAMS = {
-    ALL: 0,
-    SENT: 2,
-    RECEIVED: 1,
-};
-class IndexerClient {
-    constructor(config) {
-        this.endpoint = config.endpoint;
-        this.chainId = config.chainId;
-        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) {
-        // 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, sortBy = 'transaction_timestamp', sortOrder = 'desc') {
-        if (!wallet) {
-            throw new Error('wallet address cannot be empty');
-        }
-        if (page < 1)
-            page = 1;
-        if (limit <= 0)
-            limit = 50;
-        if (limit > 1000)
-            limit = 1000;
-        const params = {
-            page: page - 1,
-            limit,
-            sort_by: sortBy,
-            sort_order: sortOrder,
-        };
-        switch (filter) {
-            case API_FILTER_PARAMS.ALL:
-                params['wallet_address'] = wallet;
-                break;
-            case API_FILTER_PARAMS.SENT:
-                params['filter_from_address'] = wallet;
-                break;
-            case API_FILTER_PARAMS.RECEIVED:
-                params['filter_to_address'] = wallet;
-                break;
-        }
-        const path = `${this.chainId}/transactions`;
-        return this.makeRequest('GET', path, params);
-    }
-    async getWalletDetail(wallet) {
-        if (!wallet) {
-            throw new Error('wallet address cannot be empty');
-        }
-        const path = `${this.chainId}/wallets/${wallet}/detail`;
-        const res = await this.makeRequest('GET', path);
-        return res.data;
-    }
+// Fetch and AbortController polyfills for Node 14 compatibility
+/* eslint-disable @typescript-eslint/no-require-imports */
+let fetchPolyfill;
+let AbortControllerPolyfill;
+if (typeof fetch === 'undefined') {
+    try {
+        // Use node-fetch in Node.js environments that don't have global fetch
+        fetchPolyfill = require('node-fetch');
+    }
+    catch {
+        throw new Error('node-fetch is required for Node 14 compatibility. Please install it: npm install node-fetch@2');
+    }
+}
+else {
+    fetchPolyfill = fetch;
+}
+if (typeof AbortController === 'undefined') {
+    try {
+        // Use abort-controller in environments that don't have AbortController
+        AbortControllerPolyfill = require('abort-controller');
+    }
+    catch {
+        throw new Error('abort-controller is required for Node 14 compatibility. Please install it: npm install abort-controller');
+    }
+}
+else {
+    AbortControllerPolyfill = AbortController;
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+const API_FILTER_PARAMS = {
+    ALL: 0,
+    SENT: 2,
+    RECEIVED: 1,
+};
+class IndexerClient {
+    constructor(config) {
+        this.endpoint = config.endpoint;
+        this.chainId = config.chainId;
+        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) {
+        // 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 AbortControllerPolyfill();
+        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 fetchPolyfill(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, sortBy = 'transaction_timestamp', sortOrder = 'desc') {
+        if (!wallet) {
+            throw new Error('wallet address cannot be empty');
+        }
+        if (page < 1)
+            page = 1;
+        if (limit <= 0)
+            limit = 50;
+        if (limit > 1000)
+            limit = 1000;
+        const params = {
+            page: page - 1,
+            limit,
+            sort_by: sortBy,
+            sort_order: sortOrder,
+        };
+        switch (filter) {
+            case API_FILTER_PARAMS.ALL:
+                params['wallet_address'] = wallet;
+                break;
+            case API_FILTER_PARAMS.SENT:
+                params['filter_from_address'] = wallet;
+                break;
+            case API_FILTER_PARAMS.RECEIVED:
+                params['filter_to_address'] = wallet;
+                break;
+        }
+        const path = `${this.chainId}/transactions`;
+        return this.makeRequest('GET', path, params);
+    }
+    async getWalletDetail(wallet) {
+        if (!wallet) {
+            throw new Error('wallet address cannot be empty');
+        }
+        const path = `${this.chainId}/wallets/${wallet}/detail`;
+        const res = await this.makeRequest('GET', path);
+        return res.data;
+    }
 }
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
 var cryptoJs = {exports: {}};
 
 function commonjsRequire(path) {
@@ -942,8 +967,8 @@ function requireCore () {
 
 			return CryptoJS;
 
-		})); 
-	} (core));
+		}));
+} (core));
 	return core.exports;
 }
 
@@ -1250,8 +1275,8 @@ function requireX64Core () {
 
 			return CryptoJS;
 
-		})); 
-	} (x64Core));
+		}));
+} (x64Core));
 	return x64Core.exports;
 }
 
@@ -1330,8 +1355,8 @@ function requireLibTypedarrays () {
 
 			return CryptoJS.lib.WordArray;
 
-		})); 
-	} (libTypedarrays));
+		}));
+} (libTypedarrays));
 	return libTypedarrays.exports;
 }
 
@@ -1483,8 +1508,8 @@ function requireEncUtf16 () {
 
 			return CryptoJS.enc.Utf16;
 
-		})); 
-	} (encUtf16));
+		}));
+} (encUtf16));
 	return encUtf16.exports;
 }
 
@@ -1623,8 +1648,8 @@ function requireEncBase64 () {
 
 			return CryptoJS.enc.Base64;
 
-		})); 
-	} (encBase64));
+		}));
+} (encBase64));
 	return encBase64.exports;
 }
 
@@ -1775,8 +1800,8 @@ function requireEncBase64url () {
 
 			return CryptoJS.enc.Base64url;
 
-		})); 
-	} (encBase64url));
+		}));
+} (encBase64url));
 	return encBase64url.exports;
 }
 
@@ -2047,8 +2072,8 @@ function requireMd5 () {
 
 			return CryptoJS.MD5;
 
-		})); 
-	} (md5));
+		}));
+} (md5));
 	return md5.exports;
 }
 
@@ -2201,8 +2226,8 @@ function requireSha1 () {
 
 			return CryptoJS.SHA1;
 
-		})); 
-	} (sha1));
+		}));
+} (sha1));
 	return sha1.exports;
 }
 
@@ -2404,8 +2429,8 @@ function requireSha256 () {
 
 			return CryptoJS.SHA256;
 
-		})); 
-	} (sha256));
+		}));
+} (sha256));
 	return sha256.exports;
 }
 
@@ -2488,8 +2513,8 @@ function requireSha224 () {
 
 			return CryptoJS.SHA224;
 
-		})); 
-	} (sha224));
+		}));
+} (sha224));
 	return sha224.exports;
 }
 
@@ -2818,8 +2843,8 @@ function requireSha512 () {
 
 			return CryptoJS.SHA512;
 
-		})); 
-	} (sha512));
+		}));
+} (sha512));
 	return sha512.exports;
 }
 
@@ -2905,8 +2930,8 @@ function requireSha384 () {
 
 			return CryptoJS.SHA384;
 
-		})); 
-	} (sha384));
+		}));
+} (sha384));
 	return sha384.exports;
 }
 
@@ -3235,8 +3260,8 @@ function requireSha3 () {
 
 			return CryptoJS.SHA3;
 
-		})); 
-	} (sha3));
+		}));
+} (sha3));
 	return sha3.exports;
 }
 
@@ -3506,8 +3531,8 @@ function requireRipemd160 () {
 
 			return CryptoJS.RIPEMD160;
 
-		})); 
-	} (ripemd160));
+		}));
+} (ripemd160));
 	return ripemd160.exports;
 }
 
@@ -3653,8 +3678,8 @@ function requireHmac () {
 			}());
 
 
-		})); 
-	} (hmac));
+		}));
+} (hmac));
 	return hmac.exports;
 }
 
@@ -3802,8 +3827,8 @@ function requirePbkdf2 () {
 
 			return CryptoJS.PBKDF2;
 
-		})); 
-	} (pbkdf2));
+		}));
+} (pbkdf2));
 	return pbkdf2.exports;
 }
 
@@ -3940,8 +3965,8 @@ function requireEvpkdf () {
 
 			return CryptoJS.EvpKDF;
 
-		})); 
-	} (evpkdf));
+		}));
+} (evpkdf));
 	return evpkdf.exports;
 }
 
@@ -4164,7 +4189,7 @@ function requireCipherCore () {
 			    C_lib.StreamCipher = Cipher.extend({
 			        _doFinalize: function () {
 			            // Process partial blocks
-			            var finalProcessedBlocks = this._process(true);
+			            var finalProcessedBlocks = this._process(!!'flush');
 
 			            return finalProcessedBlocks;
 			        },
@@ -4445,10 +4470,10 @@ function requireCipherCore () {
 			                padding.pad(this._data, this.blockSize);
 
 			                // Process final blocks
-			                finalProcessedBlocks = this._process(true);
+			                finalProcessedBlocks = this._process(!!'flush');
 			            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
 			                // Process final blocks
-			                finalProcessedBlocks = this._process(true);
+			                finalProcessedBlocks = this._process(!!'flush');
 
 			                // Unpad data
 			                padding.unpad(finalProcessedBlocks);
@@ -4839,8 +4864,8 @@ function requireCipherCore () {
 			}());
 
 
-		})); 
-	} (cipherCore));
+		}));
+} (cipherCore));
 	return cipherCore.exports;
 }
 
@@ -4923,8 +4948,8 @@ function requireModeCfb () {
 
 			return CryptoJS.mode.CFB;
 
-		})); 
-	} (modeCfb));
+		}));
+} (modeCfb));
 	return modeCfb.exports;
 }
 
@@ -4985,8 +5010,8 @@ function requireModeCtr () {
 
 			return CryptoJS.mode.CTR;
 
-		})); 
-	} (modeCtr));
+		}));
+} (modeCtr));
 	return modeCtr.exports;
 }
 
@@ -5105,8 +5130,8 @@ function requireModeCtrGladman () {
 
 			return CryptoJS.mode.CTRGladman;
 
-		})); 
-	} (modeCtrGladman));
+		}));
+} (modeCtrGladman));
 	return modeCtrGladman.exports;
 }
 
@@ -5163,8 +5188,8 @@ function requireModeOfb () {
 
 			return CryptoJS.mode.OFB;
 
-		})); 
-	} (modeOfb));
+		}));
+} (modeOfb));
 	return modeOfb.exports;
 }
 
@@ -5207,8 +5232,8 @@ function requireModeEcb () {
 
 			return CryptoJS.mode.ECB;
 
-		})); 
-	} (modeEcb));
+		}));
+} (modeEcb));
 	return modeEcb.exports;
 }
 
@@ -5260,8 +5285,8 @@ function requirePadAnsix923 () {
 
 			return CryptoJS.pad.Ansix923;
 
-		})); 
-	} (padAnsix923));
+		}));
+} (padAnsix923));
 	return padAnsix923.exports;
 }
 
@@ -5308,8 +5333,8 @@ function requirePadIso10126 () {
 
 			return CryptoJS.pad.Iso10126;
 
-		})); 
-	} (padIso10126));
+		}));
+} (padIso10126));
 	return padIso10126.exports;
 }
 
@@ -5352,8 +5377,8 @@ function requirePadIso97971 () {
 
 			return CryptoJS.pad.Iso97971;
 
-		})); 
-	} (padIso97971));
+		}));
+} (padIso97971));
 	return padIso97971.exports;
 }
 
@@ -5403,8 +5428,8 @@ function requirePadZeropadding () {
 
 			return CryptoJS.pad.ZeroPadding;
 
-		})); 
-	} (padZeropadding));
+		}));
+} (padZeropadding));
 	return padZeropadding.exports;
 }
 
@@ -5437,8 +5462,8 @@ function requirePadNopadding () {
 
 			return CryptoJS.pad.NoPadding;
 
-		})); 
-	} (padNopadding));
+		}));
+} (padNopadding));
 	return padNopadding.exports;
 }
 
@@ -5507,8 +5532,8 @@ function requireFormatHex () {
 
 			return CryptoJS.format.Hex;
 
-		})); 
-	} (formatHex));
+		}));
+} (formatHex));
 	return formatHex.exports;
 }
 
@@ -5745,8 +5770,8 @@ function requireAes () {
 
 			return CryptoJS.AES;
 
-		})); 
-	} (aes));
+		}));
+} (aes));
 	return aes.exports;
 }
 
@@ -6528,8 +6553,8 @@ function requireTripledes () {
 
 			return CryptoJS.TripleDES;
 
-		})); 
-	} (tripledes));
+		}));
+} (tripledes));
 	return tripledes.exports;
 }
 
@@ -6671,8 +6696,8 @@ function requireRc4 () {
 
 			return CryptoJS.RC4;
 
-		})); 
-	} (rc4));
+		}));
+} (rc4));
 	return rc4.exports;
 }
 
@@ -6867,8 +6892,8 @@ function requireRabbit () {
 
 			return CryptoJS.Rabbit;
 
-		})); 
-	} (rabbit));
+		}));
+} (rabbit));
 	return rabbit.exports;
 }
 
@@ -7061,8 +7086,8 @@ function requireRabbitLegacy () {
 
 			return CryptoJS.RabbitLegacy;
 
-		})); 
-	} (rabbitLegacy));
+		}));
+} (rabbitLegacy));
 	return rabbitLegacy.exports;
 }
 
@@ -7536,8 +7561,8 @@ function requireBlowfish () {
 
 			return CryptoJS.Blowfish;
 
-		})); 
-	} (blowfish));
+		}));
+} (blowfish));
 	return blowfish.exports;
 }
 
@@ -7551,623 +7576,621 @@ function requireBlowfish () {
 
 		return CryptoJS;
 
-	})); 
+	}));
 } (cryptoJs));
 
-var cryptoJsExports = cryptoJs.exports;
-var CryptoJS = /*@__PURE__*/getDefaultExportFromCjs(cryptoJsExports);
-
-// MMN Client
-// This client provides a complete interface for interacting with MMN blockchain
-// Buffer polyfill for mobile environments
-class BufferPolyfill {
-    static isBuffer(obj) {
-        if (typeof Buffer !== 'undefined' && Buffer.isBuffer) {
-            return Buffer.isBuffer(obj);
-        }
-        return obj instanceof Uint8Array;
-    }
-    static from(data, encoding) {
-        if (typeof Buffer !== 'undefined' && Buffer.from) {
-            return Buffer.from(data, encoding);
-        }
-        let result;
-        if (Array.isArray(data)) {
-            result = new Uint8Array(data);
-        }
-        else if (typeof data === 'string') {
-            if (encoding === 'hex') {
-                const bytes = [];
-                for (let i = 0; i < data.length; i += 2) {
-                    bytes.push(parseInt(data.substr(i, 2), 16));
-                }
-                result = new Uint8Array(bytes);
-            }
-            else {
-                // UTF-8 encoding
-                const encoder = new TextEncoder();
-                result = encoder.encode(data);
-            }
-        }
-        else if (data instanceof Uint8Array) {
-            result = data;
-        }
-        else {
-            result = new Uint8Array(data);
-        }
-        // Add toString method
-        result.toString = function (encoding) {
-            if (encoding === 'hex') {
-                return Array.from(this)
-                    .map((b) => b.toString(16).padStart(2, '0'))
-                    .join('');
-            }
-            else if (encoding === 'base64') {
-                // Simple base64 encoding
-                const bytes = this;
-                let binary = '';
-                for (let i = 0; i < bytes.length; i++) {
-                    binary += String.fromCharCode(bytes[i]);
-                }
-                return btoa(binary);
-            }
-            else {
-                // UTF-8 decoding
-                const decoder = new TextDecoder();
-                return decoder.decode(this);
-            }
-        };
-        return result;
-    }
-    static concat(arrays) {
-        if (typeof Buffer !== 'undefined' && Buffer.concat) {
-            return Buffer.concat(arrays);
-        }
-        const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-        const result = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const arr of arrays) {
-            result.set(arr, offset);
-            offset += arr.length;
-        }
-        // Add toString method
-        result.toString = function (encoding) {
-            if (encoding === 'hex') {
-                return Array.from(this)
-                    .map((b) => b.toString(16).padStart(2, '0'))
-                    .join('');
-            }
-            else {
-                const decoder = new TextDecoder();
-                return decoder.decode(this);
-            }
-        };
-        return result;
-    }
-}
-// Use polyfill if Buffer is not available
-const BufferCompat = typeof Buffer !== 'undefined' ? Buffer : BufferPolyfill;
-// Cryptographic constants
-const CRYPTO_CONSTANTS = {
-    ED25519_PRIVATE_KEY_LENGTH: 32,
-    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,
-    PRIVATE_KEY: 1,
-};
-const DECIMALS = 6;
-class MmnClient {
-    constructor(config) {
-        this.requestId = 0;
-        this.config = {
-            timeout: 30000,
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-            ...config,
-        };
-    }
-    async makeRequest(method, params) {
-        const request = {
-            jsonrpc: '2.0',
-            method,
-            params,
-            id: ++this.requestId,
-        };
-        // Create AbortController for timeout
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout || 30000);
-        try {
-            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);
-            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) {
-            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');
-        }
-    }
-    /**
-     * Securely convert raw Ed25519 private key to PKCS#8 format
-     * @param raw - Raw 32-byte Ed25519 private key
-     * @returns PKCS#8 formatted private key in hex
-     * @throws Error if input validation fails
-     */
-    rawEd25519ToPkcs8Hex(raw) {
-        // Input validation
-        if (!BufferCompat.isBuffer(raw)) {
-            throw new Error('Private key must be a Buffer');
-        }
-        if (raw.length !== CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH) {
-            throw new Error(`Ed25519 private key must be exactly ${CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH} bytes`);
-        }
-        try {
-            // 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, // Length of integer (1 byte)
-                CRYPTO_CONSTANTS.PKCS8_VERSION,
-            ]);
-            // Create algorithm identifier sequence (AlgorithmIdentifier)
-            const algorithmId = BufferCompat.concat([
-                BufferCompat.from([
-                    CRYPTO_CONSTANTS.ASN1_SEQUENCE_TAG,
-                    CRYPTO_CONSTANTS.PKCS8_ALGORITHM_ID_LENGTH,
-                ]),
-                ED25519_OID,
-            ]);
-            // Create private key octet string (wrapped Ed25519 private key)
-            const privateKeyOctetString = BufferCompat.concat([
-                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
-            const pkcs8Body = BufferCompat.concat([
-                VERSION_BYTES,
-                algorithmId,
-                privateKeyOctetString,
-            ]);
-            // Create final PKCS#8 structure
-            const pkcs8 = BufferCompat.concat([
-                BufferCompat.from([CRYPTO_CONSTANTS.ASN1_SEQUENCE_TAG]), // SEQUENCE
-                this.encodeLength(pkcs8Body.length),
-                pkcs8Body,
-            ]);
-            const result = pkcs8.toString('hex');
-            // Clear sensitive data from memory
-            raw.fill(0);
-            privateKeyOctetString.fill(0);
-            pkcs8Body.fill(0);
-            pkcs8.fill(0);
-            return result;
-        }
-        catch (error) {
-            // Clear sensitive data on error
-            raw.fill(0);
-            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 < CRYPTO_CONSTANTS.ASN1_LENGTH) {
-            return BufferCompat.from([length]);
-        }
-        const bytes = [];
-        let len = length;
-        while (len > 0) {
-            bytes.unshift(len & PRNG_CONSTANTS.BYTE_MASK);
-            len >>= 8;
-        }
-        return BufferCompat.from([
-            CRYPTO_CONSTANTS.ASN1_LENGTH | bytes.length,
-            ...bytes,
-        ]);
-    }
-    /**
-     * Generate secure entropy using multiple sources for maximum compatibility
-     * @returns Array of 32 random bytes
-     */
-    generateSecureEntropy() {
-        const entropy = [];
-        const targetLength = CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH;
-        // Use multiple entropy sources
-        const now = Date.now();
-        const performance = typeof window !== 'undefined' && window.performance
-            ? window.performance.now()
-            : now;
-        const random = Math.random();
-        // Create initial seed from timestamp and random
-        let seed = now + performance + random;
-        // 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++) {
-            // 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();
-                // 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 >>> PRNG_CONSTANTS.BYTE_SHIFT) & PRNG_CONSTANTS.BYTE_MASK);
-        }
-        return entropy;
-    }
-    /**
-     * Securely generate ephemeral key pair with proper entropy
-     * React Native compatible version with multiple fallbacks
-     * @returns Ephemeral key pair with private and public keys
-     * @throws Error if key generation fails
-     */
-    generateEphemeralKeyPair() {
-        try {
-            let seed;
-            // Try multiple approaches for mobile compatibility
-            try {
-                // Method 1: Try nacl.randomBytes first
-                seed = nacl.randomBytes(CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH);
-            }
-            catch (naclError) {
-                try {
-                    // Method 2: Use crypto.getRandomValues if available (browsers/React Native)
-                    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
-                        seed = new Uint8Array(CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH);
-                        crypto.getRandomValues(seed);
-                    }
-                    else {
-                        throw new Error('crypto.getRandomValues not available');
-                    }
-                }
-                catch (cryptoError) {
-                    // Method 3: Fallback to secure pseudo-random generation
-                    const entropy = this.generateSecureEntropy();
-                    seed = new Uint8Array(entropy);
-                }
-            }
-            // Validate seed length
-            if (seed.length !== CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH) {
-                throw new Error(`Invalid seed length: expected ${CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH}, got ${seed.length}`);
-            }
-            // Generate key pair from seed
-            const keyPair = nacl.sign.keyPair.fromSeed(seed);
-            const publicKeyBytes = keyPair.publicKey;
-            // Validate public key
-            if (publicKeyBytes.length !== CRYPTO_CONSTANTS.ED25519_PUBLIC_KEY_LENGTH) {
-                throw new Error(`Invalid public key length: expected ${CRYPTO_CONSTANTS.ED25519_PUBLIC_KEY_LENGTH}, got ${publicKeyBytes.length}`);
-            }
-            // Convert private key to PKCS#8 format
-            const privateKeyHex = this.rawEd25519ToPkcs8Hex(BufferCompat.from(seed));
-            // Clear sensitive data
-            seed.fill(0);
-            keyPair.secretKey.fill(0);
-            return {
-                privateKey: privateKeyHex,
-                publicKey: bs58.encode(publicKeyBytes),
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to generate ephemeral key pair: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    getAddressFromUserId(userId) {
-        // Use crypto-js for SHA-256 in React Native
-        const hash = CryptoJS.SHA256(userId).toString(CryptoJS.enc.Hex);
-        const hashBuffer = BufferCompat.from(hash, 'hex');
-        return bs58.encode(hashBuffer);
-    }
-    /**
-     * Create and sign a transaction message
-     */
-    createAndSignTx(params) {
-        if (!this.validateAddress(params.sender)) {
-            throw new Error('Invalid sender address');
-        }
-        if (!this.validateAddress(params.recipient)) {
-            throw new Error('Invalid recipient address');
-        }
-        if (params.sender === params.recipient) {
-            throw new Error('Sender and recipient addresses cannot be the same');
-        }
-        const txMsg = {
-            type: params.type,
-            sender: params.sender,
-            recipient: params.recipient,
-            amount: params.amount,
-            timestamp: params.timestamp || Date.now(),
-            text_data: params.textData || '',
-            nonce: params.nonce,
-            extra_info: JSON.stringify(params.extraInfo) || '',
-            zk_proof: params.zkProof || '',
-            zk_pub: params.zkPub || '',
-        };
-        const signature = this.signTransaction(txMsg, params.privateKey);
-        return {
-            tx_msg: txMsg,
-            signature,
-        };
-    }
-    /**
-     * Securely sign a transaction with Ed25519
-     * @param tx - Transaction message to sign
-     * @param privateKeyHex - Private key in PKCS#8 hex format
-     * @returns Base58 encoded signature
-     * @throws Error if signing fails
-     */
-    signTransaction(tx, privateKeyHex) {
-        try {
-            // Validate inputs
-            if (!tx || typeof tx !== 'object') {
-                throw new Error('Invalid transaction object');
-            }
-            if (!privateKeyHex || typeof privateKeyHex !== 'string') {
-                throw new Error('Invalid private key format');
-            }
-            // Serialize transaction data
-            const serializedData = this.serializeTransaction(tx);
-            if (!serializedData || serializedData.length === 0) {
-                throw new Error('Failed to serialize transaction');
-            }
-            // Extract the Ed25519 seed from the private key for nacl signing
-            const privateKeyDer = BufferCompat.from(privateKeyHex, 'hex');
-            if (privateKeyDer.length < CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH) {
-                throw new Error(`Invalid private key length: expected at least ${CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH} bytes, got ${privateKeyDer.length}`);
-            }
-            const seed = privateKeyDer.subarray(-CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH); // Last 32 bytes
-            const keyPair = nacl.sign.keyPair.fromSeed(seed);
-            // Validate key pair
-            if (!keyPair.publicKey || !keyPair.secretKey) {
-                throw new Error('Failed to create key pair from seed');
-            }
-            // Sign using Ed25519 (nacl) - constant time operation
-            const signature = nacl.sign.detached(serializedData, keyPair.secretKey);
-            if (!signature || signature.length === 0) {
-                throw new Error('Failed to generate signature');
-            }
-            // Clear sensitive data
-            privateKeyDer.fill(0);
-            seed.fill(0);
-            keyPair.secretKey.fill(0);
-            // Return signature based on transaction type
-            if (tx.type === TX_TYPE.PRIVATE_KEY) {
-                return bs58.encode(BufferCompat.from(signature));
-            }
-            // For regular transactions, wrap signature with public key
-            const userSig = {
-                PubKey: BufferCompat.from(keyPair.publicKey).toString('base64'),
-                Sig: BufferCompat.from(signature).toString('base64'),
-            };
-            return bs58.encode(BufferCompat.from(JSON.stringify(userSig)));
-        }
-        catch (error) {
-            throw new Error(`Transaction signing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * Serialize transaction for signing
-     */
-    serializeTransaction(tx) {
-        const data = `${tx.type}|${tx.sender}|${tx.recipient}|${tx.amount}|${tx.text_data}|${tx.nonce}|${tx.extra_info}`;
-        return BufferCompat.from(data, 'utf8');
-    }
-    /**
-     * Add a signed transaction to the blockchain
-     */
-    async addTx(signedTx) {
-        return this.makeRequest('tx.addtx', signedTx);
-    }
-    /**
-     * Send a transaction (create, sign, and submit)
-     */
-    async sendTransaction(params) {
-        const fromAddress = this.getAddressFromUserId(params.sender);
-        const toAddress = this.getAddressFromUserId(params.recipient);
-        const signedTx = this.createAndSignTx({
-            ...params,
-            type: TX_TYPE.TRANSFER,
-            sender: fromAddress,
-            recipient: toAddress,
-        });
-        return this.addTx(signedTx);
-    }
-    async sendTransactionByAddress(params) {
-        const signedTx = this.createAndSignTx({
-            ...params,
-            type: TX_TYPE.TRANSFER,
-        });
-        return this.addTx(signedTx);
-    }
-    async sendTransactionByPrivateKey(params) {
-        const signedTx = this.createAndSignTx({
-            ...params,
-            type: TX_TYPE.PRIVATE_KEY,
-        });
-        return this.addTx(signedTx);
-    }
-    /**
-     * Get current nonce for an account
-     */
-    async getCurrentNonce(userId, tag = 'latest') {
-        const address = this.getAddressFromUserId(userId);
-        return this.makeRequest('account.getcurrentnonce', { address, tag });
-    }
-    async getAccountByUserId(userId) {
-        const address = this.getAddressFromUserId(userId);
-        return this.makeRequest('account.getaccount', {
-            address,
-        });
-    }
-    scaleAmountToDecimals(originalAmount, decimals = DECIMALS) {
-        let scaledAmount = BigInt(originalAmount);
-        for (let i = 0; i < decimals; i++) {
-            scaledAmount = scaledAmount * BigInt(10);
-        }
-        return scaledAmount.toString();
-    }
-    validateAddress(addr) {
-        const decoded = bs58.decode(addr);
-        if (!decoded ||
-            decoded.length !== CRYPTO_CONSTANTS.ED25519_PUBLIC_KEY_LENGTH) {
-            return false;
-        }
-        return true;
-    }
-    validateAmount(balance, amount) {
-        const bigBalance = BigInt(balance);
-        const bigAmount = BigInt(typeof amount === 'number' ? this.scaleAmountToDecimals(amount) : amount);
-        return bigAmount <= bigBalance;
-    }
-}
-function createMmnClient(config) {
-    return new MmnClient(config);
+var CryptoJS = cryptoJs.exports;
+
+// MMN Client
+// Buffer polyfill for mobile environments
+class BufferPolyfill {
+    static isBuffer(obj) {
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer) {
+            return Buffer.isBuffer(obj);
+        }
+        return obj instanceof Uint8Array;
+    }
+    static from(data, encoding) {
+        if (typeof Buffer !== 'undefined' && Buffer.from) {
+            return Buffer.from(data, encoding);
+        }
+        let result;
+        if (Array.isArray(data)) {
+            result = new Uint8Array(data);
+        }
+        else if (typeof data === 'string') {
+            if (encoding === 'hex') {
+                const bytes = [];
+                for (let i = 0; i < data.length; i += 2) {
+                    bytes.push(parseInt(data.substr(i, 2), 16));
+                }
+                result = new Uint8Array(bytes);
+            }
+            else {
+                // UTF-8 encoding
+                const encoder = new TextEncoder();
+                result = encoder.encode(data);
+            }
+        }
+        else if (data instanceof Uint8Array) {
+            result = data;
+        }
+        else {
+            result = new Uint8Array(data);
+        }
+        // Add toString method
+        result.toString = function (encoding) {
+            if (encoding === 'hex') {
+                return Array.from(this)
+                    .map((b) => b.toString(16).padStart(2, '0'))
+                    .join('');
+            }
+            else if (encoding === 'base64') {
+                // Simple base64 encoding
+                const bytes = this;
+                let binary = '';
+                for (let i = 0; i < bytes.length; i++) {
+                    binary += String.fromCharCode(bytes[i]);
+                }
+                return btoa(binary);
+            }
+            else {
+                // UTF-8 decoding
+                const decoder = new TextDecoder();
+                return decoder.decode(this);
+            }
+        };
+        return result;
+    }
+    static concat(arrays) {
+        if (typeof Buffer !== 'undefined' && Buffer.concat) {
+            return Buffer.concat(arrays);
+        }
+        const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const arr of arrays) {
+            result.set(arr, offset);
+            offset += arr.length;
+        }
+        // Add toString method
+        result.toString = function (encoding) {
+            if (encoding === 'hex') {
+                return Array.from(this)
+                    .map((b) => b.toString(16).padStart(2, '0'))
+                    .join('');
+            }
+            else {
+                const decoder = new TextDecoder();
+                return decoder.decode(this);
+            }
+        };
+        return result;
+    }
+}
+// Use polyfill if Buffer is not available
+const BufferCompat = typeof Buffer !== 'undefined' ? Buffer : BufferPolyfill;
+// Cryptographic constants
+const CRYPTO_CONSTANTS = {
+    ED25519_PRIVATE_KEY_LENGTH: 32,
+    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,
+    PKCS8_PRIVATE_KEY_OCTET_OUTER_LENGTH: 0x22,
+    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_INCREMENT: 1013904223,
+    LCG_MODULUS: 4294967296,
+    TIMESTAMP_MULTIPLIER: 2654435761,
+    HASH_SUBSTRING_LENGTH: 8,
+    BYTE_SHIFT: 24,
+    BYTE_MASK: 0xff,
+};
+const TX_TYPE = {
+    TRANSFER: 0,
+    PRIVATE_KEY: 1,
+};
+const DECIMALS = 6;
+class MmnClient {
+    constructor(config) {
+        this.requestId = 0;
+        this.config = {
+            timeout: 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            ...config,
+        };
+    }
+    async makeRequest(method, params) {
+        const request = {
+            jsonrpc: '2.0',
+            method,
+            params,
+            id: ++this.requestId,
+        };
+        // Create AbortController for timeout
+        const controller = new AbortControllerPolyfill();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout || 30000);
+        try {
+            const requestOptions = {
+                method: 'POST',
+                mode: 'cors',
+                credentials: 'omit',
+                signal: controller.signal,
+                headers: this.config.headers || {},
+                body: JSON.stringify(request),
+            };
+            const response = await fetchPolyfill(this.config.baseUrl, requestOptions);
+            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) {
+            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');
+        }
+    }
+    /**
+     * Securely convert raw Ed25519 private key to PKCS#8 format
+     * @param raw - Raw 32-byte Ed25519 private key
+     * @returns PKCS#8 formatted private key in hex
+     * @throws Error if input validation fails
+     */
+    rawEd25519ToPkcs8Hex(raw) {
+        // Input validation
+        if (!BufferCompat.isBuffer(raw)) {
+            throw new Error('Private key must be a Buffer');
+        }
+        if (raw.length !== CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH) {
+            throw new Error(`Ed25519 private key must be exactly ${CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH} bytes`);
+        }
+        try {
+            // 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,
+                CRYPTO_CONSTANTS.PKCS8_VERSION,
+            ]);
+            // Create algorithm identifier sequence (AlgorithmIdentifier)
+            const algorithmId = BufferCompat.concat([
+                BufferCompat.from([
+                    CRYPTO_CONSTANTS.ASN1_SEQUENCE_TAG,
+                    CRYPTO_CONSTANTS.PKCS8_ALGORITHM_ID_LENGTH,
+                ]),
+                ED25519_OID,
+            ]);
+            // Create private key octet string (wrapped Ed25519 private key)
+            const privateKeyOctetString = BufferCompat.concat([
+                BufferCompat.from([
+                    CRYPTO_CONSTANTS.ASN1_OCTET_STRING_TAG,
+                    CRYPTO_CONSTANTS.PKCS8_PRIVATE_KEY_OCTET_OUTER_LENGTH,
+                ]),
+                BufferCompat.from([
+                    CRYPTO_CONSTANTS.ASN1_OCTET_STRING_TAG,
+                    CRYPTO_CONSTANTS.PKCS8_PRIVATE_KEY_OCTET_INNER_LENGTH,
+                ]),
+                raw,
+            ]);
+            // Create PKCS#8 body
+            const pkcs8Body = BufferCompat.concat([
+                VERSION_BYTES,
+                algorithmId,
+                privateKeyOctetString,
+            ]);
+            // Create final PKCS#8 structure
+            const pkcs8 = BufferCompat.concat([
+                BufferCompat.from([CRYPTO_CONSTANTS.ASN1_SEQUENCE_TAG]),
+                this.encodeLength(pkcs8Body.length),
+                pkcs8Body,
+            ]);
+            const result = pkcs8.toString('hex');
+            // Clear sensitive data from memory
+            raw.fill(0);
+            privateKeyOctetString.fill(0);
+            pkcs8Body.fill(0);
+            pkcs8.fill(0);
+            return result;
+        }
+        catch (error) {
+            // Clear sensitive data on error
+            raw.fill(0);
+            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 < CRYPTO_CONSTANTS.ASN1_LENGTH) {
+            return BufferCompat.from([length]);
+        }
+        const bytes = [];
+        let len = length;
+        while (len > 0) {
+            bytes.unshift(len & PRNG_CONSTANTS.BYTE_MASK);
+            len >>= 8;
+        }
+        return BufferCompat.from([
+            CRYPTO_CONSTANTS.ASN1_LENGTH | bytes.length,
+            ...bytes,
+        ]);
+    }
+    /**
+     * Generate secure entropy using multiple sources for maximum compatibility
+     * @returns Array of 32 random bytes
+     */
+    generateSecureEntropy() {
+        const entropy = [];
+        const targetLength = CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH;
+        // Use multiple entropy sources
+        const now = Date.now();
+        const performance = typeof window !== 'undefined' && window.performance
+            ? window.performance.now()
+            : now;
+        const random = Math.random();
+        // Create initial seed from timestamp and random
+        let seed = now + performance + random;
+        // 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++) {
+            // 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();
+                // 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 >>> PRNG_CONSTANTS.BYTE_SHIFT) & PRNG_CONSTANTS.BYTE_MASK);
+        }
+        return entropy;
+    }
+    /**
+     * Securely generate ephemeral key pair with proper entropy
+     * React Native compatible version with multiple fallbacks
+     * @returns Ephemeral key pair with private and public keys
+     * @throws Error if key generation fails
+     */
+    generateEphemeralKeyPair() {
+        try {
+            let seed;
+            // Try multiple approaches for mobile compatibility
+            try {
+                // Method 1: Try nacl.randomBytes first
+                seed = nacl.randomBytes(CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH);
+            }
+            catch (naclError) {
+                try {
+                    // Method 2: Use crypto.getRandomValues if available (browsers/React Native)
+                    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+                        seed = new Uint8Array(CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH);
+                        crypto.getRandomValues(seed);
+                    }
+                    else {
+                        throw new Error('crypto.getRandomValues not available');
+                    }
+                }
+                catch (cryptoError) {
+                    // Method 3: Fallback to secure pseudo-random generation
+                    const entropy = this.generateSecureEntropy();
+                    seed = new Uint8Array(entropy);
+                }
+            }
+            // Validate seed length
+            if (seed.length !== CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH) {
+                throw new Error(`Invalid seed length: expected ${CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH}, got ${seed.length}`);
+            }
+            // Generate key pair from seed
+            const keyPair = nacl.sign.keyPair.fromSeed(seed);
+            const publicKeyBytes = keyPair.publicKey;
+            // Validate public key
+            if (publicKeyBytes.length !== CRYPTO_CONSTANTS.ED25519_PUBLIC_KEY_LENGTH) {
+                throw new Error(`Invalid public key length: expected ${CRYPTO_CONSTANTS.ED25519_PUBLIC_KEY_LENGTH}, got ${publicKeyBytes.length}`);
+            }
+            // Convert private key to PKCS#8 format
+            const privateKeyHex = this.rawEd25519ToPkcs8Hex(BufferCompat.from(seed));
+            // Clear sensitive data
+            seed.fill(0);
+            keyPair.secretKey.fill(0);
+            return {
+                privateKey: privateKeyHex,
+                publicKey: bs58.encode(publicKeyBytes),
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to generate ephemeral key pair: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    getAddressFromUserId(userId) {
+        // Use crypto-js for SHA-256 in React Native
+        const hash = CryptoJS.SHA256(userId).toString(CryptoJS.enc.Hex);
+        const hashBuffer = BufferCompat.from(hash, 'hex');
+        return bs58.encode(hashBuffer);
+    }
+    /**
+     * Create and sign a transaction message
+     */
+    createAndSignTx(params) {
+        if (!this.validateAddress(params.sender)) {
+            throw new Error('Invalid sender address');
+        }
+        if (!this.validateAddress(params.recipient)) {
+            throw new Error('Invalid recipient address');
+        }
+        if (params.sender === params.recipient) {
+            throw new Error('Sender and recipient addresses cannot be the same');
+        }
+        const txMsg = {
+            type: params.type,
+            sender: params.sender,
+            recipient: params.recipient,
+            amount: params.amount,
+            timestamp: params.timestamp || Date.now(),
+            text_data: params.textData || '',
+            nonce: params.nonce,
+            extra_info: JSON.stringify(params.extraInfo) || '',
+            zk_proof: params.zkProof || '',
+            zk_pub: params.zkPub || '',
+        };
+        const signature = this.signTransaction(txMsg, params.privateKey);
+        return {
+            tx_msg: txMsg,
+            signature,
+        };
+    }
+    /**
+     * Securely sign a transaction with Ed25519
+     * @param tx - Transaction message to sign
+     * @param privateKeyHex - Private key in PKCS#8 hex format
+     * @returns Base58 encoded signature
+     * @throws Error if signing fails
+     */
+    signTransaction(tx, privateKeyHex) {
+        try {
+            // Validate inputs
+            if (!tx || typeof tx !== 'object') {
+                throw new Error('Invalid transaction object');
+            }
+            if (!privateKeyHex || typeof privateKeyHex !== 'string') {
+                throw new Error('Invalid private key format');
+            }
+            // Serialize transaction data
+            const serializedData = this.serializeTransaction(tx);
+            if (!serializedData || serializedData.length === 0) {
+                throw new Error('Failed to serialize transaction');
+            }
+            // Extract the Ed25519 seed from the private key for nacl signing
+            const privateKeyDer = BufferCompat.from(privateKeyHex, 'hex');
+            if (privateKeyDer.length < CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH) {
+                throw new Error(`Invalid private key length: expected at least ${CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH} bytes, got ${privateKeyDer.length}`);
+            }
+            const seed = privateKeyDer.subarray(-CRYPTO_CONSTANTS.ED25519_PRIVATE_KEY_LENGTH); // Last 32 bytes
+            const keyPair = nacl.sign.keyPair.fromSeed(seed);
+            // Validate key pair
+            if (!keyPair.publicKey || !keyPair.secretKey) {
+                throw new Error('Failed to create key pair from seed');
+            }
+            // Sign using Ed25519 (nacl) - constant time operation
+            const signature = nacl.sign.detached(serializedData, keyPair.secretKey);
+            if (!signature || signature.length === 0) {
+                throw new Error('Failed to generate signature');
+            }
+            // Clear sensitive data
+            privateKeyDer.fill(0);
+            seed.fill(0);
+            keyPair.secretKey.fill(0);
+            // Return signature based on transaction type
+            if (tx.type === TX_TYPE.PRIVATE_KEY) {
+                return bs58.encode(BufferCompat.from(signature));
+            }
+            // For regular transactions, wrap signature with public key
+            const userSig = {
+                PubKey: BufferCompat.from(keyPair.publicKey).toString('base64'),
+                Sig: BufferCompat.from(signature).toString('base64'),
+            };
+            return bs58.encode(BufferCompat.from(JSON.stringify(userSig)));
+        }
+        catch (error) {
+            throw new Error(`Transaction signing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Serialize transaction for signing
+     */
+    serializeTransaction(tx) {
+        const data = `${tx.type}|${tx.sender}|${tx.recipient}|${tx.amount}|${tx.text_data}|${tx.nonce}|${tx.extra_info}`;
+        return BufferCompat.from(data, 'utf8');
+    }
+    /**
+     * Add a signed transaction to the blockchain
+     */
+    async addTx(signedTx) {
+        return this.makeRequest('tx.addtx', signedTx);
+    }
+    /**
+     * Send a transaction (create, sign, and submit)
+     */
+    async sendTransaction(params) {
+        const fromAddress = this.getAddressFromUserId(params.sender);
+        const toAddress = this.getAddressFromUserId(params.recipient);
+        const signedTx = this.createAndSignTx({
+            ...params,
+            type: TX_TYPE.TRANSFER,
+            sender: fromAddress,
+            recipient: toAddress,
+        });
+        return this.addTx(signedTx);
+    }
+    async sendTransactionByAddress(params) {
+        const signedTx = this.createAndSignTx({
+            ...params,
+            type: TX_TYPE.TRANSFER,
+        });
+        return this.addTx(signedTx);
+    }
+    async sendTransactionByPrivateKey(params) {
+        const signedTx = this.createAndSignTx({
+            ...params,
+            type: TX_TYPE.PRIVATE_KEY,
+        });
+        return this.addTx(signedTx);
+    }
+    /**
+     * Get current nonce for an account
+     */
+    async getCurrentNonce(userId, tag = 'latest') {
+        const address = this.getAddressFromUserId(userId);
+        return this.makeRequest('account.getcurrentnonce', { address, tag });
+    }
+    async getAccountByUserId(userId) {
+        const address = this.getAddressFromUserId(userId);
+        return this.makeRequest('account.getaccount', {
+            address,
+        });
+    }
+    scaleAmountToDecimals(originalAmount, decimals = DECIMALS) {
+        let scaledAmount = BigInt(originalAmount);
+        for (let i = 0; i < decimals; i++) {
+            scaledAmount = scaledAmount * BigInt(10);
+        }
+        return scaledAmount.toString();
+    }
+    validateAddress(addr) {
+        const decoded = bs58.decode(addr);
+        if (!decoded ||
+            decoded.length !== CRYPTO_CONSTANTS.ED25519_PUBLIC_KEY_LENGTH) {
+            return false;
+        }
+        return true;
+    }
+    validateAmount(balance, amount) {
+        const bigBalance = BigInt(balance);
+        const bigAmount = BigInt(typeof amount === 'number' ? this.scaleAmountToDecimals(amount) : amount);
+        return bigAmount <= bigBalance;
+    }
+}
+function createMmnClient(config) {
+    return new MmnClient(config);
 }
 
-// --- JSON-RPC Types ---
-var ETransferType;
-(function (ETransferType) {
-    ETransferType["GiveCoffee"] = "give_coffee";
-    ETransferType["TransferToken"] = "transfer_token";
-    ETransferType["UnlockItem"] = "unlock_item";
-})(ETransferType || (ETransferType = {}));
-var EZkClientType;
-(function (EZkClientType) {
-    EZkClientType["MEZON"] = "mezon";
-    EZkClientType["OAUTH"] = "oauth";
+// --- JSON-RPC Types ---
+var ETransferType;
+(function (ETransferType) {
+    ETransferType["GiveCoffee"] = "give_coffee";
+    ETransferType["TransferToken"] = "transfer_token";
+    ETransferType["UnlockItem"] = "unlock_item";
+})(ETransferType || (ETransferType = {}));
+var EZkClientType;
+(function (EZkClientType) {
+    EZkClientType["MEZON"] = "mezon";
+    EZkClientType["OAUTH"] = "oauth";
 })(EZkClientType || (EZkClientType = {}));
 
-class ZkClient {
-    constructor(config) {
-        this.endpoint = config.endpoint;
-        this.timeout = config.timeout || 30000;
-        this.headers = {
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-            ...(config.headers || {}),
-        };
-    }
-    async makeRequest(method, path, params, body) {
-        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, clientType = EZkClientType.MEZON, }) {
-        const path = `prove`;
-        const res = await this.makeRequest('POST', path, undefined, {
-            user_id: userId,
-            ephemeral_pk: ephemeralPublicKey,
-            jwt,
-            address,
-            client_type: clientType,
-        });
-        return res.data;
-    }
+class ZkClient {
+    constructor(config) {
+        this.endpoint = config.endpoint;
+        this.timeout = config.timeout || 30000;
+        this.headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            ...(config.headers || {}),
+        };
+    }
+    async makeRequest(method, path, params, body) {
+        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 AbortControllerPolyfill();
+        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 fetchPolyfill(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, clientType = EZkClientType.MEZON, }) {
+        const path = `prove`;
+        const res = await this.makeRequest('POST', path, undefined, {
+            user_id: userId,
+            ephemeral_pk: ephemeralPublicKey,
+            jwt,
+            address,
+            client_type: clientType,
+        });
+        return res.data;
+    }
 }
 
 export { ETransferType, EZkClientType, IndexerClient, MmnClient, ZkClient, createMmnClient };