@amadeus-protocol/sdk 1.0.8 → 1.1.0

package/dist/encoding.js

@@ -1,165 +1,144 @@
+import bs58 from "bs58";
+//#region src/encoding.ts
 /**
- * Encoding/Decoding Utilities
- *
- * Provides general-purpose encoding and decoding functions for converting
- * between different binary formats (Uint8Array, ArrayBuffer, Base64, Base58)
- */
-import bs58 from 'bs58';
-// ============================================================================
-// Base64 Encoding/Decoding
-// ============================================================================
+* Encoding/Decoding Utilities
+*
+* Provides general-purpose encoding and decoding functions for converting
+* between different binary formats (Uint8Array, ArrayBuffer, Base64, Base58)
+*/
 /**
- * Check if Buffer is available (Node.js environment)
- */
+* Check if Buffer is available (Node.js environment)
+*/
 function isBufferAvailable() {
-    return typeof Buffer !== 'undefined' && Buffer.from !== undefined;
+	return typeof Buffer !== "undefined" && Buffer.from !== void 0;
 }
 /**
- * Convert Uint8Array to Base64 string
- *
- * Uses Node.js Buffer when available (more efficient), falls back to btoa for browsers.
- *
- * @param bytes - Bytes to encode
- * @returns Base64 encoded string
- *
- * @example
- * ```ts
- * const base64 = uint8ArrayToBase64(new Uint8Array([1, 2, 3]))
- * ```
- */
-export function uint8ArrayToBase64(bytes) {
-    if (isBufferAvailable()) {
-        // Node.js: Use Buffer for better performance
-        return Buffer.from(bytes).toString('base64');
-    }
-    // Browser: Use btoa (available in Node.js 18+ and all modern browsers)
-    let binary = '';
-    for (let i = 0; i < bytes.byteLength; i++) {
-        binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
+* Convert Uint8Array to Base64 string
+*
+* Uses Node.js Buffer when available (more efficient), falls back to btoa for browsers.
+*
+* @param bytes - Bytes to encode
+* @returns Base64 encoded string
+*
+* @example
+* ```ts
+* const base64 = uint8ArrayToBase64(new Uint8Array([1, 2, 3]))
+* ```
+*/
+function uint8ArrayToBase64(bytes) {
+	if (isBufferAvailable()) return Buffer.from(bytes).toString("base64");
+	let binary = "";
+	for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary);
 }
 /**
- * Convert Base64 string to Uint8Array
- *
- * Uses Node.js Buffer when available (more efficient), falls back to atob for browsers.
- *
- * @param base64 - Base64 encoded string
- * @returns Decoded bytes
- *
- * @example
- * ```ts
- * const bytes = base64ToUint8Array('AQID')
- * ```
- */
-export function base64ToUint8Array(base64) {
-    if (isBufferAvailable()) {
-        // Node.js: Use Buffer for better performance
-        return new Uint8Array(Buffer.from(base64, 'base64'));
-    }
-    // Browser: Use atob (available in Node.js 18+ and all modern browsers)
-    const binaryString = atob(base64);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes;
+* Convert Base64 string to Uint8Array
+*
+* Uses Node.js Buffer when available (more efficient), falls back to atob for browsers.
+*
+* @param base64 - Base64 encoded string
+* @returns Decoded bytes
+*
+* @example
+* ```ts
+* const bytes = base64ToUint8Array('AQID')
+* ```
+*/
+function base64ToUint8Array(base64) {
+	if (isBufferAvailable()) return new Uint8Array(Buffer.from(base64, "base64"));
+	const binaryString = atob(base64);
+	const bytes = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+	return bytes;
 }
 /**
- * Convert ArrayBuffer to Base64 string
- *
- * @param buffer - Buffer to encode
- * @returns Base64 encoded string
- *
- * @example
- * ```ts
- * const base64 = arrayBufferToBase64(new ArrayBuffer(8))
- * ```
- */
-export function arrayBufferToBase64(buffer) {
-    const bytes = new Uint8Array(buffer);
-    return uint8ArrayToBase64(bytes);
+* Convert ArrayBuffer to Base64 string
+*
+* @param buffer - Buffer to encode
+* @returns Base64 encoded string
+*
+* @example
+* ```ts
+* const base64 = arrayBufferToBase64(new ArrayBuffer(8))
+* ```
+*/
+function arrayBufferToBase64(buffer) {
+	return uint8ArrayToBase64(new Uint8Array(buffer));
 }
 /**
- * Convert Base64 string to ArrayBuffer
- *
- * @param base64 - Base64 encoded string
- * @returns Decoded buffer
- *
- * @example
- * ```ts
- * const buffer = base64ToArrayBuffer('AQID')
- * ```
- */
-export function base64ToArrayBuffer(base64) {
-    const bytes = base64ToUint8Array(base64);
-    const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-    return buffer;
+* Convert Base64 string to ArrayBuffer
+*
+* @param base64 - Base64 encoded string
+* @returns Decoded buffer
+*
+* @example
+* ```ts
+* const buffer = base64ToArrayBuffer('AQID')
+* ```
+*/
+function base64ToArrayBuffer(base64) {
+	const bytes = base64ToUint8Array(base64);
+	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 }
-// ============================================================================
-// ArrayBuffer/Uint8Array Conversions
-// ============================================================================
 /**
- * Convert Uint8Array to ArrayBuffer
- *
- * @param bytes - The Uint8Array to convert
- * @returns ArrayBuffer
- *
- * @example
- * ```ts
- * const buffer = uint8ArrayToArrayBuffer(new Uint8Array([1, 2, 3]))
- * ```
- */
-export function uint8ArrayToArrayBuffer(bytes) {
-    if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
-        return bytes.buffer;
-    }
-    return bytes.slice().buffer;
+* Convert Uint8Array to ArrayBuffer
+*
+* @param bytes - The Uint8Array to convert
+* @returns ArrayBuffer
+*
+* @example
+* ```ts
+* const buffer = uint8ArrayToArrayBuffer(new Uint8Array([1, 2, 3]))
+* ```
+*/
+function uint8ArrayToArrayBuffer(bytes) {
+	if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) return bytes.buffer;
+	return bytes.slice().buffer;
 }
 /**
- * Convert ArrayBuffer to Uint8Array
- *
- * @param buffer - The ArrayBuffer to convert
- * @returns Uint8Array view of the buffer
- *
- * @example
- * ```ts
- * const bytes = arrayBufferToUint8Array(new ArrayBuffer(8))
- * ```
- */
-export function arrayBufferToUint8Array(buffer) {
-    return new Uint8Array(buffer);
+* Convert ArrayBuffer to Uint8Array
+*
+* @param buffer - The ArrayBuffer to convert
+* @returns Uint8Array view of the buffer
+*
+* @example
+* ```ts
+* const bytes = arrayBufferToUint8Array(new ArrayBuffer(8))
+* ```
+*/
+function arrayBufferToUint8Array(buffer) {
+	return new Uint8Array(buffer);
 }
-// ============================================================================
-// Base58 Encoding/Decoding
-// ============================================================================
 /**
- * Encode a Uint8Array to Base58 string
- *
- * @param buf - The bytes to encode
- * @returns Base58 encoded string
- *
- * @example
- * ```ts
- * const encoded = toBase58(new Uint8Array([1, 2, 3]))
- * ```
- */
-export function toBase58(buf) {
-    return bs58.encode(buf);
+* Encode a Uint8Array to Base58 string
+*
+* @param buf - The bytes to encode
+* @returns Base58 encoded string
+*
+* @example
+* ```ts
+* const encoded = toBase58(new Uint8Array([1, 2, 3]))
+* ```
+*/
+function toBase58(buf) {
+	return bs58.encode(buf);
 }
 /**
- * Decode a Base58 string to Uint8Array
- *
- * @param str - The Base58 string to decode
- * @returns Decoded bytes as Uint8Array
- * @throws Error if the string is invalid Base58
- *
- * @example
- * ```ts
- * const decoded = fromBase58('5Kd3N...')
- * ```
- */
-export function fromBase58(str) {
-    return bs58.decode(str);
+* Decode a Base58 string to Uint8Array
+*
+* @param str - The Base58 string to decode
+* @returns Decoded bytes as Uint8Array
+* @throws Error if the string is invalid Base58
+*
+* @example
+* ```ts
+* const decoded = fromBase58('5Kd3N...')
+* ```
+*/
+function fromBase58(str) {
+	return bs58.decode(str);
 }
+//#endregion
+export { arrayBufferToBase64, arrayBufferToUint8Array, base64ToArrayBuffer, base64ToUint8Array, fromBase58, toBase58, uint8ArrayToArrayBuffer, uint8ArrayToBase64 };
+
 //# sourceMappingURL=encoding.js.map

package/dist/encoding.js.map

@@ -1 +1 @@
-{"version":3,"file":"encoding.js","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"encoding.js","names":[],"sources":["../src/encoding.ts"],"sourcesContent":["/**\n * Encoding/Decoding Utilities\n *\n * Provides general-purpose encoding and decoding functions for converting\n * between different binary formats (Uint8Array, ArrayBuffer, Base64, Base58)\n */\n\nimport bs58 from 'bs58'\n\n// ============================================================================\n// Base64 Encoding/Decoding\n// ============================================================================\n\n/**\n * Check if Buffer is available (Node.js environment)\n */\nfunction isBufferAvailable(): boolean {\n\treturn typeof Buffer !== 'undefined' && Buffer.from !== undefined\n}\n\n/**\n * Convert Uint8Array to Base64 string\n *\n * Uses Node.js Buffer when available (more efficient), falls back to btoa for browsers.\n *\n * @param bytes - Bytes to encode\n * @returns Base64 encoded string\n *\n * @example\n * ```ts\n * const base64 = uint8ArrayToBase64(new Uint8Array([1, 2, 3]))\n * ```\n */\nexport function uint8ArrayToBase64(bytes: Uint8Array): string {\n\tif (isBufferAvailable()) {\n\t\t// Node.js: Use Buffer for better performance\n\t\treturn Buffer.from(bytes).toString('base64')\n\t}\n\t// Browser: Use btoa (available in Node.js 18+ and all modern browsers)\n\tlet binary = ''\n\tfor (let i = 0; i < bytes.byteLength; i++) {\n\t\tbinary += String.fromCharCode(bytes[i])\n\t}\n\treturn btoa(binary)\n}\n\n/**\n * Convert Base64 string to Uint8Array\n *\n * Uses Node.js Buffer when available (more efficient), falls back to atob for browsers.\n *\n * @param base64 - Base64 encoded string\n * @returns Decoded bytes\n *\n * @example\n * ```ts\n * const bytes = base64ToUint8Array('AQID')\n * ```\n */\nexport function base64ToUint8Array(base64: string): Uint8Array {\n\tif (isBufferAvailable()) {\n\t\t// Node.js: Use Buffer for better performance\n\t\treturn new Uint8Array(Buffer.from(base64, 'base64'))\n\t}\n\t// Browser: Use atob (available in Node.js 18+ and all modern browsers)\n\tconst binaryString = atob(base64)\n\tconst bytes = new Uint8Array(binaryString.length)\n\tfor (let i = 0; i < binaryString.length; i++) {\n\t\tbytes[i] = binaryString.charCodeAt(i)\n\t}\n\treturn bytes\n}\n\n/**\n * Convert ArrayBuffer to Base64 string\n *\n * @param buffer - Buffer to encode\n * @returns Base64 encoded string\n *\n * @example\n * ```ts\n * const base64 = arrayBufferToBase64(new ArrayBuffer(8))\n * ```\n */\nexport function arrayBufferToBase64(buffer: ArrayBuffer): string {\n\tconst bytes = new Uint8Array(buffer)\n\treturn uint8ArrayToBase64(bytes)\n}\n\n/**\n * Convert Base64 string to ArrayBuffer\n *\n * @param base64 - Base64 encoded string\n * @returns Decoded buffer\n *\n * @example\n * ```ts\n * const buffer = base64ToArrayBuffer('AQID')\n * ```\n */\nexport function base64ToArrayBuffer(base64: string): ArrayBuffer {\n\tconst bytes = base64ToUint8Array(base64)\n\tconst buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)\n\treturn buffer as ArrayBuffer\n}\n\n// ============================================================================\n// ArrayBuffer/Uint8Array Conversions\n// ============================================================================\n\n/**\n * Convert Uint8Array to ArrayBuffer\n *\n * @param bytes - The Uint8Array to convert\n * @returns ArrayBuffer\n *\n * @example\n * ```ts\n * const buffer = uint8ArrayToArrayBuffer(new Uint8Array([1, 2, 3]))\n * ```\n */\nexport function uint8ArrayToArrayBuffer(bytes: Uint8Array): ArrayBuffer {\n\tif (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {\n\t\treturn bytes.buffer as ArrayBuffer\n\t}\n\treturn bytes.slice().buffer\n}\n\n/**\n * Convert ArrayBuffer to Uint8Array\n *\n * @param buffer - The ArrayBuffer to convert\n * @returns Uint8Array view of the buffer\n *\n * @example\n * ```ts\n * const bytes = arrayBufferToUint8Array(new ArrayBuffer(8))\n * ```\n */\nexport function arrayBufferToUint8Array(buffer: ArrayBuffer): Uint8Array {\n\treturn new Uint8Array(buffer)\n}\n\n// ============================================================================\n// Base58 Encoding/Decoding\n// ============================================================================\n\n/**\n * Encode a Uint8Array to Base58 string\n *\n * @param buf - The bytes to encode\n * @returns Base58 encoded string\n *\n * @example\n * ```ts\n * const encoded = toBase58(new Uint8Array([1, 2, 3]))\n * ```\n */\nexport function toBase58(buf: Uint8Array): string {\n\treturn bs58.encode(buf)\n}\n\n/**\n * Decode a Base58 string to Uint8Array\n *\n * @param str - The Base58 string to decode\n * @returns Decoded bytes as Uint8Array\n * @throws Error if the string is invalid Base58\n *\n * @example\n * ```ts\n * const decoded = fromBase58('5Kd3N...')\n * ```\n */\nexport function fromBase58(str: string): Uint8Array {\n\treturn bs58.decode(str)\n}\n"],"mappings":";;;;;;;;;;;AAgBA,SAAS,oBAA6B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,SAAS,KAAA;;;;;;;;;;;;;;;AAgBzD,SAAgB,mBAAmB,OAA2B;CAC7D,IAAI,mBAAmB,EAEtB,OAAO,OAAO,KAAK,MAAM,CAAC,SAAS,SAAS;CAG7C,IAAI,SAAS;CACb,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,YAAY,KACrC,UAAU,OAAO,aAAa,MAAM,GAAG;CAExC,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;AAgBpB,SAAgB,mBAAmB,QAA4B;CAC9D,IAAI,mBAAmB,EAEtB,OAAO,IAAI,WAAW,OAAO,KAAK,QAAQ,SAAS,CAAC;CAGrD,MAAM,eAAe,KAAK,OAAO;CACjC,MAAM,QAAQ,IAAI,WAAW,aAAa,OAAO;CACjD,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KACxC,MAAM,KAAK,aAAa,WAAW,EAAE;CAEtC,OAAO;;;;;;;;;;;;;AAcR,SAAgB,oBAAoB,QAA6B;CAEhE,OAAO,mBAAmB,IADR,WAAW,OACE,CAAC;;;;;;;;;;;;;AAcjC,SAAgB,oBAAoB,QAA6B;CAChE,MAAM,QAAQ,mBAAmB,OAAO;CAExC,OADe,MAAM,OAAO,MAAM,MAAM,YAAY,MAAM,aAAa,MAAM,WAChE;;;;;;;;;;;;;AAkBd,SAAgB,wBAAwB,OAAgC;CACvE,IAAI,MAAM,eAAe,KAAK,MAAM,eAAe,MAAM,OAAO,YAC/D,OAAO,MAAM;CAEd,OAAO,MAAM,OAAO,CAAC;;;;;;;;;;;;;AActB,SAAgB,wBAAwB,QAAiC;CACxE,OAAO,IAAI,WAAW,OAAO;;;;;;;;;;;;;AAkB9B,SAAgB,SAAS,KAAyB;CACjD,OAAO,KAAK,OAAO,IAAI;;;;;;;;;;;;;;AAexB,SAAgB,WAAW,KAAyB;CACnD,OAAO,KAAK,OAAO,IAAI"}

package/dist/encryption.d.ts

@@ -1,3 +1,4 @@
+//#region src/encryption.d.ts
 /**
  * Password-Based Encryption Utilities
  *
@@ -12,32 +13,32 @@
  * @param iterations - Number of PBKDF2 iterations (default: 100,000)
  * @returns Derived AES-GCM key
  */
-export declare function deriveKey(password: string, salt: Uint8Array | ArrayBuffer, iterations?: number): Promise<CryptoKey>;
+declare function deriveKey(password: string, salt: Uint8Array | ArrayBuffer, iterations?: number): Promise<CryptoKey>;
 /**
  * Generate a cryptographically secure random salt
  *
  * @returns Random salt (16 bytes)
  */
-export declare function generateSalt(): Uint8Array;
+declare function generateSalt(): Uint8Array;
 /**
  * Generate a cryptographically secure random initialization vector
  *
  * @returns Random IV (12 bytes)
  */
-export declare function generateIV(): Uint8Array;
+declare function generateIV(): Uint8Array;
 /**
  * Encrypted data payload (Base64 encoded)
  *
  * Uses Base64 encoding for binary payloads like vaults (more efficient than Base58).
  * Base58 is reserved for addresses, keys, and hashes.
  */
-export interface EncryptedPayload {
-    /** Encrypted data (Base64 encoded) */
-    encryptedData: string;
-    /** Initialization vector (Base64 encoded) */
-    iv: string;
-    /** Salt used for key derivation (Base64 encoded) */
-    salt: string;
+interface EncryptedPayload {
+  /** Encrypted data (Base64 encoded) */
+  encryptedData: string;
+  /** Initialization vector (Base64 encoded) */
+  iv: string;
+  /** Salt used for key derivation (Base64 encoded) */
+  salt: string;
 }
 /**
  * Encrypt plaintext with a password using AES-GCM
@@ -58,7 +59,7 @@ export interface EncryptedPayload {
  * // Store encrypted.encryptedData, encrypted.iv, encrypted.salt
  * ```
  */
-export declare function encryptWithPassword(plaintext: string, password: string): Promise<EncryptedPayload>;
+declare function encryptWithPassword(plaintext: string, password: string): Promise<EncryptedPayload>;
 /**
  * Decrypt encrypted data with a password
  *
@@ -72,5 +73,7 @@ export declare function encryptWithPassword(plaintext: string, password: string)
  * const decrypted = await decryptWithPassword(encrypted, 'my-password')
  * ```
  */
-export declare function decryptWithPassword(payload: EncryptedPayload, password: string): Promise<string>;
+declare function decryptWithPassword(payload: EncryptedPayload, password: string): Promise<string>;
+//#endregion
+export { EncryptedPayload, decryptWithPassword, deriveKey, encryptWithPassword, generateIV, generateSalt };
 //# sourceMappingURL=encryption.d.ts.map

package/dist/encryption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAqCH;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC9B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,GAAG,WAAW,EAC9B,UAAU,GAAE,MAA0B,GACpC,OAAO,CAAC,SAAS,CAAC,CAgBpB;AAMD;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,UAAU,CAIzC;AAED;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,UAAU,CAIvC;AAMD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAChC,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAA;IACrB,6CAA6C;IAC7C,EAAE,EAAE,MAAM,CAAA;IACV,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;CACZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,mBAAmB,CACxC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,CAAC,CAkB3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,CAgBjB"}
+{"version":3,"file":"encryption.d.ts","names":[],"sources":["../src/encryption.ts"],"mappings":";;AAkDA;;;;;;;;;;;;;iBAAsB,SAAA,CACrB,QAAA,UACA,IAAA,EAAM,UAAA,GAAa,WAAA,EACnB,UAAA,YACE,OAAA,CAAQ,SAAA;;;;;AA2BX;iBAAgB,YAAA,CAAA,GAAgB,UAAA;;;;AAWhC;;iBAAgB,UAAA,CAAA,GAAc,UAAA;;;AAgB9B;;;;UAAiB,gBAAA;EAIhB;EAFA,aAAA;EAII;EAFJ,EAAA;EAwBqB;EAtBrB,IAAA;AAAA;;;;;;;;AA0DD;;;;;;;;;;;;iBApCsB,mBAAA,CACrB,SAAA,UACA,QAAA,WACE,OAAA,CAAQ,gBAAA;;;;;;;;;;;;;;iBAiCW,mBAAA,CACrB,OAAA,EAAS,gBAAA,EACT,QAAA,WACE,OAAA"}

package/dist/encryption.js

@@ -1,137 +1,139 @@
+import { base64ToUint8Array, uint8ArrayToArrayBuffer, uint8ArrayToBase64 } from "./encoding.js";
+//#region src/encryption.ts
 /**
- * Password-Based Encryption Utilities
- *
- * Provides secure password-based encryption using PBKDF2 key derivation
- * and AES-GCM encryption. Suitable for encrypting sensitive wallet data.
- */
-import { uint8ArrayToBase64, base64ToUint8Array } from './encoding';
-import { uint8ArrayToArrayBuffer } from './encoding';
-// ============================================================================
-// Constants
-// ============================================================================
+* Password-Based Encryption Utilities
+*
+* Provides secure password-based encryption using PBKDF2 key derivation
+* and AES-GCM encryption. Suitable for encrypting sensitive wallet data.
+*/
 /**
- * PBKDF2 iterations for key derivation (100,000 iterations for security)
- * Matches web wallet implementation for consistency
- */
-const PBKDF2_ITERATIONS = 100_000;
+* PBKDF2 iterations for key derivation (100,000 iterations for security)
+* Matches web wallet implementation for consistency
+*/
+const PBKDF2_ITERATIONS = 1e5;
 /**
- * Salt length in bytes (128 bits)
- */
+* Salt length in bytes (128 bits)
+*/
 const SALT_LENGTH = 16;
 /**
- * IV length in bytes for AES-GCM (96 bits)
- */
+* IV length in bytes for AES-GCM (96 bits)
+*/
 const IV_LENGTH = 12;
-// ============================================================================
-// Helper Functions
-// ============================================================================
 /**
- * Import password as a PBKDF2 key
- */
+* Import password as a PBKDF2 key
+*/
 async function importPbkdf2Key(password) {
-    const enc = new TextEncoder();
-    return crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveKey']);
+	const enc = new TextEncoder();
+	return crypto.subtle.importKey("raw", enc.encode(password), "PBKDF2", false, ["deriveKey"]);
 }
 /**
- * Derive a cryptographic key from a password using PBKDF2
- *
- * @param password - Password string
- * @param salt - Salt as Uint8Array or ArrayBuffer
- * @param iterations - Number of PBKDF2 iterations (default: 100,000)
- * @returns Derived AES-GCM key
- */
-export async function deriveKey(password, salt, iterations = PBKDF2_ITERATIONS) {
-    const baseKey = await importPbkdf2Key(password);
-    const saltBuffer = salt instanceof Uint8Array ? uint8ArrayToArrayBuffer(salt) : salt;
-    return crypto.subtle.deriveKey({
-        name: 'PBKDF2',
-        salt: saltBuffer,
-        iterations,
-        hash: 'SHA-256'
-    }, baseKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+* Derive a cryptographic key from a password using PBKDF2
+*
+* @param password - Password string
+* @param salt - Salt as Uint8Array or ArrayBuffer
+* @param iterations - Number of PBKDF2 iterations (default: 100,000)
+* @returns Derived AES-GCM key
+*/
+async function deriveKey(password, salt, iterations = PBKDF2_ITERATIONS) {
+	const baseKey = await importPbkdf2Key(password);
+	const saltBuffer = salt instanceof Uint8Array ? uint8ArrayToArrayBuffer(salt) : salt;
+	return crypto.subtle.deriveKey({
+		name: "PBKDF2",
+		salt: saltBuffer,
+		iterations,
+		hash: "SHA-256"
+	}, baseKey, {
+		name: "AES-GCM",
+		length: 256
+	}, false, ["encrypt", "decrypt"]);
 }
-// ============================================================================
-// Random Generation
-// ============================================================================
 /**
- * Generate a cryptographically secure random salt
- *
- * @returns Random salt (16 bytes)
- */
-export function generateSalt() {
-    const salt = new Uint8Array(SALT_LENGTH);
-    crypto.getRandomValues(salt);
-    return salt;
+* Generate a cryptographically secure random salt
+*
+* @returns Random salt (16 bytes)
+*/
+function generateSalt() {
+	const salt = new Uint8Array(SALT_LENGTH);
+	crypto.getRandomValues(salt);
+	return salt;
 }
 /**
- * Generate a cryptographically secure random initialization vector
- *
- * @returns Random IV (12 bytes)
- */
-export function generateIV() {
-    const iv = new Uint8Array(IV_LENGTH);
-    crypto.getRandomValues(iv);
-    return iv;
+* Generate a cryptographically secure random initialization vector
+*
+* @returns Random IV (12 bytes)
+*/
+function generateIV() {
+	const iv = new Uint8Array(IV_LENGTH);
+	crypto.getRandomValues(iv);
+	return iv;
 }
 /**
- * Encrypt plaintext with a password using AES-GCM
- *
- * Uses PBKDF2 for key derivation and Base64 encoding for output.
- * Suitable for encrypting sensitive wallet data like private keys.
- *
- * **Encoding Standard**: Uses Base64 encoding for binary payloads (RFC 4648).
- * Base58 is used for addresses, keys, and hashes elsewhere in the SDK.
- *
- * @param plaintext - Plaintext string to encrypt
- * @param password - Password for encryption
- * @returns Encrypted payload with encryptedData, IV, and salt (all Base64 encoded)
- *
- * @example
- * ```ts
- * const encrypted = await encryptWithPassword('sensitive data', 'my-password')
- * // Store encrypted.encryptedData, encrypted.iv, encrypted.salt
- * ```
- */
-export async function encryptWithPassword(plaintext, password) {
-    const enc = new TextEncoder();
-    const iv = generateIV();
-    const salt = generateSalt();
-    const key = await deriveKey(password, salt);
-    const ivBuffer = uint8ArrayToArrayBuffer(iv);
-    const encryptedBuf = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: ivBuffer }, key, enc.encode(plaintext));
-    return {
-        encryptedData: uint8ArrayToBase64(new Uint8Array(encryptedBuf)),
-        iv: uint8ArrayToBase64(iv),
-        salt: uint8ArrayToBase64(salt)
-    };
+* Encrypt plaintext with a password using AES-GCM
+*
+* Uses PBKDF2 for key derivation and Base64 encoding for output.
+* Suitable for encrypting sensitive wallet data like private keys.
+*
+* **Encoding Standard**: Uses Base64 encoding for binary payloads (RFC 4648).
+* Base58 is used for addresses, keys, and hashes elsewhere in the SDK.
+*
+* @param plaintext - Plaintext string to encrypt
+* @param password - Password for encryption
+* @returns Encrypted payload with encryptedData, IV, and salt (all Base64 encoded)
+*
+* @example
+* ```ts
+* const encrypted = await encryptWithPassword('sensitive data', 'my-password')
+* // Store encrypted.encryptedData, encrypted.iv, encrypted.salt
+* ```
+*/
+async function encryptWithPassword(plaintext, password) {
+	const enc = new TextEncoder();
+	const iv = generateIV();
+	const salt = generateSalt();
+	const key = await deriveKey(password, salt);
+	const ivBuffer = uint8ArrayToArrayBuffer(iv);
+	const encryptedBuf = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv: ivBuffer
+	}, key, enc.encode(plaintext));
+	return {
+		encryptedData: uint8ArrayToBase64(new Uint8Array(encryptedBuf)),
+		iv: uint8ArrayToBase64(iv),
+		salt: uint8ArrayToBase64(salt)
+	};
 }
 /**
- * Decrypt encrypted data with a password
- *
- * @param payload - Encrypted payload (Base64 encoded)
- * @param password - Password used for encryption
- * @returns Decrypted plaintext string
- * @throws {Error} If decryption fails (wrong password or corrupted data)
- *
- * @example
- * ```ts
- * const decrypted = await decryptWithPassword(encrypted, 'my-password')
- * ```
- */
-export async function decryptWithPassword(payload, password) {
-    const dec = new TextDecoder();
-    const ivBytes = base64ToUint8Array(payload.iv);
-    const saltBytes = base64ToUint8Array(payload.salt);
-    const encryptedBytes = base64ToUint8Array(payload.encryptedData);
-    const key = await deriveKey(password, saltBytes);
-    const iv = uint8ArrayToArrayBuffer(ivBytes);
-    const encrypted = uint8ArrayToArrayBuffer(encryptedBytes);
-    try {
-        const plaintextBuf = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, encrypted);
-        return dec.decode(plaintextBuf);
-    }
-    catch {
-        throw new Error('Decryption failed. Incorrect password or corrupted data.');
-    }
+* Decrypt encrypted data with a password
+*
+* @param payload - Encrypted payload (Base64 encoded)
+* @param password - Password used for encryption
+* @returns Decrypted plaintext string
+* @throws {Error} If decryption fails (wrong password or corrupted data)
+*
+* @example
+* ```ts
+* const decrypted = await decryptWithPassword(encrypted, 'my-password')
+* ```
+*/
+async function decryptWithPassword(payload, password) {
+	const dec = new TextDecoder();
+	const ivBytes = base64ToUint8Array(payload.iv);
+	const saltBytes = base64ToUint8Array(payload.salt);
+	const encryptedBytes = base64ToUint8Array(payload.encryptedData);
+	const key = await deriveKey(password, saltBytes);
+	const iv = uint8ArrayToArrayBuffer(ivBytes);
+	const encrypted = uint8ArrayToArrayBuffer(encryptedBytes);
+	try {
+		const plaintextBuf = await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv
+		}, key, encrypted);
+		return dec.decode(plaintextBuf);
+	} catch {
+		throw new Error("Decryption failed. Incorrect password or corrupted data.");
+	}
 }
+//#endregion
+export { decryptWithPassword, deriveKey, encryptWithPassword, generateIV, generateSalt };
+
 //# sourceMappingURL=encryption.js.map