Gate proxy nonce budget on share activity

Author: MoneroOcean

lib/pool/miner_registry.js

@@ -98,7 +98,7 @@ module.exports = function createMinerRegistry(deps) {
         miner.proxyMinerName = proxyMinerName;
 
         if (!(proxyMinerName in state.proxyMiners)) {
-            state.proxyMiners[proxyMinerName] = { connectTime: Date.now(), count: 1, hashes: 0 };
+            state.proxyMiners[proxyMinerName] = { connectTime: Date.now(), count: 1, hashes: 0, submissionBudget: false };
             console.log(state.threadName + formatPoolEvent("Proxy track", { payout: proxyMinerName }));
         } else if (++state.proxyMiners[proxyMinerName].count > global.config.pool.workerMax) {
             console.error(state.threadName + formatPoolEvent("Wallet long ban", {

lib/pool/protocol.js

@@ -84,7 +84,8 @@ module.exports = function createProtocolHandler(deps) {
     function hasProxySubmissionBudget(miner) {
         if (!miner) return false;
         const proxyMinerName = miner.proxyMinerName || miner.payout;
-        return !!(proxyMinerName && proxyMinerName in state.proxyMiners);
+        const proxyMiner = proxyMinerName && state.proxyMiners[proxyMinerName];
+        return !!(proxyMiner && proxyMiner.submissionBudget === true);
     }
 
     function getTrackedSubmissionLimit(miner) {

lib/pool/shares.js

@@ -205,7 +205,10 @@ module.exports = function createShareProcessor(deps) {
     function recordShareData(miner, job, isTrustedShare, blockTemplate) {
         miner.hashes += job.norm_diff;
         const proxyMinerName = miner.payout;
-        if (proxyMinerName in proxyMiners) proxyMiners[proxyMinerName].hashes += job.norm_diff;
+        if (proxyMinerName in proxyMiners) {
+            proxyMiners[proxyMinerName].hashes += job.norm_diff;
+            proxyMiners[proxyMinerName].submissionBudget = true;
+        }
         if (miner.payout in walletTrust) walletLastSeeTime[miner.payout] = Date.now();
 
         const timeNow = Date.now();
@@ -337,6 +340,7 @@ module.exports = function createShareProcessor(deps) {
                     if (addProxyMiner(miner)) {
                         const proxyMinerName = miner.payout;
                         proxyMiners[proxyMinerName].hashes += job.norm_diff;
+                        proxyMiners[proxyMinerName].submissionBudget = true;
                         adjustMinerDiff(miner);
                     }
                     nextProcessShareCB(null);

tests/pool/runtime/submissions.js

@@ -420,7 +420,66 @@ test("jobs reject new nonces after reaching the tracked submission cap without e
     }
 });
 
-test("proxy-tracked jobs use the larger tracked submission cap", async () => {
+test("proxy-labeled jobs use the normal tracked submission cap before share activity", async () => {
+    const { runtime } = await startHarness();
+    const originalThrottlePerSec = global.config.pool.minerThrottleSharePerSec;
+    const originalThrottleWindow = global.config.pool.minerThrottleShareWindow;
+    const socket = {};
+
+    try {
+        global.config.pool.minerThrottleSharePerSec = 2;
+        global.config.pool.minerThrottleShareWindow = 5;
+
+        const loginReply = invokePoolMethod({
+            socket,
+            id: 201,
+            method: "login",
+            params: {
+                login: MAIN_WALLET,
+                pass: "proxy-submission-cap",
+                agent: "attacker-controlled string containing proxy"
+            }
+        });
+        const miner = runtime.getState().activeMiners.get(socket.miner_id);
+        const jobId = loginReply.replies[0].result.job.job_id;
+        const job = miner.validJobs.toarray().find((entry) => entry.id === jobId);
+        const trackedSubmissionLimit = global.config.pool.minerThrottleShareWindow * global.config.pool.minerThrottleSharePerSec * 100;
+
+        assert.equal(miner.proxyMinerName, MAIN_WALLET);
+        assert.equal(MAIN_WALLET in runtime.getState().proxyMiners, true);
+        assert.equal(runtime.getState().proxyMiners[MAIN_WALLET].submissionBudget, false);
+
+        job.submissions = new Map();
+        for (let index = 0; index < trackedSubmissionLimit; ++index) {
+            job.submissions.set(index.toString(16).padStart(8, "0"), 1);
+        }
+
+        const submitReply = invokePoolMethod({
+            socket,
+            id: 202,
+            method: "submit",
+            params: {
+                id: socket.miner_id,
+                job_id: jobId,
+                nonce: "fffffff0",
+                result: VALID_RESULT
+            }
+        });
+
+        assert.deepEqual(submitReply.replies, [{
+            error: "Too many share submissions for the current job. Wait for a new job.",
+            result: undefined
+        }]);
+        assert.equal(job.submissions.size, trackedSubmissionLimit);
+        assert.equal(job.submissions.has("fffffff0"), false);
+    } finally {
+        global.config.pool.minerThrottleSharePerSec = originalThrottlePerSec;
+        global.config.pool.minerThrottleShareWindow = originalThrottleWindow;
+        await runtime.stop();
+    }
+});
+
+test("proxy jobs with observed share activity use the larger tracked submission cap", async () => {
     const { runtime } = await startHarness();
     const originalThrottlePerSec = global.config.pool.minerThrottleSharePerSec;
     const originalThrottleWindow = global.config.pool.minerThrottleShareWindow;
@@ -447,6 +506,25 @@ test("proxy-tracked jobs use the larger tracked submission cap", async () => {
 
         assert.equal(miner.proxyMinerName, MAIN_WALLET);
         assert.equal(MAIN_WALLET in runtime.getState().proxyMiners, true);
+        assert.equal(runtime.getState().proxyMiners[MAIN_WALLET].submissionBudget, false);
+
+        const firstShareReply = invokePoolMethod({
+            socket,
+            id: 202,
+            method: "submit",
+            params: {
+                id: socket.miner_id,
+                job_id: jobId,
+                nonce: "fffffff0",
+                result: VALID_RESULT
+            }
+        });
+
+        assert.deepEqual(firstShareReply.replies, [{
+            error: null,
+            result: { status: "OK" }
+        }]);
+        assert.equal(runtime.getState().proxyMiners[MAIN_WALLET].submissionBudget, true);
 
         job.submissions = new Map();
         for (let index = 0; index < trackedSubmissionLimit - 1; ++index) {
@@ -455,12 +533,12 @@ test("proxy-tracked jobs use the larger tracked submission cap", async () => {
 
         const submitReply = invokePoolMethod({
             socket,
-            id: 202,
+            id: 203,
             method: "submit",
             params: {
                 id: socket.miner_id,
                 job_id: jobId,
-                nonce: "fffffff0",
+                nonce: "fffffff1",
                 result: VALID_RESULT
             }
         });
@@ -470,16 +548,16 @@ test("proxy-tracked jobs use the larger tracked submission cap", async () => {
             result: { status: "OK" }
         }]);
         assert.equal(job.submissions.size, trackedSubmissionLimit);
-        assert.equal(job.submissions.has("fffffff0"), true);
+        assert.equal(job.submissions.has("fffffff1"), true);
 
         const cappedReply = invokePoolMethod({
             socket,
-            id: 203,
+            id: 204,
             method: "submit",
             params: {
                 id: socket.miner_id,
                 job_id: jobId,
-                nonce: "fffffff1",
+                nonce: "fffffff2",
                 result: VALID_RESULT
             }
         });
@@ -488,7 +566,7 @@ test("proxy-tracked jobs use the larger tracked submission cap", async () => {
             error: "Too many share submissions for the current job. Wait for a new job.",
             result: undefined
         }]);
-        assert.equal(job.submissions.has("fffffff1"), false);
+        assert.equal(job.submissions.has("fffffff2"), false);
     } finally {
         global.config.pool.minerThrottleSharePerSec = originalThrottlePerSec;
         global.config.pool.minerThrottleShareWindow = originalThrottleWindow;