lnlink-server 1.1.6 → 1.1.8

package/dist/index.js

@@ -22,6 +22,7 @@ var require_config_default = __commonJS({
       LINK_DATA_PATH: "",
       LINK_FLASH_SITE_BASE_URL: "https://devofflash.unift.xyz",
       LINK_LNFI_NODE_SITE_URL: "https://devoflnnode.unift.xyz",
+      LINK_RGB_PRICE_SERVER_URL: "https://api-oracle.lnfi.network",
       LINK_OWNER: "",
       LINK_SETTING_FILE_PATH: ""
       // LINK_SETTING_FILE_PATH: "",
@@ -880,7 +881,9 @@ var require_constants = __commonJS({
       "link_status",
       "list_unspents",
       "decode_rgb_invoice",
-      "decode_ln_invoice"
+      "decode_ln_invoice",
+      "get_exchange_rate",
+      "list_exchange_orders"
     ];
     var OWNER_PERMISSIONS = [
       "genseed",
@@ -922,6 +925,7 @@ var require_constants = __commonJS({
       "pay_rgb_invoice",
       "disconnect_peer",
       "create_invoice",
+      "create_hodl_invoice",
       "pay_invoice",
       "backup_node",
       "restore_node",
@@ -1286,6 +1290,163 @@ var require_events = __commonJS({
   }
 });
 
+// business/service/prisma/repositories/exchangeOrderRepository.js
+var require_exchangeOrderRepository = __commonJS({
+  "business/service/prisma/repositories/exchangeOrderRepository.js"(exports2, module2) {
+    var PrismaService = require_prismaService();
+    var ExchangeOrderRepository = class {
+      static {
+        __name(this, "ExchangeOrderRepository");
+      }
+      constructor() {
+        this.prisma = PrismaService.getInstance().getClient();
+      }
+      async createOrder(data) {
+        const now = Math.floor(Date.now() / 1e3);
+        return this.prisma.exchangeOrder.create({
+          data: {
+            payment_hash: data.payment_hash,
+            btc_invoice: data.btc_invoice,
+            btc_amount: data.btc_amount,
+            rgb_invoice: data.rgb_invoice || null,
+            asset_id: data.asset_id,
+            asset_amount: data.asset_amount,
+            preimage: data.preimage || null,
+            status: data.status,
+            error_message: data.error_message || null,
+            htlc_expiry_at: data.htlc_expiry_at,
+            created_at: data.created_at || now,
+            updated_at: data.updated_at || now
+          }
+        });
+      }
+      async getOrderById(id) {
+        return this.prisma.exchangeOrder.findUnique({ where: { id } });
+      }
+      async getOrderByPaymentHash(payment_hash) {
+        return this.prisma.exchangeOrder.findUnique({ where: { payment_hash } });
+      }
+      async getOrdersByStatus(status) {
+        return this.prisma.exchangeOrder.findMany({
+          where: { status },
+          orderBy: { created_at: "asc" }
+        });
+      }
+      async getOrders({
+        status,
+        page = 1,
+        page_size = 20
+      } = {}) {
+        const where = status ? { status } : {};
+        const [list, total] = await Promise.all([
+          this.prisma.exchangeOrder.findMany({
+            where,
+            orderBy: { created_at: "desc" },
+            skip: (page - 1) * page_size,
+            take: page_size
+          }),
+          this.prisma.exchangeOrder.count({ where })
+        ]);
+        return { list, total };
+      }
+      async updateOrder(id, data) {
+        return this.prisma.exchangeOrder.update({
+          where: { id },
+          data: {
+            ...data,
+            updated_at: Math.floor(Date.now() / 1e3)
+          }
+        });
+      }
+      /**
+       * Optimistic lock: only update if current status matches expectedStatus.
+       * Returns true if update succeeded, false if status already changed.
+       */
+      async updateOrderWithExpectedStatus(id, expectedStatus, data) {
+        const result = await this.prisma.exchangeOrder.updateMany({
+          where: { id, status: expectedStatus },
+          data: {
+            ...data,
+            updated_at: Math.floor(Date.now() / 1e3)
+          }
+        });
+        return result.count > 0;
+      }
+      async getOrdersByStatusIn(statuses) {
+        return this.prisma.exchangeOrder.findMany({
+          where: { status: { in: statuses } },
+          orderBy: { created_at: "asc" }
+        });
+      }
+    };
+    module2.exports = ExchangeOrderRepository;
+  }
+});
+
+// business/service/prisma/db/exchangeOrders.js
+var require_exchangeOrders = __commonJS({
+  "business/service/prisma/db/exchangeOrders.js"(exports2, module2) {
+    var Logger = require_linkLogger();
+    var ExchangeOrderRepository = require_exchangeOrderRepository();
+    var repo = null;
+    function getRepo() {
+      if (!repo) {
+        repo = new ExchangeOrderRepository();
+      }
+      return repo;
+    }
+    __name(getRepo, "getRepo");
+    module2.exports = {
+      createExchangeOrder: /* @__PURE__ */ __name(async (data) => {
+        const logger2 = new Logger("exchangeOrderDB");
+        try {
+          return await getRepo().createOrder(data);
+        } catch (error) {
+          logger2.error("Error creating exchange order:", error.message);
+          throw error;
+        }
+      }, "createExchangeOrder"),
+      getExchangeOrderById: /* @__PURE__ */ __name(async (id) => {
+        return getRepo().getOrderById(id);
+      }, "getExchangeOrderById"),
+      getExchangeOrderByPaymentHash: /* @__PURE__ */ __name(async (payment_hash) => {
+        return getRepo().getOrderByPaymentHash(payment_hash);
+      }, "getExchangeOrderByPaymentHash"),
+      getExchangeOrdersByStatus: /* @__PURE__ */ __name(async (status) => {
+        return getRepo().getOrdersByStatus(status);
+      }, "getExchangeOrdersByStatus"),
+      getExchangeOrdersByStatusIn: /* @__PURE__ */ __name(async (statuses) => {
+        return getRepo().getOrdersByStatusIn(statuses);
+      }, "getExchangeOrdersByStatusIn"),
+      getExchangeOrders: /* @__PURE__ */ __name(async (filters) => {
+        return getRepo().getOrders(filters);
+      }, "getExchangeOrders"),
+      updateExchangeOrder: /* @__PURE__ */ __name(async (id, data) => {
+        const logger2 = new Logger("exchangeOrderDB");
+        try {
+          return await getRepo().updateOrder(id, data);
+        } catch (error) {
+          logger2.error("Error updating exchange order:", error.message);
+          throw error;
+        }
+      }, "updateExchangeOrder"),
+      /**
+       * Optimistic lock update: only succeeds if current status matches expectedStatus.
+       * Returns true if updated, false if status already changed (stale).
+       */
+      updateExchangeOrderWithExpectedStatus: /* @__PURE__ */ __name(async (id, expectedStatus, data) => {
+        const logger2 = new Logger("exchangeOrderDB");
+        try {
+          return await getRepo().updateOrderWithExpectedStatus(id, expectedStatus, data);
+        } catch (error) {
+          logger2.error("Error updating exchange order (optimistic):", error.message);
+          throw error;
+        }
+      }, "updateExchangeOrderWithExpectedStatus")
+    };
+  }
+});
+
 // business/service/prisma/repositories/orderRepository.js
 var require_orderRepository = __commonJS({
   "business/service/prisma/repositories/orderRepository.js"(exports2, module2) {
@@ -2532,6 +2693,7 @@ var require_dbService = __commonJS({
   "business/service/prisma/dbService.js"(exports2, module2) {
     var config = require_config();
     var events = require_events();
+    var exchangeOrders = require_exchangeOrders();
     var orders = require_orders();
     var transactions = require_transactions();
     var users = require_users();
@@ -2542,6 +2704,7 @@ var require_dbService = __commonJS({
       ...users,
       ...transactions,
       ...orders,
+      ...exchangeOrders,
       ...utils
     };
   }
@@ -2651,6 +2814,7 @@ var require_getConfig = __commonJS({
             officialUniverseServer,
             priceOracle,
             rgbProxy,
+            rgbPriceServer,
             enableTor
           } = settingFileData;
           const litdRgbConfig = {
@@ -2667,6 +2831,7 @@ var require_getConfig = __commonJS({
             LINK_RGB_BITCOIND_RPCPASS: bitcoindPass,
             LINK_RGB_ELECTRS_HOST: bitcoindIndex,
             LINK_RGB_PROXY_ENDPOINT: rgbProxy,
+            LINK_RGB_PRICE_SERVER_URL: rgbPriceServer || void 0,
             LINK_RGB_REMOTE_NODE_PUBKEY: officialRgbPeer,
             LINK_RGB_REMOTE_NODE_HOST: officialRgbPeerHost,
             LINK_BITCOIND_RPCHOST: bitcoindRpcHost && bitcoindRpcPort ? `${bitcoindRpcHost}:${bitcoindRpcPort}` : void 0,
@@ -2900,13 +3065,16 @@ var require_getConfig = __commonJS({
           }
           combinedConfig.LINK_TOR_SOCKS_PORT = combinedConfig.LINK_TOR_SOCKS_PORT || 9050;
           combinedConfig.LINK_TOR_CONTROL_PORT = combinedConfig.LINK_TOR_CONTROL_PORT || 9051;
-          try {
-            combinedConfig = await assignAvailablePorts(combinedConfig);
-          } catch (portError) {
-            console.warn(
-              "Port assignment failed, using default ports:",
-              portError.message
-            );
+          const isExternalNodes = combinedConfig.LINK_EXTERNAL_NODES === "true" || combinedConfig.LINK_EXTERNAL_NODES === true;
+          if (!isExternalNodes) {
+            try {
+              combinedConfig = await assignAvailablePorts(combinedConfig);
+            } catch (portError) {
+              console.warn(
+                "Port assignment failed, using default ports:",
+                portError.message
+              );
+            }
           }
           combinedConfig.LINK_GRPC_HOST = `localhost:${combinedConfig.LINK_LND_RPC_PORT}`;
           combinedConfig.LINK_ENABLE_TOR = combinedConfig.LINK_ENABLE_TOR === "true" || combinedConfig.LINK_ENABLE_TOR === true;
@@ -5384,6 +5552,10 @@ var require_config2 = __commonJS({
       }
       try {
         const config = getConfig2();
+        const isExternalNodes = config.LINK_EXTERNAL_NODES === "true" || config.LINK_EXTERNAL_NODES === true;
+        if (isExternalNodes) {
+          return null;
+        }
         const torBinary = path2.join(config.LINK_BINARY_PATH || "", getBinaryName("tor"));
         const output = execSync(`"${torBinary}" --hash-password "${TOR_CONTROL_PASSWORD}"`, {
           encoding: "utf-8",
@@ -6108,7 +6280,8 @@ var require_client4 = __commonJS({
           throw new Error("RGB configuration not available");
         }
         rgbClient = new RgbApiClient({
-          baseUrl: `http://127.0.0.1:${config.LINK_RGB_LISTENING_PORT}`
+          // baseUrl: `http://127.0.0.1:${config.LINK_RGB_LISTENING_PORT}`,
+          baseUrl: "http://35.221.95.26:9744"
         });
       }
       return rgbClient;
@@ -7181,7 +7354,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "lnlink-server",
-      version: "1.1.6",
+      version: "1.1.8",
       private: false,
       main: "dist/index.js",
       files: [
@@ -7193,7 +7366,7 @@ var require_package = __commonJS({
         build: "node build.js && node build.js --mode development --external all --entry electron",
         "start:bin": "node scripts/start-bin.js",
         "start:docker:dev": "dotenv -e .env.dev -- docker compose -f ./docker-compose.dev.yml up --build",
-        "start:dev": 'dotenv -e .env.dev -- sh -c "prisma generate && (prisma migrate dev --name auto_update || prisma db push) && clinic heapprof -- node ./app.js"',
+        "start:dev": 'dotenv -e .env.dev -- sh -c "prisma generate && (prisma migrate dev --name auto_update || prisma db push) && node ./app.js"',
         "start:regtest": "docker compose --env-file ./.env.regtest -f ./docker-compose-lnlink.yml up --build",
         "start:testnet": "docker compose --env-file ./.env.testnet -f ./docker-compose-lnlink.yml up --build",
         "start:mainnet": "docker compose --env-file ./.env.mainnet -f ./docker-compose-lnlink.yml up --build",
@@ -7810,13 +7983,19 @@ var require_lndService = __commonJS({
         }
         if (state >= WALLET_STATE_CODE.RPC_ACTIVE && isMacaroonDecrypted && state !== WALLET_STATE_CODE.WAITING_TO_START) {
           const lightningService = getLightningService();
-          const ret = await Promise.allSettled([
-            getMainLnlinkConfig(),
-            lightningService.getInfo(),
-            lightningService.walletBalance(),
-            lightningService.listPeers({})
-          ]);
-          const [configResult, infoResult, balanceResult, peersResult] = ret;
+          const promises = [
+            getMainLnlinkConfig()
+          ];
+          if (state >= WALLET_STATE_CODE.SERVER_ACTIVE) {
+            promises.push(getCacheNodeInfo(true));
+            promises.push(lightningService.walletBalance());
+            promises.push(lightningService.listPeers({}));
+          }
+          const ret = await Promise.allSettled(promises);
+          const configResult = ret[0];
+          const infoResult = state >= WALLET_STATE_CODE.SERVER_ACTIVE ? ret[1] : { status: "rejected" };
+          const balanceResult = state >= WALLET_STATE_CODE.SERVER_ACTIVE ? ret[2] : { status: "rejected" };
+          const peersResult = state >= WALLET_STATE_CODE.SERVER_ACTIVE ? ret[3] : { status: "rejected" };
           let settings = null;
           if (configResult.status === "fulfilled") {
             settings = configResult.value?.settings;
@@ -7835,9 +8014,11 @@ var require_lndService = __commonJS({
               address: peer.address
             };
           });
-          logger2.info(
-            `LND lndService combineNodeInfoAsync peer:${peers.map((item) => item.pub_key)}`
-          );
+          if (state >= WALLET_STATE_CODE.SERVER_ACTIVE) {
+            logger2.info(
+              `LND lndService combineNodeInfoAsync peer:${peers.map((item) => item.pub_key)}`
+            );
+          }
           const errors = ret?.filter((p) => p.status === "rejected")?.map((p) => p.reason);
           if (errors && errors.length > 0) {
             logger2.error(
@@ -8579,7 +8760,11 @@ var require_api = __commonJS({
             socket.setTimeout(TIMEOUT);
             socket.once("connect", () => {
               socket.destroy();
-              resolve({ host, port, reachable: true });
+              resolve({
+                host,
+                port,
+                reachable: true
+              });
             });
             socket.once("timeout", () => {
               socket.destroy();
@@ -8596,10 +8781,26 @@ var require_api = __commonJS({
         __name(tryConnect2, "tryConnect");
         const net = require("node:net");
         const TOR_DIR_AUTHORITIES = [
-          { host: "128.31.0.34", port: 9131, name: "moria1" },
-          { host: "193.23.244.244", port: 443, name: "dannenberg" },
-          { host: "199.58.81.140", port: 80, name: "Faravahar" },
-          { host: "86.59.21.38", port: 443, name: "gabelmoo" }
+          {
+            host: "128.31.0.34",
+            port: 9131,
+            name: "moria1"
+          },
+          {
+            host: "193.23.244.244",
+            port: 443,
+            name: "dannenberg"
+          },
+          {
+            host: "199.58.81.140",
+            port: 80,
+            name: "Faravahar"
+          },
+          {
+            host: "86.59.21.38",
+            port: 443,
+            name: "gabelmoo"
+          }
         ];
         const TIMEOUT = 5e3;
         let reachable = false;
@@ -9470,10 +9671,20 @@ var require_tapdService = __commonJS({
       const decodedInvoice = decode(payment_request);
       const routingInfo = decodedInvoice.tags.find((tag) => tag.tagName === "routing_info");
       if (routingInfo && routingInfo.data && routingInfo.data.length > 0) {
-        const lastHop = routingInfo.data[routingInfo.data.length - 1];
-        if (lastHop.pubkey) {
-          paymentRequest.last_hop_pubkey = Buffer2.from(lastHop.pubkey, "hex");
-        }
+        const route_hints = routingInfo.data.map((hop) => {
+          return {
+            hop_hints: [
+              {
+                node_id: hop.pubkey,
+                chan_id: BigInt(`0x${hop.short_channel_id}`).toString(),
+                fee_base_msat: hop.fee_base_msat,
+                fee_proportional_millionths: hop.fee_proportional_millionths,
+                cltv_expiry_delta: hop.cltv_expiry_delta
+              }
+            ]
+          };
+        });
+        paymentRequest.route_hints = route_hints;
       }
       const sendParams = {
         asset_amount,
@@ -9682,7 +9893,7 @@ var require_tapdService = __commonJS({
       if (!retIsConnectPeer) {
         throw new Error("Peer not connected");
       }
-      const invoice = await tapChannelService.addInvoice({
+      const createInvoiceArgs = {
         asset_amount,
         asset_id: Buffer2.from(asset_id, "hex"),
         peer_pubkey: Buffer2.from(remotePubkey, "hex"),
@@ -9691,7 +9902,8 @@ var require_tapdService = __commonJS({
           expiry,
           description_hash: description_hash ? Buffer2.from(description_hash, "hex") : void 0
         }
-      });
+      };
+      const invoice = await tapChannelService.addInvoice(createInvoiceArgs);
       const payment_req = invoice?.invoice_result?.payment_request;
       if (payment_req) {
         await sleep(500);
@@ -9845,7 +10057,7 @@ var require_constants2 = __commonJS({
       SOCIAL_ID_MISMATCH: "Social id don't match",
       METHOD_NOT_SUPPORTED: "Method not supported"
     };
-    var PRIVILEGED_METHODS = ["make_invoice", "pay_invoice"];
+    var PRIVILEGED_METHODS = ["make_invoice", "pay_invoice", "create_hodl_invoice"];
     var FLASH_ACCOUNT_METHODS = [
       "make_invoice",
       "pay_invoice",
@@ -11346,8 +11558,9 @@ var require_nwcProxy = __commonJS({
         }
       } else {
         const filterChannelList = channelList.filter((item) => {
-          const itemAsset = item?.custom_channel_data?.assets?.[0];
-          return item.commitment_type.includes("TAPROOT") && item.active === true && itemAsset?.asset_utxo?.asset_genesis?.asset_id === assetId;
+          const asset_genesis = item?.custom_channel_data?.assets?.[0]?.asset_utxo?.asset_genesis || item?.custom_channel_data?.funding_assets?.[0]?.asset_genesis;
+          const custom_channel_asset_id = asset_genesis?.asset_id;
+          return item.commitment_type.includes("TAPROOT") && item.active === true && custom_channel_asset_id === assetId;
         });
         if (filterChannelList.length > 0) {
           return filterChannelList.sort((a, b) => {
@@ -11480,9 +11693,15 @@ var require_nwcProxy = __commonJS({
             }
             const create_at = Math.floor(Date.now() / 1e3);
             const expire_at = create_at + (expiry ?? 5 * 60);
+            const chan_id = await getBestOutgoingChainId(
+              asset_id
+            ).catch(() => {
+              return false;
+            });
             const invoice = await addInvoice({
               asset_amount: amount,
               asset_id,
+              chan_id,
               description,
               description_hash,
               expiry,
@@ -11619,7 +11838,9 @@ var require_nwcProxy = __commonJS({
                 result: {
                   preimage: payment?.payment_result?.payment_preimage,
                   payment_hash: payment?.payment_result?.payment_hash,
-                  asset_id: lnlinkUser.asset_id
+                  asset_id: lnlinkUser.asset_id,
+                  status: payment?.payment_result?.status,
+                  failure_reason: payment?.payment_result?.failure_reason
                 }
               });
             }
@@ -11795,7 +12016,7 @@ var require_nwcProxy = __commonJS({
                 user_npub: lnlinkUser.npub,
                 node_type: NODE_TYPE.LITD,
                 transaction_kind: TRANSACTION_KIND.LIGHTNING,
-                asset_id
+                asset_id: lnlinkUser?.asset_id || asset_id
               });
               total = allTotal;
               return allList.map((item) => ({
@@ -12072,7 +12293,7 @@ var require_info = __commonJS({
           ] = await Promise.allSettled([
             rgbClient.node.getNodeInfo(),
             rgbClient.onchain.getBtcBalance({
-              skip_sync: true
+              skip_sync: false
               // Skip sync for faster response
             }),
             rgbClient.lightning.listPeers({})
@@ -12214,6 +12435,7 @@ var require_lightning = __commonJS({
       push_msat,
       asset_amount,
       asset_id,
+      push_asset_amount = 0,
       isPublic = true,
       with_anchors = true,
       fee_base_msat = 1e3,
@@ -12226,12 +12448,11 @@ var require_lightning = __commonJS({
         host,
         capacity_sat,
         push_msat,
-        asset_amount,
-        asset_id,
         public: isPublic,
         with_anchors,
         fee_base_msat: Number(fee_base_msat),
-        fee_proportional_millionths
+        fee_proportional_millionths,
+        ...asset_id ? { asset_id, asset_amount, push_asset_amount } : {}
       };
       const { is_connected, peer } = await isConnectPeer({
         pubkey
@@ -12942,6 +13163,190 @@ var require_rgb = __commonJS({
   }
 });
 
+// business/service/rgb/exchange.js
+var require_exchange = __commonJS({
+  "business/service/rgb/exchange.js"(exports2, module2) {
+    var { checkObjectArgs } = require_common();
+    var { getConfigValue } = require_getConfig();
+    var {
+      createExchangeOrder,
+      getExchangeOrderByPaymentHash,
+      getExchangeOrderById,
+      getExchangeOrders,
+      updateExchangeOrder
+    } = require_dbService();
+    var Logger = require_linkLogger();
+    var getRgbClient = require_client4();
+    var { decodeLnInvoice, listChannels } = require_lightning();
+    var EXCHANGE_ORDER_STATUS = {
+      CREATED: "created",
+      RGB_HODL_ISSUED: "rgb_hodl_issued",
+      RGB_PAID: "rgb_paid",
+      BTC_SENDING: "btc_sending",
+      BTC_SENT: "btc_sent",
+      COMPLETED: "completed",
+      FAILED: "failed"
+    };
+    var HODL_BUFFER_SEC = 7200;
+    async function createHodlInvoice({
+      btc_invoice,
+      asset_id,
+      asset_amount
+    }) {
+      const logger2 = new Logger("rgb-exchange");
+      checkObjectArgs({
+        btc_invoice,
+        asset_id,
+        asset_amount
+      }, ["btc_invoice", "asset_id", "asset_amount"]);
+      const parsedAssetAmount = Number(asset_amount);
+      if (!Number.isFinite(parsedAssetAmount) || parsedAssetAmount <= 0 || !Number.isInteger(parsedAssetAmount)) {
+        throw new Error(`asset_amount must be a positive integer, got: ${asset_amount}`);
+      }
+      const decoded = await decodeLnInvoice({ invoice: btc_invoice });
+      const {
+        payment_hash,
+        amt_msat,
+        timestamp,
+        expiry_sec: btc_expiry_sec
+      } = decoded;
+      if (!payment_hash) {
+        throw new Error("Failed to extract payment_hash from BTC invoice");
+      }
+      if (!amt_msat) {
+        throw new Error("BTC invoice has no amount");
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      const btcExpireAt = Number(timestamp) + Number(btc_expiry_sec);
+      const remaining = btcExpireAt - now;
+      if (remaining <= HODL_BUFFER_SEC) {
+        throw new Error(`BTC invoice expires too soon (remaining: ${remaining}s, required > ${HODL_BUFFER_SEC}s)`);
+      }
+      const hodl_expiry_sec = remaining - HODL_BUFFER_SEC;
+      const { channels = [] } = await listChannels();
+      const btcOutbound = channels.filter((ch) => !ch.asset_id && (ch.is_usable !== false && ch.ready !== false)).reduce((sum, ch) => {
+        const balance = Number(ch.outbound_balance_msat || ch.local_balance_msat || 0);
+        return sum + balance;
+      }, 0);
+      if (btcOutbound === 0) {
+        logger2.warn(`BTC outbound balance is 0 \u2014 verify channel field names. Sample channel: ${JSON.stringify(channels[0] || {})}`);
+      }
+      if (btcOutbound < Number(amt_msat)) {
+        throw new Error(`Insufficient BTC outbound liquidity (available: ${btcOutbound} msat, required: ${amt_msat} msat)`);
+      }
+      const existing = await getExchangeOrderByPaymentHash(payment_hash);
+      if (existing) {
+        throw new Error(`Exchange order already exists for payment_hash: ${payment_hash}`);
+      }
+      const RGB_MIN_AMT_MSAT = 3 * 1e3 * 1e3;
+      const rgbClient = getRgbClient();
+      const invoiceResult = await rgbClient.lightning.createHodlInvoice({
+        payment_hash,
+        amt_msat: RGB_MIN_AMT_MSAT,
+        expiry_sec: hodl_expiry_sec,
+        asset_id,
+        asset_amount: parsedAssetAmount
+      });
+      const htlc_expiry_at = now + hodl_expiry_sec;
+      const order = await createExchangeOrder({
+        payment_hash,
+        btc_invoice,
+        btc_amount: String(amt_msat),
+        rgb_invoice: invoiceResult.invoice,
+        asset_id,
+        asset_amount: String(asset_amount),
+        status: EXCHANGE_ORDER_STATUS.RGB_HODL_ISSUED,
+        htlc_expiry_at,
+        created_at: now,
+        updated_at: now
+      });
+      logger2.info(`Exchange order created: id=${order.id}, payment_hash=${payment_hash}`);
+      return {
+        invoice: invoiceResult.invoice,
+        payment_hash,
+        expiry_sec: hodl_expiry_sec,
+        exchange_order_id: order.id,
+        btc_amount: String(amt_msat)
+      };
+    }
+    __name(createHodlInvoice, "createHodlInvoice");
+    var BTC_ASSET_ID = "0000000000000000000000000000000000000000000000000000000000000000";
+    async function getExchangeRate({ asset_id }) {
+      const logger2 = new Logger("rgb-exchange");
+      checkObjectArgs({ asset_id }, ["asset_id"]);
+      const priceServerUrl = getConfigValue("LINK_RGB_PRICE_SERVER_URL");
+      if (!priceServerUrl) {
+        throw new Error("Price server URL not configured (LINK_RGB_PRICE_SERVER_URL)");
+      }
+      if (!priceServerUrl.startsWith("http://") && !priceServerUrl.startsWith("https://")) {
+        throw new Error(`Invalid price server URL scheme: ${priceServerUrl}`);
+      }
+      const baseUrl = priceServerUrl.replace(/\/$/, "");
+      const url = `${baseUrl}/price/getOne?transaction_type=0&subjectAssetId=${encodeURIComponent(asset_id)}&paymentAssetId=${BTC_ASSET_ID}`;
+      const res = await fetch(url);
+      if (!res.ok) {
+        throw new Error(`Price oracle error: ${res.status} ${res.statusText}`);
+      }
+      const body = await res.json();
+      if (!body.ok || !body.ok.assetRates) {
+        throw new Error(`Price oracle returned error: ${JSON.stringify(body)}`);
+      }
+      const { assetRates } = body.ok;
+      logger2.info(`Exchange rate fetched for asset ${asset_id}: coefficient=${assetRates.subjectAssetRate?.coefficient}, scale=${assetRates.subjectAssetRate?.scale}`);
+      return { assetRates };
+    }
+    __name(getExchangeRate, "getExchangeRate");
+    async function listExchangeOrders({
+      status,
+      page = 1,
+      page_size = 20
+    } = {}) {
+      const validStatuses = Object.values(EXCHANGE_ORDER_STATUS);
+      if (status && !validStatuses.includes(status)) {
+        throw new Error(`Invalid status: ${status}. Valid values: ${validStatuses.join(", ")}`);
+      }
+      const safePage = Math.max(1, parseInt(page) || 1);
+      const safePageSize = Math.min(100, Math.max(1, parseInt(page_size) || 20));
+      const { list, total } = await getExchangeOrders({
+        status,
+        page: safePage,
+        page_size: safePageSize
+      });
+      return {
+        orders: list.map((order) => ({
+          id: order.id,
+          payment_hash: order.payment_hash,
+          btc_amount: order.btc_amount,
+          asset_id: order.asset_id,
+          asset_amount: order.asset_amount,
+          status: order.status,
+          error_message: order.error_message,
+          created_at: order.created_at,
+          updated_at: order.updated_at
+        })),
+        total
+      };
+    }
+    __name(listExchangeOrders, "listExchangeOrders");
+    async function getExchangeOrder({ order_id }) {
+      checkObjectArgs({ order_id }, ["order_id"]);
+      const order = await getExchangeOrderById(Number(order_id));
+      if (!order) {
+        throw new Error(`Exchange order not found: ${order_id}`);
+      }
+      return order;
+    }
+    __name(getExchangeOrder, "getExchangeOrder");
+    module2.exports = {
+      EXCHANGE_ORDER_STATUS,
+      createHodlInvoice,
+      getExchangeRate,
+      listExchangeOrders,
+      getExchangeOrder
+    };
+  }
+});
+
 // business/service/proxy/rgbProxy.js
 var require_rgbProxy = __commonJS({
   "business/service/proxy/rgbProxy.js"(exports2, module2) {
@@ -12976,6 +13381,12 @@ var require_rgbProxy = __commonJS({
       restoreNode,
       getRGBAssetsList
     } = require_rgb();
+    var {
+      createHodlInvoice,
+      getExchangeRate,
+      listExchangeOrders,
+      getExchangeOrder
+    } = require_exchange();
     function rgbProxy() {
       return {
         // ---node manager
@@ -13165,6 +13576,35 @@ var require_rgbProxy = __commonJS({
             readonly: true
           };
         }, "decode_ln_invoice"),
+        // ---exchange
+        create_hodl_invoice: /* @__PURE__ */ __name(async () => {
+          return {
+            method: createHodlInvoice,
+            argNames: ["btc_invoice", "asset_id", "asset_amount"],
+            readonly: false
+          };
+        }, "create_hodl_invoice"),
+        get_exchange_rate: /* @__PURE__ */ __name(async () => {
+          return {
+            method: getExchangeRate,
+            argNames: ["asset_id"],
+            readonly: true
+          };
+        }, "get_exchange_rate"),
+        list_exchange_orders: /* @__PURE__ */ __name(async () => {
+          return {
+            method: listExchangeOrders,
+            argNames: ["status", "page", "page_size"],
+            readonly: true
+          };
+        }, "list_exchange_orders"),
+        get_exchange_order: /* @__PURE__ */ __name(async () => {
+          return {
+            method: getExchangeOrder,
+            argNames: ["order_id"],
+            readonly: true
+          };
+        }, "get_exchange_order"),
         backup_node: /* @__PURE__ */ __name(async () => {
           return {
             method: backupNode,
@@ -14844,8 +15284,8 @@ var require_mempool = __commonJS({
       const { LINK_NETWORK } = getConfig2();
       if ((LINK_NETWORK || "").toLowerCase() === "regtest") {
         return {
-          apiBase: "http://34.84.66.29:8889/api",
-          pageBase: "http://34.84.66.29:8889/zh"
+          apiBase: "http://34.84.69.164:8889/api",
+          pageBase: "http://34.84.69.164:8889/zh"
         };
       }
       return {
@@ -15740,6 +16180,321 @@ var require_pollBtcTransfers2 = __commonJS({
   }
 });
 
+// business/job/rgb/pollExchangeOrders.js
+var require_pollExchangeOrders = __commonJS({
+  "business/job/rgb/pollExchangeOrders.js"(exports2, module2) {
+    var {
+      getExchangeOrdersByStatusIn,
+      getExchangeOrderById,
+      updateExchangeOrderWithExpectedStatus
+    } = require_dbService();
+    var getRgbClient = require_client4();
+    var { EXCHANGE_ORDER_STATUS } = require_exchange();
+    var { listPayments, listChannels } = require_lightning();
+    var Logger = require_linkLogger();
+    var POLL_STALE_MS = 6e4;
+    var pollingStartedAt = 0;
+    async function pollExchangeOrders() {
+      const now = Date.now();
+      if (pollingStartedAt > 0) {
+        if (now - pollingStartedAt < POLL_STALE_MS) return;
+        const logger2 = new Logger("poll-exchange-orders");
+        logger2.warn(`Previous poll stuck for ${now - pollingStartedAt}ms, forcing re-entry`);
+      }
+      pollingStartedAt = now;
+      try {
+        const activeOrders = await getExchangeOrdersByStatusIn([
+          EXCHANGE_ORDER_STATUS.RGB_HODL_ISSUED,
+          EXCHANGE_ORDER_STATUS.RGB_PAID,
+          EXCHANGE_ORDER_STATUS.BTC_SENDING,
+          EXCHANGE_ORDER_STATUS.BTC_SENT
+        ]);
+        if (!activeOrders || activeOrders.length === 0) {
+          return;
+        }
+        const logger2 = new Logger("poll-exchange-orders");
+        logger2.info(`Polling ${activeOrders.length} active exchange orders`);
+        let payments = [];
+        try {
+          const paymentsResult = await listPayments();
+          payments = paymentsResult && paymentsResult.payments ? paymentsResult.payments : [];
+        } catch (error) {
+          logger2.warn(`Failed to fetch listPayments, detection skipped: ${error.message}`);
+        }
+        const rgbClient = getRgbClient();
+        for (const order of activeOrders) {
+          try {
+            await processOrder(order, payments, rgbClient, logger2);
+          } catch (error) {
+            logger2.error(`Error processing exchange order ${order.id}: ${error.message}`);
+          }
+        }
+      } finally {
+        pollingStartedAt = 0;
+      }
+    }
+    __name(pollExchangeOrders, "pollExchangeOrders");
+    var MAX_BTC_RETRIES = 10;
+    async function processOrder(order, payments, rgbClient, logger2) {
+      const now = Math.floor(Date.now() / 1e3);
+      switch (order.status) {
+        case EXCHANGE_ORDER_STATUS.RGB_HODL_ISSUED: {
+          if (order.htlc_expiry_at && now > order.htlc_expiry_at) {
+            const updated = await updateExchangeOrderWithExpectedStatus(
+              order.id,
+              EXCHANGE_ORDER_STATUS.RGB_HODL_ISSUED,
+              { status: EXCHANGE_ORDER_STATUS.FAILED, error_message: "HODL invoice expired, A never paid" }
+            );
+            if (updated) logger2.info(`Order ${order.id}: expired in rgb_hodl_issued, marked failed`);
+            break;
+          }
+          const hodlPending = payments.find(
+            (p) => p.payment_hash === order.payment_hash && p.inbound === true && p.status === "Pending" && p.asset_id
+          );
+          if (hodlPending) {
+            const updated = await updateExchangeOrderWithExpectedStatus(
+              order.id,
+              EXCHANGE_ORDER_STATUS.RGB_HODL_ISSUED,
+              { status: EXCHANGE_ORDER_STATUS.RGB_PAID, error_message: null }
+            );
+            if (updated) {
+              logger2.info(`Order ${order.id}: RGB HODL payment received (Pending), updated to rgb_paid`);
+              const freshOrder = await getExchangeOrderById(order.id);
+              if (freshOrder) await sendBtcPayment(freshOrder, payments, rgbClient, logger2);
+            } else {
+              logger2.warn(`Order ${order.id}: optimistic lock failed on rgb_hodl_issued -> rgb_paid`);
+            }
+          }
+          break;
+        }
+        case EXCHANGE_ORDER_STATUS.RGB_PAID:
+        case EXCHANGE_ORDER_STATUS.BTC_SENDING: {
+          if (order.status === EXCHANGE_ORDER_STATUS.BTC_SENDING) {
+            const alreadySent = payments.find(
+              (p) => p.payment_hash === order.payment_hash && p.inbound === false && p.status === "Succeeded"
+            );
+            if (alreadySent) {
+              const preimage = alreadySent.preimage || null;
+              await updateExchangeOrderWithExpectedStatus(
+                order.id,
+                EXCHANGE_ORDER_STATUS.BTC_SENDING,
+                {
+                  status: EXCHANGE_ORDER_STATUS.BTC_SENT,
+                  preimage,
+                  btc_retry_count: 0,
+                  error_message: null
+                }
+              );
+              logger2.info(`Order ${order.id}: BTC payment already succeeded (crash recovery), advanced to btc_sent`);
+              break;
+            }
+          }
+          await sendBtcPayment(order, payments, rgbClient, logger2);
+          break;
+        }
+        case EXCHANGE_ORDER_STATUS.BTC_SENT: {
+          const btcSucceeded = payments.find(
+            (p) => p.payment_hash === order.payment_hash && p.inbound === false && p.status === "Succeeded"
+          );
+          if (!btcSucceeded) {
+            const btcFailed = payments.find(
+              (p) => p.payment_hash === order.payment_hash && p.inbound === false && p.status === "Failed"
+            );
+            if (btcFailed) {
+              const updated = await updateExchangeOrderWithExpectedStatus(
+                order.id,
+                EXCHANGE_ORDER_STATUS.BTC_SENT,
+                {
+                  status: EXCHANGE_ORDER_STATUS.RGB_PAID,
+                  btc_retry_count: (order.btc_retry_count || 0) + 1,
+                  error_message: "BTC payment failed asynchronously, will retry"
+                }
+              );
+              if (updated) logger2.warn(`Order ${order.id}: BTC payment failed async (retry ${(order.btc_retry_count || 0) + 1}/${MAX_BTC_RETRIES}), reverting to rgb_paid`);
+              break;
+            }
+          }
+          const hodlSucceeded = payments.find(
+            (p) => p.payment_hash === order.payment_hash && p.inbound === true && p.status === "Succeeded" && p.asset_id
+          );
+          if (hodlSucceeded) {
+            const updated = await updateExchangeOrderWithExpectedStatus(
+              order.id,
+              EXCHANGE_ORDER_STATUS.BTC_SENT,
+              {
+                status: EXCHANGE_ORDER_STATUS.COMPLETED,
+                btc_retry_count: 0,
+                error_message: null
+              }
+            );
+            if (updated) logger2.info(`Order ${order.id}: RGB auto-claimed (Succeeded), marked completed`);
+          } else {
+            if (order.htlc_expiry_at && now > order.htlc_expiry_at) {
+              const updated = await updateExchangeOrderWithExpectedStatus(
+                order.id,
+                EXCHANGE_ORDER_STATUS.BTC_SENT,
+                { status: EXCHANGE_ORDER_STATUS.FAILED, error_message: "HTLC expired: BTC sent but RGB auto-claim never fired (node event missed)" }
+              );
+              if (updated) logger2.error(`[LOSS] Order ${order.id}: HTLC expired in btc_sent, RGB not claimed. payment_hash=${order.payment_hash}`);
+            } else if (order.htlc_expiry_at && now > order.htlc_expiry_at - 600) {
+              logger2.error(`[ALERT] Order ${order.id} approaching HTLC expiry. payment_hash=${order.payment_hash}, preimage=${order.preimage}, htlc_expiry_at=${order.htlc_expiry_at}`);
+            }
+          }
+          break;
+        }
+      }
+    }
+    __name(processOrder, "processOrder");
+    async function sendBtcPayment(order, payments, rgbClient, logger2) {
+      const now = Math.floor(Date.now() / 1e3);
+      if (order.htlc_expiry_at && now > order.htlc_expiry_at - 300) {
+        await updateExchangeOrderWithExpectedStatus(
+          order.id,
+          order.status,
+          { status: EXCHANGE_ORDER_STATUS.FAILED, error_message: "HTLC expiry too close, aborting BTC payment" }
+        );
+        logger2.error(`Order ${order.id}: HTLC expiry imminent (${order.htlc_expiry_at - now}s left), marking failed`);
+        return;
+      }
+      const retries = order.btc_retry_count || 0;
+      if (retries >= MAX_BTC_RETRIES) {
+        await updateExchangeOrderWithExpectedStatus(
+          order.id,
+          order.status,
+          { status: EXCHANGE_ORDER_STATUS.FAILED, error_message: `BTC payment failed after ${MAX_BTC_RETRIES} retries` }
+        );
+        logger2.error(`Order ${order.id}: exceeded max BTC retries (${MAX_BTC_RETRIES})`);
+        return;
+      }
+      if (!order.btc_invoice) {
+        await updateExchangeOrderWithExpectedStatus(order.id, order.status, { status: EXCHANGE_ORDER_STATUS.FAILED, error_message: "Missing btc_invoice" });
+        logger2.error(`Order ${order.id}: btc_invoice is null/empty, marking failed`);
+        return;
+      }
+      try {
+        const { channels = [] } = await listChannels();
+        const btcOutbound = channels.filter((ch) => !ch.asset_id && (ch.is_usable !== false && ch.ready !== false)).reduce((sum, ch) => sum + Number(ch.outbound_balance_msat || ch.local_balance_msat || 0), 0);
+        const requiredMsat = Number(order.btc_amount);
+        if (!Number.isFinite(requiredMsat) || requiredMsat <= 0) {
+          await updateExchangeOrderWithExpectedStatus(order.id, order.status, { status: EXCHANGE_ORDER_STATUS.FAILED, error_message: `Invalid btc_amount: ${order.btc_amount}` });
+          logger2.error(`Order ${order.id}: invalid btc_amount "${order.btc_amount}", marking failed`);
+          return;
+        }
+        if (btcOutbound < requiredMsat) {
+          logger2.warn(`Order ${order.id}: insufficient BTC outbound (available: ${btcOutbound}, required: ${requiredMsat}), skipping this tick`);
+          return;
+        }
+      } catch (error) {
+        logger2.warn(`Order ${order.id}: failed to check BTC liquidity, proceeding anyway: ${error.message}`);
+      }
+      try {
+        const lockAcquired = await updateExchangeOrderWithExpectedStatus(
+          order.id,
+          order.status,
+          { status: EXCHANGE_ORDER_STATUS.BTC_SENDING }
+        );
+        if (!lockAcquired) {
+          logger2.warn(`Order ${order.id}: optimistic lock failed on ${order.status} -> btc_sending, skipping`);
+          return;
+        }
+        const result = await rgbClient.lightning.payInvoice({ invoice: order.btc_invoice });
+        const resultError = result && (result.error || result.failure_reason);
+        if (resultError) {
+          const errMsg = typeof resultError === "string" ? resultError : JSON.stringify(resultError);
+          const isPermanent = /route.*not.*found|no.?route|expired/i.test(errMsg);
+          if (isPermanent) {
+            await updateExchangeOrderWithExpectedStatus(
+              order.id,
+              EXCHANGE_ORDER_STATUS.BTC_SENDING,
+              { status: EXCHANGE_ORDER_STATUS.FAILED, error_message: errMsg }
+            );
+            logger2.error(`Order ${order.id}: BTC payment permanently failed (from response): ${errMsg}`);
+          } else {
+            await updateExchangeOrderWithExpectedStatus(
+              order.id,
+              EXCHANGE_ORDER_STATUS.BTC_SENDING,
+              {
+                status: EXCHANGE_ORDER_STATUS.RGB_PAID,
+                btc_retry_count: retries + 1,
+                error_message: errMsg
+              }
+            );
+            logger2.warn(`Order ${order.id}: BTC payment failed (from response, retry ${retries + 1}/${MAX_BTC_RETRIES}): ${errMsg}`);
+          }
+          return;
+        }
+        const preimage = result && result.preimage ? result.preimage : null;
+        await updateExchangeOrderWithExpectedStatus(
+          order.id,
+          EXCHANGE_ORDER_STATUS.BTC_SENDING,
+          {
+            status: EXCHANGE_ORDER_STATUS.BTC_SENT,
+            preimage,
+            // Keep btc_retry_count — don't reset until completed.
+            error_message: null
+          }
+        );
+        if (!preimage) {
+          logger2.warn(`Order ${order.id}: BTC payInvoice returned without preimage (retry ${retries}/${MAX_BTC_RETRIES}), payment may fail async`);
+        } else {
+          logger2.info(`Order ${order.id}: BTC payment sent, preimage=${preimage}`);
+        }
+      } catch (error) {
+        const isTimeout = /timeout|ETIMEDOUT|ECONNRESET|socket hang up/i.test(error.message);
+        if (isTimeout) {
+          await updateExchangeOrderWithExpectedStatus(
+            order.id,
+            EXCHANGE_ORDER_STATUS.BTC_SENDING,
+            { error_message: `Ambiguous: ${error.message} \u2014 will re-check next tick` }
+          );
+          logger2.warn(`Order ${order.id}: BTC sendpayment ambiguous timeout, keeping btc_sending for re-check`);
+          return;
+        }
+        const isAlreadyPaid = /already paid/i.test(error.message);
+        if (isAlreadyPaid) {
+          const matchedPayment = payments.find(
+            (p) => p.payment_hash === order.payment_hash && p.inbound === false && p.status === "Succeeded"
+          );
+          await updateExchangeOrderWithExpectedStatus(
+            order.id,
+            EXCHANGE_ORDER_STATUS.BTC_SENDING,
+            {
+              status: EXCHANGE_ORDER_STATUS.BTC_SENT,
+              preimage: matchedPayment?.preimage || null,
+              btc_retry_count: 0,
+              error_message: null
+            }
+          );
+          logger2.warn(`Order ${order.id}: BTC "already paid" \u2014 treating as success, advanced to btc_sent`);
+          return;
+        }
+        const isPermanent = /expired|no route/i.test(error.message);
+        if (isPermanent) {
+          await updateExchangeOrderWithExpectedStatus(
+            order.id,
+            EXCHANGE_ORDER_STATUS.BTC_SENDING,
+            { status: EXCHANGE_ORDER_STATUS.FAILED, error_message: error.message }
+          );
+          logger2.error(`Order ${order.id}: BTC sendpayment permanently failed: ${error.message}`);
+        } else {
+          await updateExchangeOrderWithExpectedStatus(
+            order.id,
+            EXCHANGE_ORDER_STATUS.BTC_SENDING,
+            {
+              status: EXCHANGE_ORDER_STATUS.RGB_PAID,
+              btc_retry_count: retries + 1,
+              error_message: error.message
+            }
+          );
+          logger2.warn(`Order ${order.id}: BTC sendpayment transient error (retry ${retries + 1}/${MAX_BTC_RETRIES}), will retry: ${error.message}`);
+        }
+      }
+    }
+    __name(sendBtcPayment, "sendBtcPayment");
+    module2.exports = pollExchangeOrders;
+  }
+});
+
 // business/job/rgb/pollLightningTransfers.js
 var require_pollLightningTransfers = __commonJS({
   "business/job/rgb/pollLightningTransfers.js"(exports2, module2) {
@@ -16634,6 +17389,7 @@ var require_tasks = __commonJS({
     var pollInvoiceTransfers = require_pollInvoiceTransfers();
     var rgbConnectPeer = require_connectPeer2();
     var pollBtcTransfers = require_pollBtcTransfers2();
+    var pollExchangeOrders = require_pollExchangeOrders();
     var pollLightningTransfers = require_pollLightningTransfers();
     var pollRgbTransfers = require_pollRgbTransfers();
     var refreshTransfers = require_refreshTransfers();
@@ -16762,6 +17518,17 @@ var require_tasks = __commonJS({
         timeout: 3e4,
         description: "Poll RGB Lightning transfers"
       },
+      rgb_poll_exchange_orders: {
+        type: "cron",
+        schedule: "*/5 * * * * *",
+        implementation: pollExchangeOrders,
+        gate: "rgbActive",
+        priority: 1,
+        enabled: true,
+        maxRetries: 3,
+        timeout: 3e4,
+        description: "Poll RGB-BTC exchange orders and trigger BTC sendpayment on RGB receipt"
+      },
       // Event-driven tasks
       bake_tapd_macaroon: {
         type: "event",
@@ -19238,7 +20005,8 @@ var require_setting_mainnet = __commonJS({
       officialRgbPeerHost: "CHANGE_ME_MAINNET_RGB_HOST:9736",
       officialUniverseServer: "CHANGE_ME_MAINNET_UNIVERSE_HOST:10009",
       priceOracle: "grpc-oracle.lnfi.network",
-      rgbProxy: "rpc://CHANGE_ME_MAINNET_RGB_PROXY_HOST:5000/json-rpc"
+      rgbProxy: "rpc://CHANGE_ME_MAINNET_RGB_PROXY_HOST:5000/json-rpc",
+      rgbPriceServer: "https://api-oracle.lnfi.network"
     };
   }
 });
@@ -19256,17 +20024,18 @@ var require_setting_regtest = __commonJS({
       bitcoindZmqRawTx: "tcp://regtest.lnfi.network:28335",
       network: "regtest",
       nostrRelays: [
-        "wss://relay.snort.social",
-        "wss://relay01.lnfi.network"
+        "wss://relay01.lnfi.network",
+        "wss://vault.iris.to"
       ],
       officialLndPeer: "03b24a4bf911ffd26ac1d5e5f2440a3c2f6974e4cc85d2ef54e17ee6d3717433d3",
-      officialLndPeerHost: "34.84.66.29:7739",
+      officialLndPeerHost: "34.84.69.164:7739",
       officialNostrPubKey: "npub1me48869w43j30cfry9ayz9dsdl4gj54xppgk9krrv7g6hsq7psuqp3yusn",
       officialRgbPeer: "03b7153e278882e48e690acd0743305cbada86b131ab3388ccd782b45b02f064ef",
       officialRgbPeerHost: "regtest.lnfi.network:9736",
       officialUniverseServer: "regtest.lnfi.network:10009",
       priceOracle: "grpc-oracle.lnfi.network",
-      rgbProxy: "rpc://regtest.lnfi.network:5000/json-rpc"
+      rgbProxy: "rpc://regtest.lnfi.network:5000/json-rpc",
+      rgbPriceServer: "https://api-oracle.lnfi.network"
     };
   }
 });
@@ -19294,7 +20063,8 @@ var require_setting_testnet = __commonJS({
       officialRgbPeerHost: "CHANGE_ME_TESTNET_RGB_HOST:9736",
       officialUniverseServer: "CHANGE_ME_TESTNET_UNIVERSE_HOST:10009",
       priceOracle: "grpc-oracle.lnfi.network",
-      rgbProxy: "rpc://CHANGE_ME_TESTNET_RGB_PROXY_HOST:5000/json-rpc"
+      rgbProxy: "rpc://CHANGE_ME_TESTNET_RGB_PROXY_HOST:5000/json-rpc",
+      rgbPriceServer: "https://api-oracle.lnfi.network"
     };
   }
 });
@@ -19328,6 +20098,16 @@ var require_initLinkConfig = __commonJS({
             await updateMainLnlinkConfig({ node_name: LINK_NAME });
             await reloadConfig();
           }
+          const networkTemplate = LINK_NETWORK === "testnet" ? testnetSettings : LINK_NETWORK === "mainnet" ? mainnetSettings : regtestSettings;
+          const missingKeys = Object.keys(networkTemplate).filter(
+            (k) => !(k in lndConfig.settings)
+          );
+          if (missingKeys.length > 0) {
+            const patch = Object.fromEntries(missingKeys.map((k) => [k, networkTemplate[k]]));
+            await updateMainLnlinkConfig({ settings: { ...lndConfig.settings, ...patch } });
+            await reloadConfig();
+            logger2.info(`Settings patched with new keys: ${missingKeys.join(", ")}`);
+          }
           return;
         }
         let settings;