arnacon-webrtc-service 0.1.4 → 0.1.6

package/globalserviceconfig.json

@@ -1,6 +1,13 @@
 {
   "development": {
     "roflBaseUrl": "https://p8000.m1485.test-proxy-b.rofl.app",
+    "useLocalRoflLogic": true,
+    "roflLogic": {
+      "rpc": "https://testnet.sapphire.oasis.io",
+      "chainId": 23295,
+      "businessNumberDbAddress": "0x684F9797de793E603368A8Fe1Fe663aAeb327621",
+      "callerIdPoolAddress": "0xFB3DD146F1aFfbA661533Ec49298D01f20104CF6"
+    },
     "messageProcessorUrl": "https://europe-west3-asterisk-tts-test.cloudfunctions.net/client_msg_processor",
     "polygon": {
       "rpc": "https://polygon-bor-rpc.publicnode.com",
@@ -65,6 +72,13 @@
   },
   "production": {
     "roflBaseUrl": "https://p8000.m206.opf-mainnet-rofl-35.rofl.app",
+    "useLocalRoflLogic": true,
+    "roflLogic": {
+      "rpc": "https://sapphire.oasis.io",
+      "chainId": 23294,
+      "businessNumberDbAddress": "",
+      "callerIdPoolAddress": "0x903796dc34Bb9A5eD76A41bBA6C40CfebD1f4269"
+    },
     "messageProcessorUrl": "https://europe-west3-asterisk-tts-test.cloudfunctions.net/client_msg_processor",
     "polygon": {
       "rpc": "https://polygon-bor-rpc.publicnode.com",

package/package.json

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

package/webRTCservice/modules/blockchain.js

@@ -15,6 +15,23 @@ function createBlockchainApi({
     const SAPPHIRE_RPC = config.sapphire.rpc;
     const SAPPHIRE_TESTNET_RPC = config.sapphireTestnet.rpc;
     const NFT_CALLER_ID_POOL_ADDRESS = config.sapphireTestnet.NFTCallerIdPool;
+    const ROFL_LOGIC_CONFIG = config.roflLogic || {};
+    const ROFL_LOGIC_RPC =
+        process.env.ROFL_LOGIC_RPC_URL ||
+        ROFL_LOGIC_CONFIG.rpc ||
+        SAPPHIRE_TESTNET_RPC ||
+        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_ADDRESS =
+        process.env.ROFL_LOGIC_BUSINESS_NUMBER_DB_ADDRESS ||
+        ROFL_LOGIC_CONFIG.businessNumberDbAddress ||
+        "";
+    const ROFL_CALLER_ID_POOL_ADDRESS =
+        process.env.ROFL_LOGIC_CALLER_ID_POOL_ADDRESS ||
+        ROFL_LOGIC_CONFIG.callerIdPoolAddress ||
+        NFT_CALLER_ID_POOL_ADDRESS;
+    const ROFL_PKEY = process.env.ROFL_LOGIC_PKEY || process.env.PKEY || "";
 
     const ENS_REGISTRY_ABI = [
         "function owner(bytes32 node) view returns (address)",
@@ -36,10 +53,27 @@ function createBlockchainApi({
         "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)",
         "function getCallerIdByTokenId(uint256 tokenId) view returns (string phoneNumber, string metadata, address owner)",
     ];
+    const BUSINESS_NUMBER_DB_ABI = [
+        "function getPhoneNumber(string identifier) view returns (string)",
+    ];
+    const CALLER_ID_POOL_ROFL_ABI = [
+        "function findNextOwnedCallerId(uint256 startIndex, address expectedOwner, uint256 maxAttempts) view returns (string phoneNumber, uint256 foundIndex, bool found)",
+        "function getPoolSize() view returns (uint256)",
+        "function admin() view returns (address)",
+        "function getTokens() view returns (uint256[])",
+        "function getCallerIdByTokenId(uint256 tokenId) view returns (string phoneNumber, string metadata, address owner)",
+    ];
 
     let polygonProvider = null;
     let sapphireProvider = null;
     let sapphireTestnetProvider = null;
+    let roflLogicProvider = null;
+    let businessNumberDbContract = null;
+    let callerIdPoolRoflContract = null;
+    let roflPoolOwnerAddress = null;
+    let roflCallerIdIndex = 0;
+    let roflAddress = null;
+    let roflOwnerResolved = false;
 
     function getPolygonProvider() {
         if (!polygonProvider) polygonProvider = new ethers.providers.JsonRpcProvider(POLYGON_RPC);
@@ -56,6 +90,77 @@ function createBlockchainApi({
         return sapphireTestnetProvider;
     }
 
+    function getRoflLogicProvider() {
+        if (!roflLogicProvider) {
+            if (ROFL_LOGIC_CHAIN_ID) {
+                roflLogicProvider = new ethers.providers.JsonRpcProvider(ROFL_LOGIC_RPC, ROFL_LOGIC_CHAIN_ID);
+            } else {
+                roflLogicProvider = new ethers.providers.JsonRpcProvider(ROFL_LOGIC_RPC);
+            }
+        }
+        return roflLogicProvider;
+    }
+
+    function normalizeContractAddress(value) {
+        const normalized = String(value || "").trim();
+        if (!normalized || normalized === "0x0000000000000000000000000000000000000000") return "";
+        return normalized;
+    }
+
+    function toSafeNumber(value, fallback = 0) {
+        if (typeof value === "number") return value;
+        if (typeof value === "bigint") return Number(value);
+        if (value && typeof value.toString === "function") return Number(value.toString());
+        return fallback;
+    }
+
+    function getRoflAddress() {
+        if (!roflAddress && ROFL_PKEY) {
+            try {
+                roflAddress = new ethers.Wallet(ROFL_PKEY).address;
+            } catch (err) {
+                logger.error(`[ROFL_LOCAL] invalid PKEY: ${err.message}`);
+            }
+        }
+        return roflAddress;
+    }
+
+    function getBusinessNumberDbContract() {
+        if (!businessNumberDbContract) {
+            const address = normalizeContractAddress(ROFL_BUSINESS_NUMBER_DB_ADDRESS);
+            if (!address) return null;
+            businessNumberDbContract = new ethers.Contract(address, BUSINESS_NUMBER_DB_ABI, getRoflLogicProvider());
+        }
+        return businessNumberDbContract;
+    }
+
+    function getRoflCallerIdPoolContract() {
+        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());
+        }
+        return callerIdPoolRoflContract;
+    }
+
+    async function getRoflPoolOwnerAddress() {
+        if (roflOwnerResolved) return roflPoolOwnerAddress || getRoflAddress();
+
+        roflOwnerResolved = true;
+        const pool = getRoflCallerIdPoolContract();
+        if (!pool) {
+            roflPoolOwnerAddress = getRoflAddress();
+            return roflPoolOwnerAddress;
+        }
+        try {
+            roflPoolOwnerAddress = await pool.admin();
+        } catch (err) {
+            logger.warn(`[ROFL_LOCAL] pool admin() failed, falling back to ROFL key address: ${err.message}`);
+            roflPoolOwnerAddress = getRoflAddress();
+        }
+        return roflPoolOwnerAddress;
+    }
+
     function isEthAddress(str) {
         return /^0x[0-9a-fA-F]{40}$/.test(str);
     }
@@ -285,6 +390,74 @@ function createBlockchainApi({
         }
     }
 
+    async function roflFindBusinessNumber(callee) {
+        const contract = getBusinessNumberDbContract();
+        if (!contract) return null;
+
+        const businessName = String(callee || "").trim().toLowerCase();
+        if (!businessName) return null;
+        try {
+            const phoneNumber = await contract.getPhoneNumber(businessName);
+            return phoneNumber && phoneNumber !== "" ? phoneNumber : null;
+        } catch (err) {
+            logger.error(`[ROFL_LOCAL] find-business-number failed for ${businessName}: ${err.message}`);
+            return null;
+        }
+    }
+
+    async function roflAssignFromNumber() {
+        const pool = getRoflCallerIdPoolContract();
+        if (!pool) return null;
+
+        try {
+            const poolSize = await pool.getPoolSize();
+            if (toSafeNumber(poolSize) <= 0) return null;
+
+            const roflKeyAddress = getRoflAddress();
+
+            // Explicit request: if PKEY is not set, assign directly from pool
+            // without owner filtering (pure round-robin by token list index).
+            if (!roflKeyAddress) {
+                const tokens = await pool.getTokens();
+                if (!tokens || tokens.length === 0) return null;
+
+                const idx = roflCallerIdIndex % tokens.length;
+                const tokenId = tokens[idx];
+                const [fromNumber] = await pool.getCallerIdByTokenId(tokenId);
+                if (!fromNumber || fromNumber === "") return null;
+
+                roflCallerIdIndex = idx + 1;
+                return fromNumber;
+            }
+
+            const ownerForPool = (await getRoflPoolOwnerAddress()) || roflKeyAddress;
+            if (!ownerForPool) return null;
+
+            const [fromNumber, foundIndex, found] = await pool.findNextOwnedCallerId(
+                ethers.BigNumber.from(roflCallerIdIndex),
+                ownerForPool,
+                poolSize,
+            );
+
+            if (!found || !fromNumber || fromNumber === "") return null;
+            roflCallerIdIndex = toSafeNumber(foundIndex, roflCallerIdIndex) + 1;
+            return fromNumber;
+        } catch (err) {
+            logger.error(`[ROFL_LOCAL] assign-from-number failed: ${err.message}`);
+            return null;
+        }
+    }
+
+    function getRoflLogicInfo() {
+        return {
+            rpc: ROFL_LOGIC_RPC || null,
+            chainId: ROFL_LOGIC_CHAIN_ID || null,
+            businessNumberDbAddress: normalizeContractAddress(ROFL_BUSINESS_NUMBER_DB_ADDRESS) || null,
+            callerIdPoolAddress: normalizeContractAddress(ROFL_CALLER_ID_POOL_ADDRESS) || null,
+            roflAddress: getRoflAddress() || null,
+        };
+    }
+
     return {
         ethers,
         getPolygonProvider,
@@ -302,6 +475,9 @@ function createBlockchainApi({
         verifyHttpSignalingSignature,
         resolveCallerServiceProviderContract,
         nftGetOwnedNumber,
+        roflFindBusinessNumber,
+        roflAssignFromNumber,
+        getRoflLogicInfo,
         getRpcForNetwork,
     };
 }

package/webRTCservice/modules/callRouter.js

@@ -6,6 +6,9 @@ function createCallRouter({
     roflBaseUrl,
     fetchImpl = fetch,
     logger = console,
+    useLocalRoflLogic = false,
+    lookupBusinessNumberImpl = null,
+    assignFromNumberImpl = null,
 }) {
     function isRawEmail(str) {
         return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str) && !str.endsWith(".global");
@@ -34,6 +37,15 @@ function createCallRouter({
     }
 
     async function roflFindBusinessNumber(callee) {
+        if (useLocalRoflLogic && typeof lookupBusinessNumberImpl === "function") {
+            try {
+                return (await lookupBusinessNumberImpl(callee)) || null;
+            } catch (err) {
+                logger.error(`[ROFL_LOCAL] find-business-number failed for ${callee}: ${err.message}`);
+                return null;
+            }
+        }
+
         try {
             const resp = await fetchImpl(`${roflBaseUrl}/find-business-number`, {
                 method: "POST",
@@ -82,6 +94,15 @@ function createCallRouter({
     }
 
     async function roflAssignFromNumber() {
+        if (useLocalRoflLogic && typeof assignFromNumberImpl === "function") {
+            try {
+                return (await assignFromNumberImpl()) || null;
+            } catch (err) {
+                logger.error(`[ROFL_LOCAL] assign-from-number failed: ${err.message}`);
+                return null;
+            }
+        }
+
         try {
             const resp = await fetchImpl(`${roflBaseUrl}/assign-from-number`);
             if (!resp.ok) return null;

package/webRTCservice/webRTCmanager.js

@@ -237,6 +237,7 @@ const config = {
     polygon: pickRuntimeConfig("polygon", {}),
     sapphire: pickRuntimeConfig("sapphire", {}),
     sapphireTestnet: pickRuntimeConfig("sapphireTestnet", {}),
+    roflLogic: pickRuntimeConfig("roflLogic", {}),
 };
 const serviceRuntimes = loadedServices;
 const selectedServiceId = process.env.SERVICE_ID || null;
@@ -268,6 +269,8 @@ const INTERNAL_BIND_IP = config.bindIp || "127.0.0.1";
 
 // ROFL API config
 const ROFL_BASE_URL = config.roflBaseUrl;
+const USE_LOCAL_ROFL_LOGIC =
+    String(process.env.USE_LOCAL_ROFL_LOGIC || pickRuntimeConfig("useLocalRoflLogic", true)) === "true";
 const MESSAGE_PROCESSOR_URL =
     config.messageProcessorUrl ||
     "https://europe-west3-asterisk-tts-test.cloudfunctions.net/client_msg_processor";
@@ -313,7 +316,17 @@ const callRouterApi = createCallRouter({
     roflBaseUrl: ROFL_BASE_URL,
     fetchImpl: fetch,
     logger: console,
+    useLocalRoflLogic: USE_LOCAL_ROFL_LOGIC,
+    lookupBusinessNumberImpl: (...args) => blockchainApi.roflFindBusinessNumber(...args),
+    assignFromNumberImpl: (...args) => blockchainApi.roflAssignFromNumber(...args),
 });
+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"}`,
+);
 const notificationApi = createNotificationApi({
     blockchainApi,
     signalingPlanAbi: SIGNALING_PLAN_ABI,