Merge branch 'main' into Calendar

Author: elizabetheonoja-art

.env.example

@@ -0,0 +1,7 @@
+# Algorand Network Configuration
+ALGOD_TOKEN=
+ALGOD_SERVER=https://testnet-api.algonode.cloud
+ALGOD_PORT=443
+
+# Owner Account (for executing reclaim transactions)
+OWNER_MNEMONIC=

index.js

@@ -1,6 +1,7 @@
 const express = require('express');
 const cors = require('cors');
 const AvailabilityService = require('./services/availabilityService');
+const AutoReclaimWorker = require('./services/autoReclaimWorker');
 
 const app = express();
 const port = 3000;
@@ -96,6 +97,25 @@ if (require.main === module) {
     });
   }).catch(error => {
     console.error('Failed to initialize Availability Service:', error);
+app.get('/status', (req, res) => {
+  res.json({
+    auto_reclaim_worker: 'Active',
+    schedule: 'Every 10 minutes',
+    last_check: new Date().toISOString()
+  });
+});
+
+if (require.main === module) {
+  const autoReclaimWorker = new AutoReclaimWorker();
+
+  autoReclaimWorker.initialize().then(() => {
+    autoReclaimWorker.start();
+    app.listen(port, () => {
+      console.log(`LeaseFlow Backend listening at http://localhost:${port}`);
+      console.log('Auto-Reclaim Worker started');
+    });
+  }).catch(error => {
+    console.error('Failed to initialize Auto-Reclaim Worker:', error);
     process.exit(1);
   });
 }

package-lock.json

@@ -11,7 +11,8 @@
     "algosdk": "^2.0.0",
     "cors": "^2.8.6",
     "dotenv": "^17.3.1",
-    "express": "^5.2.1"
+    "express": "^5.2.1",
+    "node-cron": "^3.0.3"
   },
   "devDependencies": {
     "jest": "^30.3.0",

package.json

@@ -0,0 +1,162 @@
+const cron = require('node-cron');
+const algosdk = require('algosdk');
+
+class AutoReclaimWorker {
+  constructor() {
+    this.contractId = 'CAEGD57WVTVQSYWYB23AISBW334QO7WNA5XQ56S45GH6BP3D2AVHKUG4';
+    this.algodClient = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    require('dotenv').config();
+
+    const algodToken = process.env.ALGOD_TOKEN || '';
+    const algodServer = process.env.ALGOD_SERVER || 'https://testnet-api.algonode.cloud';
+    const algodPort = parseInt(process.env.ALGOD_PORT) || 443;
+
+    this.algodClient = new algosdk.Algodv2(algodToken, algodServer, algodPort);
+    console.log('AutoReclaimWorker initialized');
+  }
+
+  async checkExpiredLeases() {
+    if (!this.algodClient) {
+      throw new Error('Worker not initialized');
+    }
+
+    try {
+      const appInfo = await this.algodClient.getApplicationByID(parseInt(this.contractId)).do();
+
+      const globalState = appInfo.params['global-state'] || [];
+      const leases = this.extractLeasesFromGlobalState(globalState);
+
+      const expiredLeases = leases.filter(lease =>
+        lease.renter_balance && lease.renter_balance <= 0
+      );
+
+      console.log(`Found ${expiredLeases.length} expired leases out of ${leases.length} total leases`);
+
+      return expiredLeases;
+    } catch (error) {
+      console.error('Error checking expired leases:', error);
+      throw error;
+    }
+  }
+
+  extractLeasesFromGlobalState(globalState) {
+    const leases = [];
+
+    globalState.forEach(state => {
+      const key = Buffer.from(state.key, 'base64').toString('utf8');
+
+      if (key.startsWith('lease_')) {
+        const leaseData = this.parseLeaseData(state.value);
+        leases.push({
+          id: key.replace('lease_', ''),
+          ...leaseData
+        });
+      }
+    });
+
+    return leases.filter(lease => lease.renter_balance !== undefined);
+  }
+
+  parseLeaseData(value) {
+    if (value.type === 1) {
+      const intValue = parseInt(value.uint);
+      return { renter_balance: intValue };
+    }
+
+    if (value.type === 2) {
+      const byteValue = Buffer.from(value.bytes, 'base64').toString('utf8');
+      try {
+        return JSON.parse(byteValue);
+      } catch {
+        return { renter_balance: 0 };
+      }
+    }
+
+    return { renter_balance: 0 };
+  }
+
+  async executeReclaim(leaseId) {
+    try {
+      const senderAccount = this.getOwnerAccount();
+
+      const suggestedParams = await this.algodClient.getTransactionParams().do();
+
+      const appCallTxn = algosdk.makeApplicationCallTxnFromObject({
+        from: senderAccount.addr,
+        appIndex: parseInt(this.contractId),
+        appArgs: [new Uint8Array(Buffer.from('reclaim'))],
+        foreignAssets: [],
+        accounts: [],
+        appForeignApps: [],
+        suggestedParams,
+        onComplete: algosdk.OnApplicationComplete.NoOpOC
+      });
+
+      const signedTxn = appCallTxn.signTxn(senderAccount.sk);
+      const txId = appCallTxn.txID().toString();
+
+      await this.algodClient.sendRawTransaction(signedTxn).do();
+
+      const confirmedTxn = await algosdk.waitForConfirmation(this.algodClient, txId, 4);
+
+      console.log(`Successfully reclaimed lease ${leaseId}. Transaction ID: ${txId}`);
+      return confirmedTxn;
+
+    } catch (error) {
+      console.error(`Failed to reclaim lease ${leaseId}:`, error);
+      throw error;
+    }
+  }
+
+  getOwnerAccount() {
+    const ownerMnemonic = process.env.OWNER_MNEMONIC;
+    if (!ownerMnemonic) {
+      throw new Error('OWNER_MNEMONIC environment variable not set');
+    }
+
+    return algosdk.mnemonicToSecretKey(ownerMnemonic);
+  }
+
+  async runReclaimCycle() {
+    if (this.isRunning) {
+      console.log('Reclaim cycle already running, skipping...');
+      return;
+    }
+
+    this.isRunning = true;
+
+    try {
+      console.log('Starting auto-reclaim cycle...');
+
+      const expiredLeases = await this.checkExpiredLeases();
+
+      for (const lease of expiredLeases) {
+        console.log(`Reclaiming lease ${lease.id} with balance ${lease.renter_balance}`);
+        await this.executeReclaim(lease.id);
+      }
+
+      console.log('Auto-reclaim cycle completed');
+
+    } catch (error) {
+      console.error('Error in reclaim cycle:', error);
+    } finally {
+      this.isRunning = false;
+    }
+  }
+
+  start() {
+    console.log('Starting Auto-Reclaim Worker (every 10 minutes)...');
+
+    cron.schedule('*/10 * * * *', async () => {
+      await this.runReclaimCycle();
+    });
+
+    setTimeout(() => this.runReclaimCycle(), 5000);
+  }
+}
+
+module.exports = AutoReclaimWorker;