@flashnet/sdk 0.3.24 → 0.3.26

package/dist/cjs/src/client/FlashnetClient.js

@@ -6,6 +6,7 @@ var index$1 = require('../config/index.js');
 var index = require('../types/index.js');
 var index$2 = require('../utils/index.js');
 var auth = require('../utils/auth.js');
+var hex = require('../utils/hex.js');
 var intents = require('../utils/intents.js');
 var signer = require('../utils/signer.js');
 var sparkAddress = require('../utils/spark-address.js');
@@ -31,6 +32,16 @@ class FlashnetClient {
     publicKey = "";
     sparkAddress = "";
     isAuthenticated = false;
+    // Ephemeral caches for config endpoints and ping
+    featureStatusCache;
+    minAmountsCache;
+    allowedAssetsCache;
+    pingCache;
+    // TTLs (milliseconds)
+    static FEATURE_STATUS_TTL_MS = 5000; // 5s
+    static MIN_AMOUNTS_TTL_MS = 5000; // 5s
+    static ALLOWED_ASSETS_TTL_MS = 60000; // 60s
+    static PING_TTL_MS = 2000; // 2s
     /**
      * Get the underlying wallet instance for direct wallet operations
      */
@@ -227,7 +238,7 @@ class FlashnetClient {
             for (const [tokenPubkey, tokenData] of balance.tokenBalances.entries()) {
                 const info = tokenData.tokenMetadata;
                 // Convert raw token identifier to hex and human-readable forms
-                const tokenIdentifierHex = Buffer.from(info.rawTokenIdentifier).toString("hex");
+                const tokenIdentifierHex = hex.getHexFromUint8Array(info.rawTokenIdentifier);
                 const tokenAddress$1 = tokenAddress.encodeSparkHumanReadableTokenIdentifier(info.rawTokenIdentifier, this.sparkNetwork);
                 tokenBalances.set(tokenPubkey, {
                     balance: BigInt(tokenData.balance),
@@ -325,6 +336,8 @@ class FlashnetClient {
      */
     async createConstantProductPool(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_pool_creation");
+        await this.assertAllowedAssetBForPoolCreation(this.toHexTokenIdentifier(params.assetBAddress));
         // Check if we need to add initial liquidity
         if (params.initialLiquidity) {
             await this.checkBalance({
@@ -364,7 +377,7 @@ class FlashnetClient {
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
             hostNamespace: params.hostNamespace || "",
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.createConstantProductPool(request);
         // Add initial liquidity if specified
@@ -373,6 +386,31 @@ class FlashnetClient {
         }
         return response;
     }
+    // Validate and normalize inputs to bigint
+    static parsePositiveIntegerToBigInt(value, name) {
+        if (typeof value === "bigint") {
+            if (value <= 0n) {
+                throw new Error(`${name} must be positive integer`);
+            }
+            return value;
+        }
+        if (typeof value === "number") {
+            if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+                throw new Error(`${name} must be positive integer`);
+            }
+            return BigInt(value);
+        }
+        try {
+            const v = BigInt(value);
+            if (v <= 0n) {
+                throw new Error(`${name} must be positive integer`);
+            }
+            return v;
+        }
+        catch {
+            throw new Error(`${name} must be positive integer`);
+        }
+    }
     /**
      * Calculates virtual reserves for a bonding curve AMM.
      *
@@ -387,69 +425,36 @@ class FlashnetClient {
      * @returns An object containing `virtualReserveA`, `virtualReserveB`, and `threshold`.
      */
     static calculateVirtualReserves(params) {
-        // Validate and normalize inputs to bigint
-        const parsePositiveIntegerToBigInt = (value, name) => {
-            if (typeof value === "bigint") {
-                if (value <= 0n) {
-                    throw new Error(`${name} must be positive integer`);
-                }
-                return value;
-            }
-            if (typeof value === "number") {
-                if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
-                    throw new Error(`${name} must be positive integer`);
-                }
-                return BigInt(value);
-            }
-            try {
-                const v = BigInt(value);
-                if (v <= 0n) {
-                    throw new Error(`${name} must be positive integer`);
-                }
-                return v;
-            }
-            catch {
-                throw new Error(`${name} must be positive integer`);
-            }
-        };
         if (!Number.isFinite(params.graduationThresholdPct) ||
-            !Number.isInteger(params.graduationThresholdPct) ||
-            params.graduationThresholdPct <= 0) {
-            throw new Error("Graduation threshold percentage must be a positive integer");
+            !Number.isInteger(params.graduationThresholdPct)) {
+            throw new Error("Graduation threshold percentage must be an integer number of percent");
         }
-        const supply = parsePositiveIntegerToBigInt(params.initialTokenSupply, "Initial token supply");
-        const targetB = parsePositiveIntegerToBigInt(params.targetRaise, "Target raise");
+        const supply = FlashnetClient.parsePositiveIntegerToBigInt(params.initialTokenSupply, "Initial token supply");
+        const targetB = FlashnetClient.parsePositiveIntegerToBigInt(params.targetRaise, "Target raise");
         const graduationThresholdPct = BigInt(params.graduationThresholdPct);
-        // Check feasibility: f - g*(1-f) > 0 where f is graduationThresholdPct/100 and g is 1
-        const MIN_GRADUATION_THRESHOLD_PCT = 50n;
-        const MAX_GRADUATION_THRESHOLD_PCT = 95n;
-        if (graduationThresholdPct <= MIN_GRADUATION_THRESHOLD_PCT ||
-            graduationThresholdPct > MAX_GRADUATION_THRESHOLD_PCT) {
-            throw new Error(`Graduation threshold percentage must be greater than ${MIN_GRADUATION_THRESHOLD_PCT} ` +
-                `and not greater than ${MAX_GRADUATION_THRESHOLD_PCT}`);
-        }
-        // f       is graduationThresholdPct / 100n
-        // denom   is (2n * graduationThresholdPct / 100n) - 1n
-        //            (2n * graduationThresholdPct - 100n) / 100n
-        // 1/denom is 100n / (2n * graduationThresholdPct - 100n)
-        // Calculate virtual reserves and round down to integers
-        // virtualA is (supply * f * f) / denom
-        const virtualANumerator = BigInt(supply) * graduationThresholdPct * graduationThresholdPct;
-        const virtualADenominator = 200n * graduationThresholdPct - 10000n;
-        const virtualARemainder = virtualANumerator % virtualADenominator;
-        const virtualA = (virtualANumerator - virtualARemainder) / virtualADenominator;
-        // virtualB is (targetB * g * (1 - f)) / denom
-        const virtualBNumerator = BigInt(targetB) * (100n - graduationThresholdPct);
-        const virtualBDenominator = 2n * graduationThresholdPct - 100n;
-        const virtualBRemainder = virtualBNumerator % virtualBDenominator;
-        const virtualB = (virtualBNumerator - virtualBRemainder) / virtualBDenominator;
-        // Calculate threshold as amount of asset A (not percentage)
-        const threshold = (BigInt(supply) * graduationThresholdPct) / 100n;
-        return {
-            virtualReserveA: virtualA,
-            virtualReserveB: virtualB,
-            threshold: threshold,
-        };
+        // Align bounds with Rust AMM (20%..95%), then check feasibility for g=1 (requires >50%).
+        const MIN_PCT = 20n;
+        const MAX_PCT = 95n;
+        if (graduationThresholdPct < MIN_PCT || graduationThresholdPct > MAX_PCT) {
+            throw new Error(`Graduation threshold percentage must be between ${MIN_PCT} and ${MAX_PCT}`);
+        }
+        // Feasibility: denom = f - g*(1-f) > 0 with g=1 -> 2f - 1 > 0 -> pct > 50
+        const denomNormalized = 2n * graduationThresholdPct - 100n; // equals 100*(f - (1-f))
+        if (denomNormalized <= 0n) {
+            throw new Error("Invalid configuration: threshold must be greater than 50% when LP fraction is 1.0");
+        }
+        // v_A = S * f^2 / (f - (1-f)) ; using integer math with pct where
+        // v_A = S * p^2 / (100 * (2p - 100))
+        const vANumerator = supply * graduationThresholdPct * graduationThresholdPct;
+        const vADenominator = 100n * denomNormalized;
+        const virtualA = vANumerator / vADenominator; // floor
+        // v_B = T * (1 - f) / (f - (1-f)) ; with pct => T * (100 - p) / (2p - 100)
+        const vBNumerator = targetB * (100n - graduationThresholdPct);
+        const vBDenominator = denomNormalized;
+        const virtualB = vBNumerator / vBDenominator; // floor
+        // Threshold amount in A
+        const threshold = (supply * graduationThresholdPct) / 100n;
+        return { virtualReserveA: virtualA, virtualReserveB: virtualB, threshold };
     }
     /**
      * Create a single-sided pool with automatic initial deposit
@@ -459,18 +464,20 @@ class FlashnetClient {
      */
     async createSingleSidedPool(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_pool_creation");
+        await this.assertAllowedAssetBForPoolCreation(this.toHexTokenIdentifier(params.assetBAddress));
         if (!params.hostNamespace && params.totalHostFeeRateBps < 10) {
             throw new Error(`Host fee must be greater than 10 bps when no host namespace is provided`);
         }
-        // Clip decimals off reserves before any operations
-        const clippedAssetAInitialReserve = Math.floor(Number(params.assetAInitialReserve)).toString();
-        const clippedVirtualReserveA = Math.floor(Number(params.virtualReserveA)).toString();
-        const clippedVirtualReserveB = Math.floor(Number(params.virtualReserveB)).toString();
+        // Validate reserves are valid positive integers before any operations
+        const assetAInitialReserve = FlashnetClient.parsePositiveIntegerToBigInt(params.assetAInitialReserve, "Asset A Initial Reserve").toString();
+        const virtualReserveA = FlashnetClient.parsePositiveIntegerToBigInt(params.virtualReserveA, "Virtual Reserve A").toString();
+        const virtualReserveB = FlashnetClient.parsePositiveIntegerToBigInt(params.virtualReserveB, "Virtual Reserve B").toString();
         await this.checkBalance({
             balancesToCheck: [
                 {
                     assetAddress: params.assetAAddress,
-                    amount: clippedAssetAInitialReserve,
+                    amount: assetAInitialReserve,
                 },
             ],
             errorPrefix: "Insufficient balance for pool creation: ",
@@ -482,9 +489,9 @@ class FlashnetClient {
             poolOwnerPublicKey,
             assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
             assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
-            assetAInitialReserve: clippedAssetAInitialReserve,
-            virtualReserveA: clippedVirtualReserveA,
-            virtualReserveB: clippedVirtualReserveB,
+            assetAInitialReserve,
+            virtualReserveA,
+            virtualReserveB,
             threshold: params.threshold.toString(),
             lpFeeRateBps: params.lpFeeRateBps.toString(),
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
@@ -497,15 +504,15 @@ class FlashnetClient {
             poolOwnerPublicKey,
             assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
             assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
-            assetAInitialReserve: clippedAssetAInitialReserve,
-            virtualReserveA: clippedVirtualReserveA,
-            virtualReserveB: clippedVirtualReserveB,
+            assetAInitialReserve,
+            virtualReserveA,
+            virtualReserveB,
             threshold: params.threshold.toString(),
             lpFeeRateBps: params.lpFeeRateBps.toString(),
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
             hostNamespace: params.hostNamespace,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const createResponse = await this.typedApi.createSingleSidedPool(request);
         if (params.disableInitialDeposit) {
@@ -519,7 +526,7 @@ class FlashnetClient {
         const assetATransferId = await this.transferAsset({
             receiverSparkAddress: lpSparkAddress,
             assetAddress: params.assetAAddress,
-            amount: clippedAssetAInitialReserve,
+            amount: assetAInitialReserve,
         });
         const confirmResponse = await this.confirmInitialDeposit(createResponse.poolId, assetATransferId, poolOwnerPublicKey);
         if (!confirmResponse.confirmed) {
@@ -548,7 +555,7 @@ class FlashnetClient {
             poolId,
             assetASparkTransferId,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
             poolOwnerPublicKey: poolOwnerPublicKey ?? this.publicKey,
         };
         return this.typedApi.confirmInitialDeposit(request);
@@ -559,6 +566,7 @@ class FlashnetClient {
      */
     async simulateSwap(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.simulateSwap(params);
     }
     /**
@@ -566,6 +574,14 @@ class FlashnetClient {
      */
     async executeSwap(params) {
         await this.ensureInitialized();
+        // Gate by feature flags and ping, and enforce min-amount policy before transfers
+        await this.ensureAmmOperationAllowed("allow_swaps");
+        await this.assertSwapMeetsMinAmounts({
+            assetInAddress: params.assetInAddress,
+            assetOutAddress: params.assetOutAddress,
+            amountIn: params.amountIn,
+            minAmountOut: params.minAmountOut,
+        });
         // Transfer assets to pool using new address encoding
         const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
             identityPublicKey: params.poolId,
@@ -584,6 +600,14 @@ class FlashnetClient {
     }
     async executeSwapIntent(params) {
         await this.ensureInitialized();
+        // Also enforce gating and min amounts for direct intent usage
+        await this.ensureAmmOperationAllowed("allow_swaps");
+        await this.assertSwapMeetsMinAmounts({
+            assetInAddress: params.assetInAddress,
+            assetOutAddress: params.assetOutAddress,
+            amountIn: params.amountIn,
+            minAmountOut: params.minAmountOut,
+        });
         // Generate swap intent
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generatePoolSwapIntentMessage({
@@ -613,7 +637,7 @@ class FlashnetClient {
             totalIntegratorFeeRateBps: params.integratorFeeRateBps?.toString() || "0",
             integratorPublicKey: params.integratorPublicKey || "",
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.executeSwap(request);
         // Check if the swap was accepted
@@ -634,6 +658,7 @@ class FlashnetClient {
             throw new Error("Route swap cannot have more than 4 hops");
         }
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.simulateRouteSwap(params);
     }
     /**
@@ -641,6 +666,18 @@ class FlashnetClient {
      */
     async executeRouteSwap(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_route_swaps");
+        // Validate min-amount policy for route: check initial input and final output asset
+        const finalOutputAsset = params.hops[params.hops.length - 1]?.assetOutAddress;
+        if (!finalOutputAsset) {
+            throw new Error("Route swap requires at least one hop with output asset");
+        }
+        await this.assertSwapMeetsMinAmounts({
+            assetInAddress: params.initialAssetAddress,
+            assetOutAddress: finalOutputAsset,
+            amountIn: params.inputAmount,
+            minAmountOut: params.minAmountOut,
+        });
         // Validate hops array
         if (params.hops.length > 4) {
             throw new Error("Route swap cannot have more than 4 hops");
@@ -710,7 +747,7 @@ class FlashnetClient {
             maxRouteSlippageBps: params.maxRouteSlippageBps.toString(),
             minAmountOut: params.minAmountOut,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
             integratorFeeRateBps: params.integratorFeeRateBps?.toString() || "0",
             integratorPublicKey: params.integratorPublicKey || "",
         };
@@ -731,6 +768,7 @@ class FlashnetClient {
      */
     async simulateAddLiquidity(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.simulateAddLiquidity(params);
     }
     /**
@@ -738,8 +776,15 @@ class FlashnetClient {
      */
     async addLiquidity(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_add_liquidity");
         // Get pool details to know which assets we're dealing with
         const pool = await this.getPool(params.poolId);
+        // Enforce min-amount policy for inputs based on pool assets
+        await this.assertAddLiquidityMeetsMinAmounts({
+            poolId: params.poolId,
+            assetAAmount: params.assetAAmount,
+            assetBAmount: params.assetBAmount,
+        });
         // Transfer assets to pool using new address encoding
         const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
             identityPublicKey: params.poolId,
@@ -783,7 +828,7 @@ class FlashnetClient {
             assetAMinAmountIn: params.assetAMinAmountIn.toString(),
             assetBMinAmountIn: params.assetBMinAmountIn.toString(),
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.addLiquidity(request);
         // Check if the liquidity addition was accepted
@@ -801,6 +846,7 @@ class FlashnetClient {
      */
     async simulateRemoveLiquidity(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.simulateRemoveLiquidity(params);
     }
     /**
@@ -808,6 +854,7 @@ class FlashnetClient {
      */
     async removeLiquidity(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_withdraw_liquidity");
         // Check LP token balance
         const position = await this.getLpPosition(params.poolId);
         const lpTokensOwned = position.lpTokensOwned;
@@ -815,6 +862,11 @@ class FlashnetClient {
         if (index$2.compareDecimalStrings(lpTokensOwned, tokensToRemove) < 0) {
             throw new Error(`Insufficient LP tokens. Owned: ${lpTokensOwned}, Requested: ${tokensToRemove}`);
         }
+        // Pre-simulate and enforce min-amount policy for outputs
+        await this.assertRemoveLiquidityMeetsMinAmounts({
+            poolId: params.poolId,
+            lpTokensToRemove: params.lpTokensToRemove,
+        });
         // Generate remove liquidity intent
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generateRemoveLiquidityIntentMessage({
@@ -831,7 +883,7 @@ class FlashnetClient {
             poolId: params.poolId,
             lpTokensToRemove: params.lpTokensToRemove,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.removeLiquidity(request);
         // Check if the liquidity removal was accepted
@@ -847,6 +899,7 @@ class FlashnetClient {
      */
     async registerHost(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const feeRecipient = params.feeRecipientPublicKey || this.publicKey;
         const nonce = index$2.generateNonce();
         // Generate intent
@@ -864,7 +917,7 @@ class FlashnetClient {
             minFeeBps: params.minFeeBps,
             feeRecipientPublicKey: feeRecipient,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         return this.typedApi.registerHost(request);
     }
@@ -880,6 +933,7 @@ class FlashnetClient {
      */
     async getPoolHostFees(hostNamespace, poolId) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.getPoolHostFees({ hostNamespace, poolId });
     }
     /**
@@ -894,6 +948,7 @@ class FlashnetClient {
      */
     async withdrawHostFees(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_withdraw_fees");
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generateWithdrawHostFeesIntentMessage({
             hostPublicKey: this.publicKey,
@@ -908,7 +963,7 @@ class FlashnetClient {
             lpIdentityPublicKey: params.lpIdentityPublicKey,
             assetBAmount: params.assetBAmount,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.withdrawHostFees(request);
         // Check if the withdrawal was accepted
@@ -923,6 +978,7 @@ class FlashnetClient {
      */
     async getHostFees(hostNamespace) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const request = {
             hostNamespace,
         };
@@ -940,6 +996,7 @@ class FlashnetClient {
      */
     async getPoolIntegratorFees(poolId) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.getPoolIntegratorFees({ poolId });
     }
     /**
@@ -947,6 +1004,7 @@ class FlashnetClient {
      */
     async withdrawIntegratorFees(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_withdraw_fees");
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generateWithdrawIntegratorFeesIntentMessage({
             integratorPublicKey: this.publicKey,
@@ -962,7 +1020,7 @@ class FlashnetClient {
             lpIdentityPublicKey: params.lpIdentityPublicKey,
             assetBAmount: params.assetBAmount,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.withdrawIntegratorFees(request);
         // Check if the withdrawal was accepted
@@ -988,6 +1046,7 @@ class FlashnetClient {
      */
     async createEscrow(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const nonce = index$2.generateNonce();
         // The intent message requires a different structure for recipients and conditions
         const intentRecipients = params.recipients.map((r) => ({
@@ -1016,7 +1075,7 @@ class FlashnetClient {
             abandonHost: params.abandonHost,
             abandonConditions: params.abandonConditions,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const createResponse = await this.typedApi.createEscrow(request);
         const autoFund = params.autoFund !== false;
@@ -1039,6 +1098,7 @@ class FlashnetClient {
      */
     async fundEscrow(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         // 1. Balance check
         await this.checkBalance({
             balancesToCheck: [
@@ -1063,6 +1123,7 @@ class FlashnetClient {
         });
     }
     async executeFundEscrowIntent(params) {
+        await this.ensurePingOk();
         // Generate intent
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generateFundEscrowIntentMessage({
@@ -1077,7 +1138,7 @@ class FlashnetClient {
         const request = {
             ...params,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         return this.typedApi.fundEscrow(request);
     }
@@ -1089,6 +1150,7 @@ class FlashnetClient {
      */
     async claimEscrow(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generateClaimEscrowIntentMessage({
             escrowId: params.escrowId,
@@ -1100,7 +1162,7 @@ class FlashnetClient {
         const request = {
             escrowId: params.escrowId,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         return this.typedApi.claimEscrow(request);
     }
@@ -1143,6 +1205,7 @@ class FlashnetClient {
      */
     async clawback(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generateClawbackIntentMessage({
             senderPublicKey: this.publicKey,
@@ -1157,7 +1220,7 @@ class FlashnetClient {
             sparkTransferId: params.sparkTransferId,
             lpIdentityPublicKey: params.lpIdentityPublicKey,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.clawback(request);
         if (!response.accepted) {
@@ -1252,6 +1315,13 @@ class FlashnetClient {
      * Helper method to add initial liquidity after pool creation
      */
     async addInitialLiquidity(poolId, assetAAddress, assetBAddress, assetAAmount, assetBAmount, assetAMinAmountIn, assetBMinAmountIn) {
+        // Enforce gating and min-amount policy for initial liquidity
+        await this.ensureAmmOperationAllowed("allow_add_liquidity");
+        await this.assertAddLiquidityMeetsMinAmounts({
+            poolId,
+            assetAAmount,
+            assetBAmount,
+        });
         const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
             identityPublicKey: poolId,
             network: this.sparkNetwork,
@@ -1293,7 +1363,7 @@ class FlashnetClient {
             assetAMinAmountIn: assetAMinAmountIn.toString(),
             assetBMinAmountIn: assetBMinAmountIn.toString(),
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: hex.getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.addLiquidity(request);
         // Check if the initial liquidity addition was accepted
@@ -1308,6 +1378,186 @@ class FlashnetClient {
     async cleanup() {
         await this._wallet.cleanupConnections();
     }
+    // ===== Config and Policy Enforcement Helpers =====
+    async ensureAmmOperationAllowed(requiredFeature) {
+        await this.ensurePingOk();
+        const featureMap = await this.getFeatureStatusMap();
+        if (featureMap.get("master_kill_switch")) {
+            throw new Error("Service is temporarily disabled by master kill switch");
+        }
+        if (!featureMap.get(requiredFeature)) {
+            throw new Error(`Operation not allowed: feature '${requiredFeature}' is disabled`);
+        }
+    }
+    async ensurePingOk() {
+        const now = Date.now();
+        if (this.pingCache && this.pingCache.expiryMs > now) {
+            if (!this.pingCache.ok) {
+                throw new Error("Settlement service unavailable. Only read (GET) operations are allowed right now.");
+            }
+            return;
+        }
+        const ping = await this.typedApi.ping();
+        const ok = !!ping &&
+            typeof ping.status === "string" &&
+            ping.status.toLowerCase() === "ok";
+        this.pingCache = { ok, expiryMs: now + FlashnetClient.PING_TTL_MS };
+        if (!ok) {
+            throw new Error("Settlement service unavailable. Only read (GET) operations are allowed right now.");
+        }
+    }
+    async getFeatureStatusMap() {
+        const now = Date.now();
+        if (this.featureStatusCache && this.featureStatusCache.expiryMs > now) {
+            const map = new Map();
+            for (const item of this.featureStatusCache.data) {
+                map.set(item.feature_name, Boolean(item.enabled));
+            }
+            return map;
+        }
+        const data = await this.typedApi.getFeatureStatus();
+        this.featureStatusCache = {
+            data,
+            expiryMs: now + FlashnetClient.FEATURE_STATUS_TTL_MS,
+        };
+        const map = new Map();
+        for (const item of data) {
+            map.set(item.feature_name, Boolean(item.enabled));
+        }
+        return map;
+    }
+    async getEnabledMinAmountsMap() {
+        const now = Date.now();
+        if (this.minAmountsCache && this.minAmountsCache.expiryMs > now) {
+            return this.minAmountsCache.map;
+        }
+        const config = await this.typedApi.getMinAmounts();
+        const map = new Map();
+        for (const item of config) {
+            if (item.enabled) {
+                const key = item.asset_identifier.toLowerCase();
+                const value = BigInt(String(item.min_amount));
+                map.set(key, value);
+            }
+        }
+        this.minAmountsCache = {
+            map,
+            expiryMs: now + FlashnetClient.MIN_AMOUNTS_TTL_MS,
+        };
+        return map;
+    }
+    getHexAddress(addr) {
+        return this.toHexTokenIdentifier(addr).toLowerCase();
+    }
+    async assertSwapMeetsMinAmounts(params) {
+        const minMap = await this.getEnabledMinAmountsMap();
+        if (minMap.size === 0) {
+            return;
+        }
+        const inHex = this.getHexAddress(params.assetInAddress);
+        const outHex = this.getHexAddress(params.assetOutAddress);
+        const minIn = minMap.get(inHex);
+        const minOut = minMap.get(outHex);
+        const amountIn = BigInt(String(params.amountIn));
+        const minAmountOut = BigInt(String(params.minAmountOut));
+        if (minIn && minOut) {
+            if (amountIn < minIn) {
+                throw new Error(`Minimum amount not met for input asset. Required \
+${minIn.toString()}, provided ${amountIn.toString()}`);
+            }
+            return;
+        }
+        if (minIn) {
+            if (amountIn < minIn) {
+                throw new Error(`Minimum amount not met for input asset. Required \
+${minIn.toString()}, provided ${amountIn.toString()}`);
+            }
+            return;
+        }
+        if (minOut) {
+            const relaxed = minOut / 2n; // 50% relaxation for slippage
+            if (minAmountOut < relaxed) {
+                throw new Error(`Minimum amount not met for output asset. Required at least \
+${relaxed.toString()} (50% relaxed), provided minAmountOut ${minAmountOut.toString()}`);
+            }
+        }
+    }
+    async assertAddLiquidityMeetsMinAmounts(params) {
+        const minMap = await this.getEnabledMinAmountsMap();
+        if (minMap.size === 0) {
+            return;
+        }
+        const pool = await this.getPool(params.poolId);
+        const aHex = pool.assetAAddress.toLowerCase();
+        const bHex = pool.assetBAddress.toLowerCase();
+        const aMin = minMap.get(aHex);
+        const bMin = minMap.get(bHex);
+        if (aMin) {
+            const aAmt = BigInt(String(params.assetAAmount));
+            if (aAmt < aMin) {
+                throw new Error(`Minimum amount not met for Asset A. Required ${aMin.toString()}, provided ${aAmt.toString()}`);
+            }
+        }
+        if (bMin) {
+            const bAmt = BigInt(String(params.assetBAmount));
+            if (bAmt < bMin) {
+                throw new Error(`Minimum amount not met for Asset B. Required ${bMin.toString()}, provided ${bAmt.toString()}`);
+            }
+        }
+    }
+    async assertRemoveLiquidityMeetsMinAmounts(params) {
+        const minMap = await this.getEnabledMinAmountsMap();
+        if (minMap.size === 0) {
+            return;
+        }
+        const simulation = await this.simulateRemoveLiquidity({
+            poolId: params.poolId,
+            providerPublicKey: this.publicKey,
+            lpTokensToRemove: String(params.lpTokensToRemove),
+        });
+        const pool = await this.getPool(params.poolId);
+        const aHex = pool.assetAAddress.toLowerCase();
+        const bHex = pool.assetBAddress.toLowerCase();
+        const aMin = minMap.get(aHex);
+        const bMin = minMap.get(bHex);
+        if (aMin) {
+            const predictedAOut = BigInt(String(simulation.assetAAmount));
+            const relaxedA = aMin / 2n; // apply 50% relaxation for outputs
+            if (predictedAOut < relaxedA) {
+                throw new Error(`Minimum amount not met for Asset A on withdrawal. Required at least ${relaxedA.toString()} (50% relaxed), predicted ${predictedAOut.toString()}`);
+            }
+        }
+        if (bMin) {
+            const predictedBOut = BigInt(String(simulation.assetBAmount));
+            const relaxedB = bMin / 2n;
+            if (predictedBOut < relaxedB) {
+                throw new Error(`Minimum amount not met for Asset B on withdrawal. Required at least ${relaxedB.toString()} (50% relaxed), predicted ${predictedBOut.toString()}`);
+            }
+        }
+    }
+    async assertAllowedAssetBForPoolCreation(assetBHex) {
+        const now = Date.now();
+        let allowed;
+        if (this.allowedAssetsCache && this.allowedAssetsCache.expiryMs > now) {
+            allowed = this.allowedAssetsCache.data;
+        }
+        else {
+            allowed = await this.typedApi.getAllowedAssets();
+            this.allowedAssetsCache = {
+                data: allowed,
+                expiryMs: now + FlashnetClient.ALLOWED_ASSETS_TTL_MS,
+            };
+        }
+        if (!allowed || allowed.length === 0) {
+            // Wildcard allowance
+            return;
+        }
+        const isAllowed = allowed.some((it) => it.enabled &&
+            it.asset_identifier.toLowerCase() === assetBHex.toLowerCase());
+        if (!isAllowed) {
+            throw new Error(`Asset B is not allowed for pool creation: ${assetBHex}`);
+        }
+    }
 }
 
 exports.FlashnetClient = FlashnetClient;