@amadeus-protocol/sdk 1.0.8 → 1.1.0

package/dist/index.js

@@ -1,55 +1,39 @@
-/**
- * @amadeus-protocol/sdk
- *
- * Official TypeScript/JavaScript SDK for Amadeus Protocol
- *
- * This SDK provides:
- * - Canonical serialization (VecPack)
- * - Cryptographic operations (BLS12-381, Base58)
- * - Transaction building and signing
- * - Token amount conversions
- * - Full-featured API client for Amadeus nodes
- *
- * @example
- * ```ts
- * import { AmadeusSDK, TransactionBuilder, generateKeypair } from '@amadeus-protocol/sdk'
- *
- * // Initialize SDK
- * const sdk = new AmadeusSDK()
- *
- * // Generate keypair
- * const keypair = generateKeypair()
- *
- * // Build and submit transaction
- * const builder = new TransactionBuilder(keypair.privateKey)
- * const { txHash, txPacked } = builder.transfer({
- *   recipient: '5Kd3N...',
- *   amount: 10.5,
- *   symbol: 'AMA'
- * })
- *
- * const result = await sdk.transaction.submit(txPacked)
- * ```
- *
- * @packageDocumentation
- */
-export * from './types';
-export * from './constants';
-export * from './networks';
-export * from './serialization';
-export * from './contract-state';
-export * from './crypto';
-export * from './conversion';
-export * from './encoding';
-export * from './encryption';
-export * from './mnemonic';
-export * from './validation';
-export * from './formatters';
-export * from './explorer';
-export * from './transaction-errors';
-export * from './transaction-builder';
-export * from './client';
-export * from './api';
-export * from './sdk';
-export * from './contracts';
-//# sourceMappingURL=index.js.map
+import { AmadeusSDKError, Contract, ContractFunction, TransactionEventType, TransactionExecutionError, TransactionValidationError } from "./types.js";
+import { AMADEUS_PUBLIC_KEY_BYTE_LENGTH, AMADEUS_SEED_BYTE_LENGTH, AMA_TOKEN_DECIMALS, AMA_TOKEN_DECIMALS_MULTIPLIER, AMA_TRANSFER_FEE, DEFAULT_TIMEOUT, EXPLORER_URL, MIN_TRANSFERABLE_AMOUNT, NODE_API_URL, SDK_VERSION } from "./constants.js";
+import { NETWORK_CONFIGS, NETWORK_EXPLORER_URLS, NETWORK_URLS, NetworkType, TESTNET_FAUCET_URL } from "./networks.js";
+import { decode, decodeContractState, encode } from "./serialization.js";
+import { arrayBufferToBase64, arrayBufferToUint8Array, base64ToArrayBuffer, base64ToUint8Array, fromBase58, toBase58, uint8ArrayToArrayBuffer, uint8ArrayToBase64 } from "./encoding.js";
+import { decodeContractStateToBase64, parseStateNumber, parseStateString } from "./contract-state.js";
+import { derivePublicKeyFromSeedBase58, deriveSkAndSeed64FromBase58Seed, generateKeypair, generatePrivateKey, getPublicKey, reduce512To256LE, seed64ToKeypair } from "./crypto.js";
+import { fromAtomicAma, toAtomicAma } from "./conversion.js";
+import { decryptWithPassword, deriveKey, encryptWithPassword, generateIV, generateSalt } from "./encryption.js";
+import { decodeVaultSecret, detectInputType, encodeVaultSecret, generateMnemonic, mnemonicToSeedBase58, validateMnemonic } from "./mnemonic.js";
+import { isValidAddress, isValidAmount, isValidSeed, validate, validateAddress, validateAmount, validatePassword, validateSeed, validateTokenSymbol } from "./validation.js";
+import { formatAMAAmount, formatBalance, formatBalanceWithPrivacy, formatNumber, formatShortAddress } from "./formatters.js";
+import { ExplorerType, makeAddressUrl, makeExplorerUrl, makeTransactionUrl } from "./explorer.js";
+import { TRANSACTION_EXECUTION_ERROR_MESSAGES, TRANSACTION_VALIDATION_ERROR_MESSAGES, getExecutionErrorMessage, getTransactionErrorMessage, getValidationErrorMessage } from "./transaction-errors.js";
+import { buildContractCall } from "./contracts/contract-call.js";
+import { createContract } from "./contracts/contract.js";
+import { buildCoinTransfer } from "./contracts/coin.js";
+import { LOCKUP_PRIME_ABI } from "./contracts/lockup-prime/abi.js";
+import { LOCKUP_ABI } from "./contracts/lockup/abi.js";
+import { buildNftCreateCollection, buildNftMint, buildNftTransfer } from "./contracts/nft/helpers.js";
+import { TransactionBuilder } from "./transaction-builder.js";
+import { AmadeusClient } from "./client.js";
+import { ChainAPI } from "./api/chain.js";
+import { ContractAPI } from "./api/contract.js";
+import { EpochAPI } from "./api/epoch.js";
+import { PeerAPI } from "./api/peer.js";
+import { ProofAPI } from "./api/proof.js";
+import { TransactionAPI } from "./api/transaction.js";
+import { WalletAPI } from "./api/wallet.js";
+import { AmadeusSDK } from "./sdk.js";
+import { LOCKUP_PRIME_TIER_KEYS, isValidLockupPrimeTierKey } from "./contracts/lockup-prime/types.js";
+import { LockupPrime, RATE_MAP } from "./contracts/lockup-prime/helpers.js";
+import { parseContractStateNumber, parseRawVaultData, parseVaultData } from "./contracts/lockup-prime/parsers.js";
+import { buildDailyStreakKey, buildLockupPrimeVaultKeyPrefix, buildNextCheckinEpochKey, extractLockupPrimeVaultIndexFromKey } from "./contracts/lockup-prime/storage-keys.js";
+import { Lockup } from "./contracts/lockup/helpers.js";
+import { parseLockupVaultData, parseRawLockupVaultData } from "./contracts/lockup/parsers.js";
+import { buildLockupVaultKeyPrefix, extractLockupVaultIndexFromKey } from "./contracts/lockup/storage-keys.js";
+import { NFT_ABI } from "./contracts/nft/abi.js";
+export { AMADEUS_PUBLIC_KEY_BYTE_LENGTH, AMADEUS_SEED_BYTE_LENGTH, AMA_TOKEN_DECIMALS, AMA_TOKEN_DECIMALS_MULTIPLIER, AMA_TRANSFER_FEE, AmadeusClient, AmadeusSDK, AmadeusSDKError, ChainAPI, Contract, ContractAPI, ContractFunction, DEFAULT_TIMEOUT, EXPLORER_URL, EpochAPI, ExplorerType, LOCKUP_ABI, LOCKUP_PRIME_ABI, LOCKUP_PRIME_TIER_KEYS, Lockup, LockupPrime, MIN_TRANSFERABLE_AMOUNT, NETWORK_CONFIGS, NETWORK_EXPLORER_URLS, NETWORK_URLS, NFT_ABI, NODE_API_URL, NetworkType, PeerAPI, ProofAPI, RATE_MAP, SDK_VERSION, TESTNET_FAUCET_URL, TRANSACTION_EXECUTION_ERROR_MESSAGES, TRANSACTION_VALIDATION_ERROR_MESSAGES, TransactionAPI, TransactionBuilder, TransactionEventType, TransactionExecutionError, TransactionValidationError, WalletAPI, arrayBufferToBase64, arrayBufferToUint8Array, base64ToArrayBuffer, base64ToUint8Array, buildCoinTransfer, buildContractCall, buildDailyStreakKey, buildLockupPrimeVaultKeyPrefix, buildLockupVaultKeyPrefix, buildNextCheckinEpochKey, buildNftCreateCollection, buildNftMint, buildNftTransfer, createContract, decode, decodeContractState, decodeContractStateToBase64, decodeVaultSecret, decryptWithPassword, deriveKey, derivePublicKeyFromSeedBase58, deriveSkAndSeed64FromBase58Seed, detectInputType, encode, encodeVaultSecret, encryptWithPassword, extractLockupPrimeVaultIndexFromKey, extractLockupVaultIndexFromKey, formatAMAAmount, formatBalance, formatBalanceWithPrivacy, formatNumber, formatShortAddress, fromAtomicAma, fromBase58, generateIV, generateKeypair, generateMnemonic, generatePrivateKey, generateSalt, getExecutionErrorMessage, getPublicKey, getTransactionErrorMessage, getValidationErrorMessage, isValidAddress, isValidAmount, isValidLockupPrimeTierKey, isValidSeed, makeAddressUrl, makeExplorerUrl, makeTransactionUrl, mnemonicToSeedBase58, parseContractStateNumber, parseLockupVaultData, parseRawLockupVaultData, parseRawVaultData, parseStateNumber, parseStateString, parseVaultData, reduce512To256LE, seed64ToKeypair, toAtomicAma, toBase58, uint8ArrayToArrayBuffer, uint8ArrayToBase64, validate, validateAddress, validateAmount, validateMnemonic, validatePassword, validateSeed, validateTokenSymbol };

package/dist/mnemonic.d.ts

@@ -1,3 +1,4 @@
+//#region src/mnemonic.d.ts
 /**
  * BIP39 Mnemonic Utilities for Amadeus Protocol
  *
@@ -15,7 +16,7 @@
  * // "abandon ability able about above absent absorb abstract absurd abuse access accident"
  * ```
  */
-export declare function generateMnemonic(): string;
+declare function generateMnemonic(): string;
 /**
  * Validate a BIP39 mnemonic phrase
  *
@@ -27,7 +28,7 @@ export declare function generateMnemonic(): string;
  * const isValid = validateMnemonic('abandon ability able ...')
  * ```
  */
-export declare function validateMnemonic(mnemonic: string): boolean;
+declare function validateMnemonic(mnemonic: string): boolean;
 /**
  * Derive an Amadeus seed (base58-encoded 64 bytes) from a BIP39 mnemonic.
  * Uses BIP39 seed derivation (PBKDF2 with SHA-512) which produces a 64-byte seed,
@@ -41,7 +42,7 @@ export declare function validateMnemonic(mnemonic: string): boolean;
  * const seed = mnemonicToSeedBase58('abandon ability able ...')
  * ```
  */
-export declare function mnemonicToSeedBase58(mnemonic: string): string;
+declare function mnemonicToSeedBase58(mnemonic: string): string;
 /**
  * Detect whether input is a mnemonic phrase or a raw private key.
  *
@@ -54,15 +55,15 @@ export declare function mnemonicToSeedBase58(mnemonic: string): string;
  * // 'mnemonic'
  * ```
  */
-export declare function detectInputType(input: string): 'mnemonic' | 'seed';
+declare function detectInputType(input: string): 'mnemonic' | 'seed';
 /**
  * Vault data format that supports both mnemonic and raw seed storage.
  * When decrypted, old vaults return a plain base58 string,
  * new vaults return a JSON string with this shape.
  */
-export interface VaultSecretData {
-    seed: string;
-    mnemonic?: string;
+interface VaultSecretData {
+  seed: string;
+  mnemonic?: string;
 }
 /**
  * Encode vault secret data as a string for encryption.
@@ -78,7 +79,7 @@ export interface VaultSecretData {
  * const encrypted = await encryptWithPassword(vaultData, password)
  * ```
  */
-export declare function encodeVaultSecret(seed: string, mnemonic?: string): string;
+declare function encodeVaultSecret(seed: string, mnemonic?: string): string;
 /**
  * Decode vault secret data from a decrypted string.
  * Handles both old format (plain base58 seed) and new format (JSON with seed + mnemonic).
@@ -92,5 +93,7 @@ export declare function encodeVaultSecret(seed: string, mnemonic?: string): stri
  * const { seed, mnemonic } = decodeVaultSecret(decrypted)
  * ```
  */
-export declare function decodeVaultSecret(decrypted: string): VaultSecretData;
+declare function decodeVaultSecret(decrypted: string): VaultSecretData;
+//#endregion
+export { VaultSecretData, decodeVaultSecret, detectInputType, encodeVaultSecret, generateMnemonic, mnemonicToSeedBase58, validateMnemonic };
 //# sourceMappingURL=mnemonic.d.ts.map

package/dist/mnemonic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic.d.ts","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAUlE;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAMzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,CAapE"}
+{"version":3,"file":"mnemonic.d.ts","names":[],"sources":["../src/mnemonic.ts"],"mappings":";;AAsBA;;;;;AAeA;;;;;AAiBA;;;;;AAiBA;AAlCA,iBAfgB,gBAAA,CAAA;;;;AAkEhB;;;;;AAmBA;;;iBAtEgB,gBAAA,CAAiB,QAAA;;AA2FjC;;;;;;;;;;;;iBA1EgB,oBAAA,CAAqB,QAAA;;;;;;;;;;;;;iBAiBrB,eAAA,CAAgB,KAAA;;;;;;UAiBf,eAAA;EAChB,IAAA;EACA,QAAA;AAAA;;;;;;;;;;;;;;;iBAiBe,iBAAA,CAAkB,IAAA,UAAc,QAAA;;;;;;;;;;;;;;iBAqBhC,iBAAA,CAAkB,SAAA,WAAoB,eAAA"}

package/dist/mnemonic.js

@@ -1,128 +1,119 @@
+import { toBase58 } from "./encoding.js";
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+//#region src/mnemonic.ts
 /**
- * BIP39 Mnemonic Utilities for Amadeus Protocol
- *
- * This module provides BIP39 mnemonic generation, validation, and seed derivation
- * for use with Amadeus Protocol wallets.
- */
-import * as bip39 from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english.js';
-import { toBase58 } from './encoding';
+* BIP39 Mnemonic Utilities for Amadeus Protocol
+*
+* This module provides BIP39 mnemonic generation, validation, and seed derivation
+* for use with Amadeus Protocol wallets.
+*/
 /**
- * Generate a new 12-word BIP39 mnemonic
- *
- * @returns 12-word mnemonic phrase
- *
- * @example
- * ```ts
- * const mnemonic = generateMnemonic()
- * // "abandon ability able about above absent absorb abstract absurd abuse access accident"
- * ```
- */
-export function generateMnemonic() {
-    return bip39.generateMnemonic(wordlist, 128); // 128 bits = 12 words
+* Generate a new 12-word BIP39 mnemonic
+*
+* @returns 12-word mnemonic phrase
+*
+* @example
+* ```ts
+* const mnemonic = generateMnemonic()
+* // "abandon ability able about above absent absorb abstract absurd abuse access accident"
+* ```
+*/
+function generateMnemonic() {
+	return bip39.generateMnemonic(wordlist, 128);
 }
 /**
- * Validate a BIP39 mnemonic phrase
- *
- * @param mnemonic - Mnemonic phrase to validate
- * @returns true if the mnemonic is valid
- *
- * @example
- * ```ts
- * const isValid = validateMnemonic('abandon ability able ...')
- * ```
- */
-export function validateMnemonic(mnemonic) {
-    return bip39.validateMnemonic(mnemonic.trim().toLowerCase(), wordlist);
+* Validate a BIP39 mnemonic phrase
+*
+* @param mnemonic - Mnemonic phrase to validate
+* @returns true if the mnemonic is valid
+*
+* @example
+* ```ts
+* const isValid = validateMnemonic('abandon ability able ...')
+* ```
+*/
+function validateMnemonic(mnemonic) {
+	return bip39.validateMnemonic(mnemonic.trim().toLowerCase(), wordlist);
 }
 /**
- * Derive an Amadeus seed (base58-encoded 64 bytes) from a BIP39 mnemonic.
- * Uses BIP39 seed derivation (PBKDF2 with SHA-512) which produces a 64-byte seed,
- * matching the Amadeus SDK's expected seed length.
- *
- * @param mnemonic - BIP39 mnemonic phrase
- * @returns Base58-encoded 64-byte seed
- *
- * @example
- * ```ts
- * const seed = mnemonicToSeedBase58('abandon ability able ...')
- * ```
- */
-export function mnemonicToSeedBase58(mnemonic) {
-    const seed = bip39.mnemonicToSeedSync(mnemonic.trim().toLowerCase());
-    return toBase58(seed);
+* Derive an Amadeus seed (base58-encoded 64 bytes) from a BIP39 mnemonic.
+* Uses BIP39 seed derivation (PBKDF2 with SHA-512) which produces a 64-byte seed,
+* matching the Amadeus SDK's expected seed length.
+*
+* @param mnemonic - BIP39 mnemonic phrase
+* @returns Base58-encoded 64-byte seed
+*
+* @example
+* ```ts
+* const seed = mnemonicToSeedBase58('abandon ability able ...')
+* ```
+*/
+function mnemonicToSeedBase58(mnemonic) {
+	return toBase58(bip39.mnemonicToSeedSync(mnemonic.trim().toLowerCase()));
 }
 /**
- * Detect whether input is a mnemonic phrase or a raw private key.
- *
- * @param input - User input string
- * @returns 'mnemonic' if the input looks like a word-based mnemonic, or 'seed' if it looks like a base58-encoded key
- *
- * @example
- * ```ts
- * const type = detectInputType('abandon ability able ...')
- * // 'mnemonic'
- * ```
- */
-export function detectInputType(input) {
-    const trimmed = input.trim();
-    const words = trimmed.split(/\s+/);
-    // BIP39 mnemonics are 12 or 24 words
-    if (words.length === 12 || words.length === 24) {
-        // Check if all words look like English words (no numbers, no special chars)
-        const allWords = words.every((w) => /^[a-zA-Z]+$/.test(w));
-        if (allWords)
-            return 'mnemonic';
-    }
-    return 'seed';
+* Detect whether input is a mnemonic phrase or a raw private key.
+*
+* @param input - User input string
+* @returns 'mnemonic' if the input looks like a word-based mnemonic, or 'seed' if it looks like a base58-encoded key
+*
+* @example
+* ```ts
+* const type = detectInputType('abandon ability able ...')
+* // 'mnemonic'
+* ```
+*/
+function detectInputType(input) {
+	const words = input.trim().split(/\s+/);
+	if (words.length === 12 || words.length === 24) {
+		if (words.every((w) => /^[a-zA-Z]+$/.test(w))) return "mnemonic";
+	}
+	return "seed";
 }
 /**
- * Encode vault secret data as a string for encryption.
- * Always stores as JSON to include the optional mnemonic.
- *
- * @param seed - Base58-encoded seed
- * @param mnemonic - Optional BIP39 mnemonic phrase
- * @returns JSON string for vault encryption
- *
- * @example
- * ```ts
- * const vaultData = encodeVaultSecret(seed, mnemonic)
- * const encrypted = await encryptWithPassword(vaultData, password)
- * ```
- */
-export function encodeVaultSecret(seed, mnemonic) {
-    const data = { seed };
-    if (mnemonic) {
-        data.mnemonic = mnemonic;
-    }
-    return JSON.stringify(data);
+* Encode vault secret data as a string for encryption.
+* Always stores as JSON to include the optional mnemonic.
+*
+* @param seed - Base58-encoded seed
+* @param mnemonic - Optional BIP39 mnemonic phrase
+* @returns JSON string for vault encryption
+*
+* @example
+* ```ts
+* const vaultData = encodeVaultSecret(seed, mnemonic)
+* const encrypted = await encryptWithPassword(vaultData, password)
+* ```
+*/
+function encodeVaultSecret(seed, mnemonic) {
+	const data = { seed };
+	if (mnemonic) data.mnemonic = mnemonic;
+	return JSON.stringify(data);
 }
 /**
- * Decode vault secret data from a decrypted string.
- * Handles both old format (plain base58 seed) and new format (JSON with seed + mnemonic).
- *
- * @param decrypted - Decrypted vault string
- * @returns Parsed vault secret data
- *
- * @example
- * ```ts
- * const decrypted = await decryptWithPassword(encrypted, password)
- * const { seed, mnemonic } = decodeVaultSecret(decrypted)
- * ```
- */
-export function decodeVaultSecret(decrypted) {
-    try {
-        const parsed = JSON.parse(decrypted);
-        if (parsed && typeof parsed.seed === 'string') {
-            return {
-                seed: parsed.seed,
-                mnemonic: parsed.mnemonic || undefined
-            };
-        }
-    }
-    catch {
-        // Not JSON — old format, plain base58 seed
-    }
-    return { seed: decrypted };
+* Decode vault secret data from a decrypted string.
+* Handles both old format (plain base58 seed) and new format (JSON with seed + mnemonic).
+*
+* @param decrypted - Decrypted vault string
+* @returns Parsed vault secret data
+*
+* @example
+* ```ts
+* const decrypted = await decryptWithPassword(encrypted, password)
+* const { seed, mnemonic } = decodeVaultSecret(decrypted)
+* ```
+*/
+function decodeVaultSecret(decrypted) {
+	try {
+		const parsed = JSON.parse(decrypted);
+		if (parsed && typeof parsed.seed === "string") return {
+			seed: parsed.seed,
+			mnemonic: parsed.mnemonic || void 0
+		};
+	} catch {}
+	return { seed: decrypted };
 }
+//#endregion
+export { decodeVaultSecret, detectInputType, encodeVaultSecret, generateMnemonic, mnemonicToSeedBase58, validateMnemonic };
+
 //# sourceMappingURL=mnemonic.js.map

package/dist/mnemonic.js.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic.js","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAA;AAC5D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB;IAC/B,OAAO,KAAK,CAAC,gBAAgB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAA,CAAC,sBAAsB;AACpE,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAgB;IAChD,OAAO,KAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,QAAQ,CAAC,CAAA;AACvE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgB;IACpD,MAAM,IAAI,GAAG,KAAK,CAAC,kBAAkB,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAA;IACpE,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAA;AACtB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,KAAa;IAC5C,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAA;IAC5B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAClC,qCAAqC;IACrC,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;QAChD,4EAA4E;QAC5E,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QAC1D,IAAI,QAAQ;YAAE,OAAO,UAAU,CAAA;IAChC,CAAC;IACD,OAAO,MAAM,CAAA;AACd,CAAC;AAYD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,QAAiB;IAChE,MAAM,IAAI,GAAoB,EAAE,IAAI,EAAE,CAAA;IACtC,IAAI,QAAQ,EAAE,CAAC;QACd,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IACzB,CAAC;IACD,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAAiB;IAClD,IAAI,CAAC;QACJ,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;QACpC,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC/C,OAAO;gBACN,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,SAAS;aACtC,CAAA;QACF,CAAC;IACF,CAAC;IAAC,MAAM,CAAC;QACR,2CAA2C;IAC5C,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;AAC3B,CAAC"}
+{"version":3,"file":"mnemonic.js","names":[],"sources":["../src/mnemonic.ts"],"sourcesContent":["/**\n * BIP39 Mnemonic Utilities for Amadeus Protocol\n *\n * This module provides BIP39 mnemonic generation, validation, and seed derivation\n * for use with Amadeus Protocol wallets.\n */\n\nimport * as bip39 from '@scure/bip39'\nimport { wordlist } from '@scure/bip39/wordlists/english.js'\nimport { toBase58 } from './encoding'\n\n/**\n * Generate a new 12-word BIP39 mnemonic\n *\n * @returns 12-word mnemonic phrase\n *\n * @example\n * ```ts\n * const mnemonic = generateMnemonic()\n * // \"abandon ability able about above absent absorb abstract absurd abuse access accident\"\n * ```\n */\nexport function generateMnemonic(): string {\n\treturn bip39.generateMnemonic(wordlist, 128) // 128 bits = 12 words\n}\n\n/**\n * Validate a BIP39 mnemonic phrase\n *\n * @param mnemonic - Mnemonic phrase to validate\n * @returns true if the mnemonic is valid\n *\n * @example\n * ```ts\n * const isValid = validateMnemonic('abandon ability able ...')\n * ```\n */\nexport function validateMnemonic(mnemonic: string): boolean {\n\treturn bip39.validateMnemonic(mnemonic.trim().toLowerCase(), wordlist)\n}\n\n/**\n * Derive an Amadeus seed (base58-encoded 64 bytes) from a BIP39 mnemonic.\n * Uses BIP39 seed derivation (PBKDF2 with SHA-512) which produces a 64-byte seed,\n * matching the Amadeus SDK's expected seed length.\n *\n * @param mnemonic - BIP39 mnemonic phrase\n * @returns Base58-encoded 64-byte seed\n *\n * @example\n * ```ts\n * const seed = mnemonicToSeedBase58('abandon ability able ...')\n * ```\n */\nexport function mnemonicToSeedBase58(mnemonic: string): string {\n\tconst seed = bip39.mnemonicToSeedSync(mnemonic.trim().toLowerCase())\n\treturn toBase58(seed)\n}\n\n/**\n * Detect whether input is a mnemonic phrase or a raw private key.\n *\n * @param input - User input string\n * @returns 'mnemonic' if the input looks like a word-based mnemonic, or 'seed' if it looks like a base58-encoded key\n *\n * @example\n * ```ts\n * const type = detectInputType('abandon ability able ...')\n * // 'mnemonic'\n * ```\n */\nexport function detectInputType(input: string): 'mnemonic' | 'seed' {\n\tconst trimmed = input.trim()\n\tconst words = trimmed.split(/\\s+/)\n\t// BIP39 mnemonics are 12 or 24 words\n\tif (words.length === 12 || words.length === 24) {\n\t\t// Check if all words look like English words (no numbers, no special chars)\n\t\tconst allWords = words.every((w) => /^[a-zA-Z]+$/.test(w))\n\t\tif (allWords) return 'mnemonic'\n\t}\n\treturn 'seed'\n}\n\n/**\n * Vault data format that supports both mnemonic and raw seed storage.\n * When decrypted, old vaults return a plain base58 string,\n * new vaults return a JSON string with this shape.\n */\nexport interface VaultSecretData {\n\tseed: string\n\tmnemonic?: string\n}\n\n/**\n * Encode vault secret data as a string for encryption.\n * Always stores as JSON to include the optional mnemonic.\n *\n * @param seed - Base58-encoded seed\n * @param mnemonic - Optional BIP39 mnemonic phrase\n * @returns JSON string for vault encryption\n *\n * @example\n * ```ts\n * const vaultData = encodeVaultSecret(seed, mnemonic)\n * const encrypted = await encryptWithPassword(vaultData, password)\n * ```\n */\nexport function encodeVaultSecret(seed: string, mnemonic?: string): string {\n\tconst data: VaultSecretData = { seed }\n\tif (mnemonic) {\n\t\tdata.mnemonic = mnemonic\n\t}\n\treturn JSON.stringify(data)\n}\n\n/**\n * Decode vault secret data from a decrypted string.\n * Handles both old format (plain base58 seed) and new format (JSON with seed + mnemonic).\n *\n * @param decrypted - Decrypted vault string\n * @returns Parsed vault secret data\n *\n * @example\n * ```ts\n * const decrypted = await decryptWithPassword(encrypted, password)\n * const { seed, mnemonic } = decodeVaultSecret(decrypted)\n * ```\n */\nexport function decodeVaultSecret(decrypted: string): VaultSecretData {\n\ttry {\n\t\tconst parsed = JSON.parse(decrypted)\n\t\tif (parsed && typeof parsed.seed === 'string') {\n\t\t\treturn {\n\t\t\t\tseed: parsed.seed,\n\t\t\t\tmnemonic: parsed.mnemonic || undefined\n\t\t\t}\n\t\t}\n\t} catch {\n\t\t// Not JSON — old format, plain base58 seed\n\t}\n\treturn { seed: decrypted }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,mBAA2B;CAC1C,OAAO,MAAM,iBAAiB,UAAU,IAAI;;;;;;;;;;;;;AAc7C,SAAgB,iBAAiB,UAA2B;CAC3D,OAAO,MAAM,iBAAiB,SAAS,MAAM,CAAC,aAAa,EAAE,SAAS;;;;;;;;;;;;;;;AAgBvE,SAAgB,qBAAqB,UAA0B;CAE9D,OAAO,SADM,MAAM,mBAAmB,SAAS,MAAM,CAAC,aAAa,CAC/C,CAAC;;;;;;;;;;;;;;AAetB,SAAgB,gBAAgB,OAAoC;CAEnE,MAAM,QADU,MAAM,MACD,CAAC,MAAM,MAAM;CAElC,IAAI,MAAM,WAAW,MAAM,MAAM,WAAW;MAE1B,MAAM,OAAO,MAAM,cAAc,KAAK,EAAE,CAC7C,EAAE,OAAO;;CAEtB,OAAO;;;;;;;;;;;;;;;;AA2BR,SAAgB,kBAAkB,MAAc,UAA2B;CAC1E,MAAM,OAAwB,EAAE,MAAM;CACtC,IAAI,UACH,KAAK,WAAW;CAEjB,OAAO,KAAK,UAAU,KAAK;;;;;;;;;;;;;;;AAgB5B,SAAgB,kBAAkB,WAAoC;CACrE,IAAI;EACH,MAAM,SAAS,KAAK,MAAM,UAAU;EACpC,IAAI,UAAU,OAAO,OAAO,SAAS,UACpC,OAAO;GACN,MAAM,OAAO;GACb,UAAU,OAAO,YAAY,KAAA;GAC7B;SAEK;CAGR,OAAO,EAAE,MAAM,WAAW"}

package/dist/networks.d.ts

@@ -1,3 +1,4 @@
+//#region src/networks.d.ts
 /**
  * Network Configuration
  *
@@ -6,38 +7,34 @@
 /**
  * Network types enum
  */
-export declare enum NetworkType {
-    MAINNET = "mainnet",
-    TESTNET = "testnet",
-    CUSTOM = "custom"
+declare enum NetworkType {
+  MAINNET = "mainnet",
+  TESTNET = "testnet",
+  CUSTOM = "custom"
 }
 /**
  * Network configuration interface
  */
-export interface NetworkConfig {
-    rpcUrl: string;
-    explorerUrl: string;
+interface NetworkConfig {
+  rpcUrl: string;
+  explorerUrl: string;
 }
 /**
  * Network API URLs
  */
-export declare const NETWORK_URLS: {
-    [key in Exclude<NetworkType, NetworkType.CUSTOM>]: string;
-};
+declare const NETWORK_URLS: { [key in Exclude<NetworkType, NetworkType.CUSTOM>]: string };
 /**
  * Network Explorer URLs
  */
-export declare const NETWORK_EXPLORER_URLS: {
-    [key in Exclude<NetworkType, NetworkType.CUSTOM>]: string;
-};
+declare const NETWORK_EXPLORER_URLS: { [key in Exclude<NetworkType, NetworkType.CUSTOM>]: string };
 /**
  * Network configurations (RPC + Explorer)
  */
-export declare const NETWORK_CONFIGS: {
-    [key in Exclude<NetworkType, NetworkType.CUSTOM>]: NetworkConfig;
-};
+declare const NETWORK_CONFIGS: { [key in Exclude<NetworkType, NetworkType.CUSTOM>]: NetworkConfig };
 /**
  * Testnet Faucet URL
  */
-export declare const TESTNET_FAUCET_URL = "https://mcp.ama.one/testnet-faucet";
+declare const TESTNET_FAUCET_URL = "https://mcp.ama.one/testnet-faucet";
+//#endregion
+export { NETWORK_CONFIGS, NETWORK_EXPLORER_URLS, NETWORK_URLS, NetworkConfig, NetworkType, TESTNET_FAUCET_URL };
 //# sourceMappingURL=networks.d.ts.map

package/dist/networks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../src/networks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,oBAAY,WAAW;IACtB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,MAAM,WAAW;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE;KAAG,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM;CAGrF,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE;KAAG,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM;CAG9F,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE;KAAG,GAAG,IAAI,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,aAAa;CAU9F,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,uCAAuC,CAAA"}
+{"version":3,"file":"networks.d.ts","names":[],"sources":["../src/networks.ts"],"mappings":";;AASA;;;;;;;aAAY,WAAA;EACX,OAAA;EACA,OAAA;EACA,MAAA;AAAA;;;AAcD;UARiB,aAAA;EAChB,MAAA;EACA,WAAA;AAAA;;;;cAMY,YAAA,YAAwB,OAAA,CAAQ,WAAA,EAAa,WAAA,CAAY,MAAA;;;;cAQzD,qBAAA,YAAiC,OAAA,CAAQ,WAAA,EAAa,WAAA,CAAY,MAAA;;;;cASlE,eAAA,YAA2B,OAAA,CAAQ,WAAA,EAAa,WAAA,CAAY,MAAA,IAAU,aAAA;;;;cAetE,kBAAA"}

package/dist/networks.js

@@ -1,46 +1,50 @@
+//#region src/networks.ts
 /**
- * Network Configuration
- *
- * This module provides network configuration for Amadeus Protocol networks.
- */
+* Network Configuration
+*
+* This module provides network configuration for Amadeus Protocol networks.
+*/
 /**
- * Network types enum
- */
-export var NetworkType;
-(function (NetworkType) {
-    NetworkType["MAINNET"] = "mainnet";
-    NetworkType["TESTNET"] = "testnet";
-    NetworkType["CUSTOM"] = "custom";
-})(NetworkType || (NetworkType = {}));
+* Network types enum
+*/
+let NetworkType = /* @__PURE__ */ function(NetworkType) {
+	NetworkType["MAINNET"] = "mainnet";
+	NetworkType["TESTNET"] = "testnet";
+	NetworkType["CUSTOM"] = "custom";
+	return NetworkType;
+}({});
 /**
- * Network API URLs
- */
-export const NETWORK_URLS = {
-    [NetworkType.MAINNET]: 'https://mainnet-rpc.ama.one',
-    [NetworkType.TESTNET]: 'https://testnet-rpc.ama.one'
+* Network API URLs
+*/
+const NETWORK_URLS = {
+	["mainnet"]: "https://mainnet-rpc.ama.one",
+	["testnet"]: "https://testnet-rpc.ama.one"
 };
 /**
- * Network Explorer URLs
- */
-export const NETWORK_EXPLORER_URLS = {
-    [NetworkType.MAINNET]: 'https://explorer.ama.one',
-    [NetworkType.TESTNET]: 'https://testnet.explorer.ama.one'
+* Network Explorer URLs
+*/
+const NETWORK_EXPLORER_URLS = {
+	["mainnet"]: "https://explorer.ama.one",
+	["testnet"]: "https://testnet.explorer.ama.one"
 };
 /**
- * Network configurations (RPC + Explorer)
- */
-export const NETWORK_CONFIGS = {
-    [NetworkType.MAINNET]: {
-        rpcUrl: NETWORK_URLS[NetworkType.MAINNET],
-        explorerUrl: NETWORK_EXPLORER_URLS[NetworkType.MAINNET]
-    },
-    [NetworkType.TESTNET]: {
-        rpcUrl: NETWORK_URLS[NetworkType.TESTNET],
-        explorerUrl: NETWORK_EXPLORER_URLS[NetworkType.TESTNET]
-    }
+* Network configurations (RPC + Explorer)
+*/
+const NETWORK_CONFIGS = {
+	["mainnet"]: {
+		rpcUrl: NETWORK_URLS["mainnet"],
+		explorerUrl: NETWORK_EXPLORER_URLS["mainnet"]
+	},
+	["testnet"]: {
+		rpcUrl: NETWORK_URLS["testnet"],
+		explorerUrl: NETWORK_EXPLORER_URLS["testnet"]
+	}
 };
 /**
- * Testnet Faucet URL
- */
-export const TESTNET_FAUCET_URL = 'https://mcp.ama.one/testnet-faucet';
+* Testnet Faucet URL
+*/
+const TESTNET_FAUCET_URL = "https://mcp.ama.one/testnet-faucet";
+//#endregion
+export { NETWORK_CONFIGS, NETWORK_EXPLORER_URLS, NETWORK_URLS, NetworkType, TESTNET_FAUCET_URL };
+
 //# sourceMappingURL=networks.js.map

package/dist/networks.js.map

@@ -1 +1 @@
-{"version":3,"file":"networks.js","sourceRoot":"","sources":["../src/networks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,CAAN,IAAY,WAIX;AAJD,WAAY,WAAW;IACtB,kCAAmB,CAAA;IACnB,kCAAmB,CAAA;IACnB,gCAAiB,CAAA;AAClB,CAAC,EAJW,WAAW,KAAX,WAAW,QAItB;AAUD;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAkE;IAC1F,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,6BAA6B;IACpD,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,6BAA6B;CACpD,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAkE;IACnG,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,0BAA0B;IACjD,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,kCAAkC;CACzD,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAC3B;IACC,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE;QACtB,MAAM,EAAE,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC;QACzC,WAAW,EAAE,qBAAqB,CAAC,WAAW,CAAC,OAAO,CAAC;KACvD;IACD,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE;QACtB,MAAM,EAAE,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC;QACzC,WAAW,EAAE,qBAAqB,CAAC,WAAW,CAAC,OAAO,CAAC;KACvD;CACD,CAAA;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,oCAAoC,CAAA"}
+{"version":3,"file":"networks.js","names":[],"sources":["../src/networks.ts"],"sourcesContent":["/**\n * Network Configuration\n *\n * This module provides network configuration for Amadeus Protocol networks.\n */\n\n/**\n * Network types enum\n */\nexport enum NetworkType {\n\tMAINNET = 'mainnet',\n\tTESTNET = 'testnet',\n\tCUSTOM = 'custom'\n}\n\n/**\n * Network configuration interface\n */\nexport interface NetworkConfig {\n\trpcUrl: string\n\texplorerUrl: string\n}\n\n/**\n * Network API URLs\n */\nexport const NETWORK_URLS: { [key in Exclude<NetworkType, NetworkType.CUSTOM>]: string } = {\n\t[NetworkType.MAINNET]: 'https://mainnet-rpc.ama.one',\n\t[NetworkType.TESTNET]: 'https://testnet-rpc.ama.one'\n}\n\n/**\n * Network Explorer URLs\n */\nexport const NETWORK_EXPLORER_URLS: { [key in Exclude<NetworkType, NetworkType.CUSTOM>]: string } =\n\t{\n\t\t[NetworkType.MAINNET]: 'https://explorer.ama.one',\n\t\t[NetworkType.TESTNET]: 'https://testnet.explorer.ama.one'\n\t}\n\n/**\n * Network configurations (RPC + Explorer)\n */\nexport const NETWORK_CONFIGS: { [key in Exclude<NetworkType, NetworkType.CUSTOM>]: NetworkConfig } =\n\t{\n\t\t[NetworkType.MAINNET]: {\n\t\t\trpcUrl: NETWORK_URLS[NetworkType.MAINNET],\n\t\t\texplorerUrl: NETWORK_EXPLORER_URLS[NetworkType.MAINNET]\n\t\t},\n\t\t[NetworkType.TESTNET]: {\n\t\t\trpcUrl: NETWORK_URLS[NetworkType.TESTNET],\n\t\t\texplorerUrl: NETWORK_EXPLORER_URLS[NetworkType.TESTNET]\n\t\t}\n\t}\n\n/**\n * Testnet Faucet URL\n */\nexport const TESTNET_FAUCET_URL = 'https://mcp.ama.one/testnet-faucet'\n"],"mappings":";;;;;;;;;AASA,IAAY,cAAL,yBAAA,aAAA;CACN,YAAA,aAAA;CACA,YAAA,aAAA;CACA,YAAA,YAAA;;KACA;;;;AAaD,MAAa,eAA8E;cACnE;cACA;CACvB;;;;AAKD,MAAa,wBACZ;cACwB;cACA;CACvB;;;;AAKF,MAAa,kBACZ;cACwB;EACtB,QAAQ,aAAA;EACR,aAAa,sBAAA;EACb;cACsB;EACtB,QAAQ,aAAA;EACR,aAAa,sBAAA;EACb;CACD;;;;AAKF,MAAa,qBAAqB"}