@flashnet/sdk 0.3.23 → 0.3.25

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

@@ -4,6 +4,7 @@ import { getClientEnvironmentName, resolveClientNetworkConfig, getClientNetworkC
 import { getSparkNetworkFromLegacy, getClientEnvironmentFromLegacy, Network } from '../types/index.js';
 import { generateNonce, compareDecimalStrings } from '../utils/index.js';
 import { AuthManager } from '../utils/auth.js';
+import { getHexFromUint8Array } from '../utils/hex.js';
 import { generateConstantProductPoolInitializationIntentMessage, generatePoolInitializationIntentMessage, generatePoolConfirmInitialDepositIntentMessage, generatePoolSwapIntentMessage, generateRouteSwapIntentMessage, generateAddLiquidityIntentMessage, generateRemoveLiquidityIntentMessage, generateRegisterHostIntentMessage, generateWithdrawHostFeesIntentMessage, generateWithdrawIntegratorFeesIntentMessage, generateCreateEscrowIntentMessage, generateFundEscrowIntentMessage, generateClaimEscrowIntentMessage, generateClawbackIntentMessage } from '../utils/intents.js';
 import { createWalletSigner } from '../utils/signer.js';
 import { getSparkNetworkFromAddress, encodeSparkAddressNew } from '../utils/spark-address.js';
@@ -29,6 +30,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
      */
@@ -225,7 +236,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 = getHexFromUint8Array(info.rawTokenIdentifier);
                 const tokenAddress = encodeSparkHumanReadableTokenIdentifier(info.rawTokenIdentifier, this.sparkNetwork);
                 tokenBalances.set(tokenPubkey, {
                     balance: BigInt(tokenData.balance),
@@ -323,6 +334,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({
@@ -362,7 +375,7 @@ class FlashnetClient {
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
             hostNamespace: params.hostNamespace || "",
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.createConstantProductPool(request);
         // Add initial liquidity if specified
@@ -371,6 +384,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.
      *
@@ -385,38 +423,13 @@ 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");
         }
-        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;
@@ -431,16 +444,22 @@ class FlashnetClient {
         //            (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;
+        // totalA is (supply * f * f) / denom
+        const totalANumerator = BigInt(supply) * graduationThresholdPct * graduationThresholdPct;
+        const totalADenominator = 200n * graduationThresholdPct - 10000n;
+        const totalARemainder = totalANumerator % totalADenominator;
+        const totalA = (totalANumerator - totalARemainder) / totalADenominator;
+        // Since there is an initial supply of tokens, we subtract that amount
+        // to get the remaining "virtual" amount for pricing
+        const virtualA = totalA - supply;
+        // totalB is (targetB * g * (1 - f)) / denom
+        const totalBNumerator = BigInt(targetB) * (100n - graduationThresholdPct);
+        const totalBDenominator = 2n * graduationThresholdPct - 100n;
+        const totalBRemainder = totalBNumerator % totalBDenominator;
+        const totalB = (totalBNumerator - totalBRemainder) / totalBDenominator;
+        // Bonding curve starts with no deposited amount of asset B,
+        // so virtualB is all of totalB
+        const virtualB = totalB;
         // Calculate threshold as amount of asset A (not percentage)
         const threshold = (BigInt(supply) * graduationThresholdPct) / 100n;
         return {
@@ -457,18 +476,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: ",
@@ -480,9 +501,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(),
@@ -495,15 +516,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: getHexFromUint8Array(signature),
         };
         const createResponse = await this.typedApi.createSingleSidedPool(request);
         if (params.disableInitialDeposit) {
@@ -517,7 +538,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) {
@@ -546,7 +567,7 @@ class FlashnetClient {
             poolId,
             assetASparkTransferId,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
             poolOwnerPublicKey: poolOwnerPublicKey ?? this.publicKey,
         };
         return this.typedApi.confirmInitialDeposit(request);
@@ -557,6 +578,7 @@ class FlashnetClient {
      */
     async simulateSwap(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.simulateSwap(params);
     }
     /**
@@ -564,6 +586,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 = encodeSparkAddressNew({
             identityPublicKey: params.poolId,
@@ -582,6 +612,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 = generateNonce();
         const intentMessage = generatePoolSwapIntentMessage({
@@ -611,7 +649,7 @@ class FlashnetClient {
             totalIntegratorFeeRateBps: params.integratorFeeRateBps?.toString() || "0",
             integratorPublicKey: params.integratorPublicKey || "",
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.executeSwap(request);
         // Check if the swap was accepted
@@ -632,6 +670,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);
     }
     /**
@@ -639,6 +678,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");
@@ -708,7 +759,7 @@ class FlashnetClient {
             maxRouteSlippageBps: params.maxRouteSlippageBps.toString(),
             minAmountOut: params.minAmountOut,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
             integratorFeeRateBps: params.integratorFeeRateBps?.toString() || "0",
             integratorPublicKey: params.integratorPublicKey || "",
         };
@@ -729,6 +780,7 @@ class FlashnetClient {
      */
     async simulateAddLiquidity(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.simulateAddLiquidity(params);
     }
     /**
@@ -736,8 +788,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 = encodeSparkAddressNew({
             identityPublicKey: params.poolId,
@@ -781,7 +840,7 @@ class FlashnetClient {
             assetAMinAmountIn: params.assetAMinAmountIn.toString(),
             assetBMinAmountIn: params.assetBMinAmountIn.toString(),
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.addLiquidity(request);
         // Check if the liquidity addition was accepted
@@ -799,6 +858,7 @@ class FlashnetClient {
      */
     async simulateRemoveLiquidity(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.simulateRemoveLiquidity(params);
     }
     /**
@@ -806,6 +866,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;
@@ -813,6 +874,11 @@ class FlashnetClient {
         if (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 = generateNonce();
         const intentMessage = generateRemoveLiquidityIntentMessage({
@@ -829,7 +895,7 @@ class FlashnetClient {
             poolId: params.poolId,
             lpTokensToRemove: params.lpTokensToRemove,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.removeLiquidity(request);
         // Check if the liquidity removal was accepted
@@ -845,6 +911,7 @@ class FlashnetClient {
      */
     async registerHost(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const feeRecipient = params.feeRecipientPublicKey || this.publicKey;
         const nonce = generateNonce();
         // Generate intent
@@ -862,7 +929,7 @@ class FlashnetClient {
             minFeeBps: params.minFeeBps,
             feeRecipientPublicKey: feeRecipient,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         return this.typedApi.registerHost(request);
     }
@@ -878,6 +945,7 @@ class FlashnetClient {
      */
     async getPoolHostFees(hostNamespace, poolId) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.getPoolHostFees({ hostNamespace, poolId });
     }
     /**
@@ -892,6 +960,7 @@ class FlashnetClient {
      */
     async withdrawHostFees(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_withdraw_fees");
         const nonce = generateNonce();
         const intentMessage = generateWithdrawHostFeesIntentMessage({
             hostPublicKey: this.publicKey,
@@ -906,7 +975,7 @@ class FlashnetClient {
             lpIdentityPublicKey: params.lpIdentityPublicKey,
             assetBAmount: params.assetBAmount,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.withdrawHostFees(request);
         // Check if the withdrawal was accepted
@@ -921,6 +990,7 @@ class FlashnetClient {
      */
     async getHostFees(hostNamespace) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const request = {
             hostNamespace,
         };
@@ -938,6 +1008,7 @@ class FlashnetClient {
      */
     async getPoolIntegratorFees(poolId) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         return this.typedApi.getPoolIntegratorFees({ poolId });
     }
     /**
@@ -945,6 +1016,7 @@ class FlashnetClient {
      */
     async withdrawIntegratorFees(params) {
         await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_withdraw_fees");
         const nonce = generateNonce();
         const intentMessage = generateWithdrawIntegratorFeesIntentMessage({
             integratorPublicKey: this.publicKey,
@@ -960,7 +1032,7 @@ class FlashnetClient {
             lpIdentityPublicKey: params.lpIdentityPublicKey,
             assetBAmount: params.assetBAmount,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.withdrawIntegratorFees(request);
         // Check if the withdrawal was accepted
@@ -986,6 +1058,7 @@ class FlashnetClient {
      */
     async createEscrow(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const nonce = generateNonce();
         // The intent message requires a different structure for recipients and conditions
         const intentRecipients = params.recipients.map((r) => ({
@@ -1014,7 +1087,7 @@ class FlashnetClient {
             abandonHost: params.abandonHost,
             abandonConditions: params.abandonConditions,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const createResponse = await this.typedApi.createEscrow(request);
         const autoFund = params.autoFund !== false;
@@ -1037,6 +1110,7 @@ class FlashnetClient {
      */
     async fundEscrow(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         // 1. Balance check
         await this.checkBalance({
             balancesToCheck: [
@@ -1061,6 +1135,7 @@ class FlashnetClient {
         });
     }
     async executeFundEscrowIntent(params) {
+        await this.ensurePingOk();
         // Generate intent
         const nonce = generateNonce();
         const intentMessage = generateFundEscrowIntentMessage({
@@ -1075,7 +1150,7 @@ class FlashnetClient {
         const request = {
             ...params,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         return this.typedApi.fundEscrow(request);
     }
@@ -1087,6 +1162,7 @@ class FlashnetClient {
      */
     async claimEscrow(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const nonce = generateNonce();
         const intentMessage = generateClaimEscrowIntentMessage({
             escrowId: params.escrowId,
@@ -1098,7 +1174,7 @@ class FlashnetClient {
         const request = {
             escrowId: params.escrowId,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         return this.typedApi.claimEscrow(request);
     }
@@ -1141,6 +1217,7 @@ class FlashnetClient {
      */
     async clawback(params) {
         await this.ensureInitialized();
+        await this.ensurePingOk();
         const nonce = generateNonce();
         const intentMessage = generateClawbackIntentMessage({
             senderPublicKey: this.publicKey,
@@ -1155,7 +1232,7 @@ class FlashnetClient {
             sparkTransferId: params.sparkTransferId,
             lpIdentityPublicKey: params.lpIdentityPublicKey,
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.clawback(request);
         if (!response.accepted) {
@@ -1250,6 +1327,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 = encodeSparkAddressNew({
             identityPublicKey: poolId,
             network: this.sparkNetwork,
@@ -1291,7 +1375,7 @@ class FlashnetClient {
             assetAMinAmountIn: assetAMinAmountIn.toString(),
             assetBMinAmountIn: assetBMinAmountIn.toString(),
             nonce,
-            signature: Buffer.from(signature).toString("hex"),
+            signature: getHexFromUint8Array(signature),
         };
         const response = await this.typedApi.addLiquidity(request);
         // Check if the initial liquidity addition was accepted
@@ -1306,6 +1390,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}`);
+        }
+    }
 }
 
 export { FlashnetClient };