arnacon-webrtc-service 0.1.74 → 0.1.76

package/globalserviceconfig.json

@@ -77,7 +77,17 @@
       "rpc": "https://sapphire.oasis.io",
       "chainId": 23294,
       "businessNumberDbAddress": "",
-      "callerIdPoolAddress": "0x903796dc34Bb9A5eD76A41bBA6C40CfebD1f4269"
+      "callerIdPoolAddress": "0x903796dc34Bb9A5eD76A41bBA6C40CfebD1f4269",
+      "businessNumberDb": {
+        "rpc": "https://sapphire.oasis.io",
+        "chainId": 23294,
+        "address": "0xFc80534F731E3849Bc06970B0e8645d72A34f493"
+      },
+      "callerIdPool": {
+        "rpc": "https://sapphire.oasis.io",
+        "chainId": 23294,
+        "address": "0x903796dc34Bb9A5eD76A41bBA6C40CfebD1f4269"
+      }
     },
     "messageProcessorUrl": "https://europe-west3-asterisk-tts-test.cloudfunctions.net/client_msg_processor",
     "polygon": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnacon-webrtc-service",
-  "version": "0.1.74",
+  "version": "0.1.76",
   "description": "Arnacon WebRTC core runtime and service modules",
   "main": "./webRTCservice/core.js",
   "type": "commonjs",

package/webRTCservice/modules/blockchain.js

@@ -16,6 +16,8 @@ function createBlockchainApi({
     const SAPPHIRE_TESTNET_RPC = config.sapphireTestnet.rpc;
     const NFT_CALLER_ID_POOL_ADDRESS = config.sapphireTestnet.NFTCallerIdPool;
     const ROFL_LOGIC_CONFIG = config.roflLogic || {};
+    const ROFL_BUSINESS_NUMBER_DB_CONFIG = ROFL_LOGIC_CONFIG.businessNumberDb || {};
+    const ROFL_CALLER_ID_POOL_CONFIG = ROFL_LOGIC_CONFIG.callerIdPool || {};
     const ROFL_LOGIC_RPC =
         process.env.ROFL_LOGIC_RPC_URL ||
         ROFL_LOGIC_CONFIG.rpc ||
@@ -23,12 +25,36 @@ function createBlockchainApi({
         SAPPHIRE_RPC;
     const ROFL_LOGIC_CHAIN_ID =
         Number(process.env.ROFL_LOGIC_CHAIN_ID || ROFL_LOGIC_CONFIG.chainId || 0) || undefined;
+    const ROFL_BUSINESS_NUMBER_DB_RPC =
+        process.env.ROFL_LOGIC_BUSINESS_NUMBER_DB_RPC_URL ||
+        ROFL_BUSINESS_NUMBER_DB_CONFIG.rpc ||
+        ROFL_LOGIC_RPC;
+    const ROFL_BUSINESS_NUMBER_DB_CHAIN_ID =
+        Number(
+            process.env.ROFL_LOGIC_BUSINESS_NUMBER_DB_CHAIN_ID ||
+            ROFL_BUSINESS_NUMBER_DB_CONFIG.chainId ||
+            ROFL_LOGIC_CHAIN_ID ||
+            0,
+        ) || undefined;
     const ROFL_BUSINESS_NUMBER_DB_ADDRESS =
         process.env.ROFL_LOGIC_BUSINESS_NUMBER_DB_ADDRESS ||
+        ROFL_BUSINESS_NUMBER_DB_CONFIG.address ||
         ROFL_LOGIC_CONFIG.businessNumberDbAddress ||
         "";
+    const ROFL_CALLER_ID_POOL_RPC =
+        process.env.ROFL_LOGIC_CALLER_ID_POOL_RPC_URL ||
+        ROFL_CALLER_ID_POOL_CONFIG.rpc ||
+        ROFL_LOGIC_RPC;
+    const ROFL_CALLER_ID_POOL_CHAIN_ID =
+        Number(
+            process.env.ROFL_LOGIC_CALLER_ID_POOL_CHAIN_ID ||
+            ROFL_CALLER_ID_POOL_CONFIG.chainId ||
+            ROFL_LOGIC_CHAIN_ID ||
+            0,
+        ) || undefined;
     const ROFL_CALLER_ID_POOL_ADDRESS =
         process.env.ROFL_LOGIC_CALLER_ID_POOL_ADDRESS ||
+        ROFL_CALLER_ID_POOL_CONFIG.address ||
         ROFL_LOGIC_CONFIG.callerIdPoolAddress ||
         NFT_CALLER_ID_POOL_ADDRESS;
     const ROFL_PKEY = process.env.ROFL_LOGIC_PKEY || process.env.PKEY || "";
@@ -68,6 +94,8 @@ function createBlockchainApi({
     let sapphireProvider = null;
     let sapphireTestnetProvider = null;
     let roflLogicProvider = null;
+    let businessNumberDbProvider = null;
+    let callerIdPoolProvider = null;
     let businessNumberDbContract = null;
     let callerIdPoolRoflContract = null;
     let roflPoolOwnerAddress = null;
@@ -101,6 +129,34 @@ function createBlockchainApi({
         return roflLogicProvider;
     }
 
+    function getBusinessNumberDbProvider() {
+        if (!businessNumberDbProvider) {
+            if (ROFL_BUSINESS_NUMBER_DB_CHAIN_ID) {
+                businessNumberDbProvider = new ethers.providers.JsonRpcProvider(
+                    ROFL_BUSINESS_NUMBER_DB_RPC,
+                    ROFL_BUSINESS_NUMBER_DB_CHAIN_ID,
+                );
+            } else {
+                businessNumberDbProvider = new ethers.providers.JsonRpcProvider(ROFL_BUSINESS_NUMBER_DB_RPC);
+            }
+        }
+        return businessNumberDbProvider;
+    }
+
+    function getCallerIdPoolProvider() {
+        if (!callerIdPoolProvider) {
+            if (ROFL_CALLER_ID_POOL_CHAIN_ID) {
+                callerIdPoolProvider = new ethers.providers.JsonRpcProvider(
+                    ROFL_CALLER_ID_POOL_RPC,
+                    ROFL_CALLER_ID_POOL_CHAIN_ID,
+                );
+            } else {
+                callerIdPoolProvider = new ethers.providers.JsonRpcProvider(ROFL_CALLER_ID_POOL_RPC);
+            }
+        }
+        return callerIdPoolProvider;
+    }
+
     function normalizeContractAddress(value) {
         const normalized = String(value || "").trim();
         if (!normalized || normalized === "0x0000000000000000000000000000000000000000") return "";
@@ -129,7 +185,7 @@ function createBlockchainApi({
         if (!businessNumberDbContract) {
             const address = normalizeContractAddress(ROFL_BUSINESS_NUMBER_DB_ADDRESS);
             if (!address) return null;
-            businessNumberDbContract = new ethers.Contract(address, BUSINESS_NUMBER_DB_ABI, getRoflLogicProvider());
+            businessNumberDbContract = new ethers.Contract(address, BUSINESS_NUMBER_DB_ABI, getBusinessNumberDbProvider());
         }
         return businessNumberDbContract;
     }
@@ -138,7 +194,7 @@ function createBlockchainApi({
         if (!callerIdPoolRoflContract) {
             const address = normalizeContractAddress(ROFL_CALLER_ID_POOL_ADDRESS);
             if (!address) return null;
-            callerIdPoolRoflContract = new ethers.Contract(address, CALLER_ID_POOL_ROFL_ABI, getRoflLogicProvider());
+            callerIdPoolRoflContract = new ethers.Contract(address, CALLER_ID_POOL_ROFL_ABI, getCallerIdPoolProvider());
         }
         return callerIdPoolRoflContract;
     }
@@ -398,7 +454,9 @@ function createBlockchainApi({
         if (!businessName) return null;
         try {
             const phoneNumber = await contract.getPhoneNumber(businessName);
-            return phoneNumber && phoneNumber !== "" ? phoneNumber : null;
+            const result = phoneNumber && phoneNumber !== "" ? phoneNumber : null;
+            logger.log(`[ROFL_LOCAL] business lookup ${businessName} -> ${result || "no-match"}`);
+            return result;
         } catch (err) {
             logger.error(`[ROFL_LOCAL] find-business-number failed for ${businessName}: ${err.message}`);
             return null;
@@ -452,7 +510,11 @@ function createBlockchainApi({
         return {
             rpc: ROFL_LOGIC_RPC || null,
             chainId: ROFL_LOGIC_CHAIN_ID || null,
+            businessNumberDbRpc: ROFL_BUSINESS_NUMBER_DB_RPC || null,
+            businessNumberDbChainId: ROFL_BUSINESS_NUMBER_DB_CHAIN_ID || null,
             businessNumberDbAddress: normalizeContractAddress(ROFL_BUSINESS_NUMBER_DB_ADDRESS) || null,
+            callerIdPoolRpc: ROFL_CALLER_ID_POOL_RPC || null,
+            callerIdPoolChainId: ROFL_CALLER_ID_POOL_CHAIN_ID || null,
             callerIdPoolAddress: normalizeContractAddress(ROFL_CALLER_ID_POOL_ADDRESS) || null,
             roflAddress: getRoflAddress() || null,
         };

package/webRTCservice/modules/callRouter.js

@@ -61,11 +61,19 @@ function createCallRouter({
         }
     }
 
-    async function roflCascadingBusinessLookup(identifier) {
-        const lookups = [identifier];
+    function buildBusinessLookupKeys(identifier) {
+        const normalized = String(identifier || "").trim().toLowerCase().replace("@", "_");
+        if (!normalized) return [];
+        const lookups = [normalized];
 
-        if (identifier.includes("_")) {
-            const domain = identifier.split("_", 2)[1];
+        if (normalized.includes("_")) {
+            const [local, domain] = normalized.split("_", 2);
+            const localParts = String(local || "").split(".").filter(Boolean);
+            for (let i = 1; i < localParts.length; i++) {
+                const localSuffix = localParts.slice(i).join(".");
+                const key = `${localSuffix}_${domain}`;
+                if (localSuffix && domain && !lookups.includes(key)) lookups.push(key);
+            }
             if (!lookups.includes(domain)) lookups.push(domain);
             let parts = domain;
             while (parts.includes(".")) {
@@ -73,13 +81,20 @@ function createCallRouter({
                 if (!lookups.includes(parts)) lookups.push(parts);
             }
         } else {
-            let parts = identifier;
+            let parts = normalized;
             while (parts.includes(".")) {
                 parts = parts.substring(0, parts.lastIndexOf("."));
                 if (!lookups.includes(parts)) lookups.push(parts);
             }
         }
 
+        return lookups;
+    }
+
+    async function roflCascadingBusinessLookup(identifier) {
+        const lookups = buildBusinessLookupKeys(identifier);
+        if (lookups.length === 0) return null;
+
         logger.log(`[Route] Cascading business lookup: [${lookups.join(", ")}]`);
 
         for (const callee of lookups) {

package/webRTCservice/services/email.js

@@ -46,8 +46,7 @@ async function resolveDestination(ctx) {
         if (addr && addr !== helpers.zeroAddress) {
             return { route: "webrtc", wallet: addr, ensName: emailEns };
         }
-        const domainPart = String(parsedTo.value || "").split("@")[1] || parsedTo.value;
-        const businessNumber = await helpers.lookupBusinessNumber(domainPart);
+        const businessNumber = await helpers.lookupBusinessNumberCascade(parsedTo.value);
         if (businessNumber) return { route: "sbc", number: businessNumber };
         return { route: "reject", reason: "No ENS owner and no business mapping" };
     }
@@ -55,8 +54,15 @@ async function resolveDestination(ctx) {
     if (parsedTo.type === "raw" || parsedTo.type === "unknown") {
         const normalized = helpers.normalizePhone(parsedTo.value);
         if (looksLikeBusinessDomain(normalized)) {
-            const businessNumber = await helpers.lookupBusinessNumber(normalized);
+            const businessNumber = await helpers.lookupBusinessNumberCascade(normalized);
+            helpers.logRouteDecision?.({
+                serviceId: "email",
+                route: "business-domain-cascade",
+                target: normalized,
+                result: businessNumber || null,
+            });
             if (businessNumber) return { route: "sbc", number: businessNumber };
+            return { route: "reject", reason: `No business mapping for ${normalized}` };
         }
         const webrtcHit = await helpers.tryInternalWebrtcLookup(normalized, helpers.getAllServiceDomains());
         if (webrtcHit) return webrtcHit;

package/webRTCservice/services/phonemyemail.js

@@ -42,8 +42,15 @@ async function resolveDestination(ctx) {
     if (parsedTo.type === "raw" || parsedTo.type === "unknown") {
         const normalized = helpers.normalizePhone(parsedTo.value);
         if (looksLikeBusinessDomain(normalized)) {
-            const businessNumber = await helpers.lookupBusinessNumber(normalized);
+            const businessNumber = await helpers.lookupBusinessNumberCascade(normalized);
+            helpers.logRouteDecision?.({
+                serviceId: "phonemyemail",
+                route: "business-domain-cascade",
+                target: normalized,
+                result: businessNumber || null,
+            });
             if (businessNumber) return { route: "sbc", number: businessNumber };
+            return { route: "reject", reason: `No business mapping for ${normalized}` };
         }
         const webrtcHit = await helpers.tryInternalWebrtcLookup(normalized, helpers.getAllServiceDomains());
         if (webrtcHit) return webrtcHit;

package/webRTCservice/webRTCmanager.js

@@ -331,8 +331,14 @@ const roflLogicInfo = blockchainApi.getRoflLogicInfo();
 console.log(
     `[ROFL] mode=${USE_LOCAL_ROFL_LOGIC ? "local_rofl_logic" : "remote_http"} ` +
         `baseUrl=${ROFL_BASE_URL || "n/a"} rpc=${roflLogicInfo.rpc || "n/a"} ` +
-        `chainId=${roflLogicInfo.chainId || "n/a"} businessDb=${roflLogicInfo.businessNumberDbAddress || "n/a"} ` +
-        `callerIdPool=${roflLogicInfo.callerIdPoolAddress || "n/a"} roflAddress=${roflLogicInfo.roflAddress || "n/a"}`,
+        `chainId=${roflLogicInfo.chainId || "n/a"} ` +
+        `businessDb=${roflLogicInfo.businessNumberDbAddress || "n/a"} ` +
+        `businessDbRpc=${roflLogicInfo.businessNumberDbRpc || "n/a"} ` +
+        `businessDbChainId=${roflLogicInfo.businessNumberDbChainId || "n/a"} ` +
+        `callerIdPool=${roflLogicInfo.callerIdPoolAddress || "n/a"} ` +
+        `callerIdPoolRpc=${roflLogicInfo.callerIdPoolRpc || "n/a"} ` +
+        `callerIdPoolChainId=${roflLogicInfo.callerIdPoolChainId || "n/a"} ` +
+        `roflAddress=${roflLogicInfo.roflAddress || "n/a"}`,
 );
 const notificationApi = createNotificationApi({
     blockchainApi,
@@ -535,6 +541,7 @@ function getServiceHelpers(serviceRuntime) {
         lookupEnsTextRecord: (...args) => blockchainApi.resolveEnsTextRecord(...args),
         lookupNftOwnedNumber: (...args) => blockchainApi.nftGetOwnedNumber(...args),
         lookupBusinessNumber: (...args) => callRouterApi.roflFindBusinessNumber(...args),
+        lookupBusinessNumberCascade: (...args) => callRouterApi.roflCascadingBusinessLookup(...args),
         assignPoolFromNumber: (...args) => callRouterApi.roflAssignFromNumber(...args),
         getProviderForDomain: (domain) => {
             if (!domain) return null;