@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/src/options.js

@@ -0,0 +1,126 @@
+// options.js
+// Singleton helper for option tickers, reduce/flip bookkeeping, rPNL, and simple valuation.
+// No state stored; singleton export for convenience.
+
+class OptionsEngine {
+  // "series-expiry-(C|P)-strike?"
+  isOptionTicker(t) {
+    return typeof t === 'string' && /^.+?-\d+-(C|P)(-\d+(\.\d+)?)?$/.test(t);
+  }
+
+  parseTicker(t) {
+    if (!t || typeof t !== 'string') return null;
+    const parts = t.split('-');
+    if (parts.length < 3) return null;
+    const seriesId = parts[0];
+    const expiryBlock = parseInt(parts[1], 10);
+    const cp = parts[2];
+    const type = cp === 'C' ? 'Call' : (cp === 'P' ? 'Put' : null);
+    const strike = parts[3] ? parseFloat(parts[3]) : null;
+    if (!seriesId || Number.isNaN(expiryBlock) || !type) return null;
+    return { seriesId, expiryBlock, type, strike, raw: t };
+  }
+
+  /**
+   * Given existing signed qty and a signed delta, compute how much is closing vs flipping.
+   * existing >0 long, <0 short. delta >0 buy, <0 sell.
+   */
+  computeReduceFlip(existingQty, deltaQty) {
+    const ex = Number(existingQty) || 0;
+    const d  = Number(deltaQty)    || 0;
+    const after = ex + d;
+
+    const exSide = ex > 0 ? 'LONG' : ex < 0 ? 'SHORT' : null;
+    const dSide  = d  > 0 ? 'LONG' : d  < 0 ? 'SHORT' : null;
+
+    let closedQty = 0;
+    let flipQty = 0;
+
+    if (ex !== 0 && d !== 0 && Math.sign(ex) !== Math.sign(d)) {
+      closedQty = Math.min(Math.abs(ex), Math.abs(d));
+      if (Math.abs(d) > Math.abs(ex)) {
+        flipQty = Math.abs(d) - Math.abs(ex);
+      }
+    }
+
+    const afterSide = after > 0 ? 'LONG' : after < 0 ? 'SHORT' : null;
+
+    return { existing: ex, delta: d, after, exSide, dSide, afterSide, closedQty, flipQty };
+  }
+
+  /**
+   * Realized PnL when reducing an option position.
+   * Long reduce: (trade - avg) * qty
+   * Short reduce: (avg - trade) * qty
+   */
+  rpnlForClose(exSide, closedQty, tradePrice, avgPrice) {
+    const q = Number(closedQty)   || 0;
+    const p = Number(tradePrice)  || 0;
+    const a = Number(avgPrice)    || 0;
+    if (!q || !exSide) return 0;
+    return exSide === 'LONG' ? (p - a) * q : (a - p) * q;
+  }
+
+  /**
+   * Intrinsic value at spot S (European payoff at mark).
+   */
+  intrinsic(type, K, S) {
+    const k = Number(K) || 0;
+    const s = Number(S) || 0;
+    if (type === 'Call') return Math.max(0, s - k);
+    return Math.max(0, k - s);
+  }
+
+  /**
+   * Very light EU price proxy using Bachelier (normal) to avoid heavy math deps:
+   * price ≈ intrinsic + v * sqrt(T) * phi(0)   (with a tiny convexity tweak)
+   * where v = vol (in price units), T in years.
+   * If you store a per-series vol index σ_annual (as decimal), you can use
+   * a Bachelier-like proxy with v = σ_annual * S for calls; puts symmetric.
+   * If vol is missing, fallback to intrinsic.
+   */
+  priceEUApprox(type, S, K, volAnnual, daysToExpiry) {
+    const s = Number(S) || 0;
+    const k = Number(K) || 0;
+    const T = Math.max(0, Number(daysToExpiry || 0)) / 365;
+    const iv = this.intrinsic(type, k, s);
+    if (!volAnnual || !T) return iv;
+
+    const sigma = Number(volAnnual);          // if you store as decimal (e.g. 0.6)
+    const v = sigma * s;                      // price vol in Bachelier
+    const noise = v * Math.sqrt(T) * 0.3989;  // ≈ φ(0) ~ 0.3989
+    // keep it conservative: intrinsic plus a slice of noise
+    return Math.max(iv, iv + noise);
+  }
+
+  /**
+   * Maintenance for *naked* shorts (10x leverage padding, your rule of thumb).
+   * Use strike/10 as generic notional for puts, and S/10 for calls (conservative).
+   * You can tune this per-series if you store policy on the registry.
+   */
+  nakedMaintenance(type, K, S) {
+    if (type === 'Call') return (Number(S) || 0) / 10; // ~10x leverage on spot notional
+    return (Number(K) || 0) / 10;                      // puts on strike notional
+  }
+
+  /**
+   * Mark-to-model exposure for a set of option positions (for liquidation offsets).
+   * positions: [{ type:'Call'|'Put', strike, qty (signed), avgPrice?, expiryBlock }]
+   * Returns total premium value (signed) at current S, using vol index and time.
+   */
+  mtmExposure(positions, S, volAnnual, blocksToExpiry, blocksPerDay) {
+    const bpd = Math.max(1, Number(blocksPerDay || 144)); // default ~ Bitcoin-like
+    const days = Math.max(0, Number(blocksToExpiry || 0) / bpd);
+    let prem = 0, intr = 0;
+    for (const p of (positions || [])) {
+      const price = this.priceEUApprox(p.type, S, p.strike, volAnnual, days);
+      prem += price * (Number(p.qty) || 0);
+      intr += this.intrinsic(p.type, p.strike, S) * (Number(p.qty) || 0);
+    }
+    return { premium: prem, intrinsic: intr };
+  }
+}
+
+// Export as a singleton instance.
+const Options = new OptionsEngine();
+module.exports = Options;

package/tradelayer.js/src/oracle.js

@@ -0,0 +1,394 @@
+var db = require('./db')
+var BigNumber = require('bignumber.js')
+const Insurance = require('./insurance.js')
+
+class OracleList {
+    static instance = null;
+    static lastOracleUpdateBlock = new Map();
+
+    constructor() {
+        if (!OracleList.instance) {
+            this.oracles = new Map(); // Initialize the oracles map only once
+            OracleList.instance = this;
+        }
+
+        return OracleList.instance;
+    }
+
+    static async getAllOracles() {
+        const instance = OracleList.getInstance();
+        await OracleList.load(); // Make sure the oracles are loaded
+
+        // Convert the Map of oracles to an array
+        return Array.from(instance.oracles.values());
+    }
+
+    async addOracle(oracleId, oracleData) {
+        try {
+            // Add to in-memory map
+            this.oracles.set(oracleId, oracleData);
+
+            // Add to NeDB database (if applicable)
+            const oracleDB = await db.getDatabase('oracleList');
+            await oracleDB.insertAsync({ _id: oracleId, ...oracleData });
+
+            console.log(`Oracle added: ID ${oracleId}`);
+            return true; // Indicate success
+        } catch (error) {
+            console.error(`Error adding oracle: ID ${oracleId}`, error);
+            throw error; // Re-throw the error for the caller to handle
+        }
+    }
+
+    static async getOracleInfo(oracleId) {
+        const instance = OracleList.getInstance();
+
+        // Check if in-memory map is empty and load if necessary
+        if (instance.oracles.size === 0) {
+            await OracleList.load();
+        }
+
+        // Oracle key to search for
+        const oracleKey = `oracle-${oracleId}`;
+
+        // Check in the in-memory map
+        const oracle = instance.oracles.get(oracleKey);
+        if (oracle) {
+            return oracle;
+        }
+
+        // If not found in-memory, optionally check the database
+        const oracleDB = await db.getDatabase('oracleList');
+        console.log('oracle key '+oracleKey)
+        const dbOracle = await oracleDB.findOneAsync({ _id: oracleKey });
+        console.log('db oracle '+ JSON.stringify(dbOracle))
+        if (dbOracle) {
+            return dbOracle;
+        }
+
+        console.log(`Oracle data not found for oracle ID: ${oracleId}`);
+        return null;
+    }
+    
+    static async getOraclePrice(oracleId) {
+        // Prepare the query to find all entries with the specified oracleId
+        const oracleDB = await db.getDatabase('oracleData');
+        const oracleData = await oracleDB.findAsync({ oracleId: oracleId });
+        
+        // Check if any data was returned
+        if (oracleData.length === 0) {
+            return 1
+        }
+        
+        // Find the latest data point by blockHeight
+        const latestDataPoint = oracleData.reduce((latest, entry) => {
+            return (entry.blockHeight > latest.blockHeight) ? entry : latest;
+        });
+
+        console.log('Latest oracle data:', JSON.stringify(latestDataPoint));
+        return latestDataPoint.data.price;
+    }
+
+    static async publishData(oracleId, price, high, low, close, blockHeight) {
+        const lastBlock = OracleList.lastOracleUpdateBlock.get(oracleId);
+
+        if (lastBlock !== undefined && lastBlock >= blockHeight) {
+            console.log(`⛔ Oracle ${oracleId} already updated at block ${lastBlock}. Skipping block ${blockHeight}.`);
+            return;
+        }
+
+        // mark as updated
+        OracleList.lastOracleUpdateBlock.set(oracleId, blockHeight);
+
+        try {
+            const instance = OracleList.getInstance();
+
+            // Prepare oracle data
+            const oracleData = { price, high, low, close };
+            const lastPrice = await OracleList.getOraclePrice(oracleId)
+            console.log('last price '+lastPrice)
+            const priceBN = new BigNumber(price)
+            const lastPriceBN = new BigNumber(lastPrice)
+            const circuitLimitUp = new BigNumber(1.05).times(lastPriceBN).decimalPlaces(4).toNumber()
+            const circuitLimitDown = new BigNumber(0.95).times(lastPriceBN).decimalPlaces(4).toNumber()
+            console.log('price, limits '+price, lastPrice, circuitLimitDown, circuitLimitUp)
+            console.log('ergo, >limit up , <limit down' + Boolean(price>circuitLimitUp)+' '+Boolean(price<circuitLimitDown))
+            if(lastPrice!=1){
+                if(price>circuitLimitUp){
+                    oracleData.price = circuitLimitUp
+                }else if(price <circuitLimitDown){
+                    oracleData.price = circuitLimitDown
+                }
+            } 
+            // Update in-memory oracle data (optional)
+            const oracleKey = `oracle-${oracleId}`;
+            instance.oracles.set(oracleKey, oracleData);
+
+            // Save oracle data to the database
+            await instance.saveOracleData(oracleId, oracleData, blockHeight);
+
+            console.log(`Data published to oracle ${oracleId} for block height ${blockHeight}`);
+        } catch (error) {
+            console.error(`Error publishing data to oracle ${oracleId} at block height ${blockHeight}:`, error);
+            throw error;
+        }
+    }
+
+    // Static method to get the singleton instance
+    static getInstance() {
+        if (!OracleList.instance) {
+            OracleList.instance = new OracleList();
+        }
+        return OracleList.instance;
+    }
+
+    static async load() {
+        try {
+            const oracleDB = await db.getDatabase('oracleList');
+            const oracles = await oracleDB.findAsync({});
+
+            const instance = OracleList.getInstance();
+            for (const oracle of oracles) {
+                instance.oracles.set(oracle._id, oracle);
+            }
+
+            console.log('Oracles loaded from the database');
+        } catch (error) {
+            console.error('Error loading oracles from the database:', error);
+        }
+    }
+
+     static async isAdmin(senderAddress, oracleId) {
+        try {
+            const oracleKey = `oracle-${oracleId}`;
+            console.log('checking admin for oracle key '+oracleKey)
+            const oracleDB = await db.getDatabase('oracleList');
+            const oracleData = await oracleDB.findOneAsync({ _id: oracleKey });
+
+            if (oracleData && oracleData.name.adminAddress === senderAddress) {
+                return true; // The sender is the admin
+            } else {
+                return false; // The sender is not the admin
+            }
+        } catch (error) {
+            console.error(`Error verifying admin for oracle ${oracleId}:`, error);
+            throw error;
+        }
+    }
+
+    static async verifyAdmin(oracleId, adminAddress) {
+        const oracleKey = `oracle-${oracleId}`;
+
+        // Check in-memory map first
+        const instance = OracleList.getInstance();
+        let oracle = instance.oracles.get(oracleKey);
+
+        // If not found in-memory, check the database
+        if (!oracle) {
+            const oracleDB = await db.getDatabase('oracleList');
+            oracle = await oracleDB.findOneAsync({ _id: oracleKey });
+        }
+
+        // Verify admin address
+        return oracle && oracle.adminAddress === adminAddress;
+    }
+
+
+    static async updateAdmin(oracleId, newAdminAddress, backup) {
+        const oracleKey = `oracle-${oracleId}`;
+        const instance = OracleList.getInstance();
+            
+        // Get the NeDB datastore for oracles
+        const oracleDB = await db.getDatabase('oracleList');
+
+        // Fetch the current oracle data
+        const oracle = await oracleDB.findOneAsync({ _id: oracleKey });
+
+        if (!oracle) {
+            throw new Error('Oracle not found');
+        }
+
+        if(backup){
+            oracle.backupAddress=newAdminAddress
+        }else{
+            // Update the admin address
+            oracle.adminAddress = newAdminAddress;
+        }
+
+        // Update the oracle in the database
+        await oracleDB.updateAsync({ _id: oracleKey }, { $set: { adminAddress: newAdminAddress } }, {});
+
+        // Optionally, update the in-memory map if you are maintaining one
+        this.oracles.set(oracleKey, oracle);
+
+        console.log(`Oracle ID ${oracleId} admin updated to ${newAdminAddress}`);
+    }
+
+    static async createOracle(name, adminAddress) {
+        const instance = OracleList.getInstance(); // Get the singleton instance
+        const oracleId = OracleList.getNextId();
+        const oracleKey = `oracle-${oracleId}`;
+
+        const newOracle = {
+            _id: oracleKey, // NeDB uses _id as the primary key
+            id: oracleId,
+            name: name,
+            adminAddress: adminAddress,
+            data: {} // Initial data, can be empty or preset values
+        };
+
+        // Get the NeDB datastore for oracles
+        const oracleDB = await db.getDatabase('oracleList');
+
+        try {
+            // Save the new oracle to the database
+            await oracleDB.insertAsync(newOracle);
+
+            // Also save the new oracle to the in-memory map
+            instance.oracles.set(oracleKey, newOracle);
+
+            console.log(`New oracle created: ID ${oracleId}, Name: ${name}`);
+            return oracleId; // Return the new oracle ID
+        } catch (error) {
+            console.error('Error creating new oracle:', error);
+            throw error; // Re-throw the error for the caller to handle
+        }
+    }
+
+    static getNextId() {
+        const instance = OracleList.getInstance(); // Get the singleton instance
+        let maxId = 0;
+        for (const key of instance.oracles.keys()) {
+            const currentId = parseInt(key.split('-')[1]);
+            if (currentId > maxId) {
+                maxId = currentId;
+            }
+        }
+        return maxId + 1;
+    }
+
+    async saveOracleData(oracleId, data, blockHeight) {
+        const oracleDataDB = await db.getDatabase('oracleData');
+        const recordKey = `oracle-${oracleId}-${blockHeight}`;
+        console.log('saving published oracle data to key '+recordKey)
+        const oracleDataRecord = {
+            _id: recordKey,
+            oracleId,
+            data,
+            blockHeight
+        };
+
+        try {
+            await oracleDataDB.updateAsync(
+                { _id: recordKey },
+                oracleDataRecord,
+                { upsert: true }
+            );
+            console.log(`Oracle data record saved successfully: ${recordKey}`);
+        } catch (error) {
+            console.error(`Error saving oracle data record: ${recordKey}`, error);
+            throw error;
+        }
+    }
+
+    async loadOracleData(oracleId, startBlockHeight = 0, endBlockHeight = Number.MAX_SAFE_INTEGER) {
+        const oracleDataDB = await db.getDatabase('oracleData');
+        try {
+            const query = {
+                oracleId: oracleId,
+                blockHeight: { $gte: startBlockHeight, $lte: endBlockHeight }
+            };
+            const oracleDataRecords = await oracleDataDB.findAsync(query);
+            return oracleDataRecords.map(record => ({
+                blockHeight: record.blockHeight,
+                data: record.data
+            }));
+        } catch (error) {
+            console.error(`Error loading oracle data for oracleId ${oracleId}:`, error);
+            throw error;
+        }
+    }
+
+    static async closeOracle(oracleId) {
+        const instance = OracleList.getInstance();
+        const oracleKey = `oracle-${oracleId}`;
+        const oracleDB = await db.getDatabase('oracleList');
+
+        try {
+            // Fetch the current oracle data
+            const oracle = await oracleDB.findOneAsync({ _id: oracleKey });
+
+            if (!oracle) {
+                throw new Error('Oracle not found');
+            }
+
+            // Mark the oracle as closed
+            oracle.closed = true;
+
+            // Update the oracle in the database
+            await oracleDB.updateAsync({ _id: oracleKey }, { $set: { closed: true } }, {});
+
+            // Update the in-memory map if maintaining one
+            instance.oracles.set(oracleKey, oracle);
+
+            console.log(`Oracle ID ${oracleId} has been closed`);
+
+            // Call the insurance fund to perform the payout
+            await Insurance.liquidate(oracle.adminAddress,true);
+
+            console.log(`Payout for Oracle ID ${oracleId} completed`);
+        } catch (error) {
+            console.error(`Error closing oracle ${oracleId}:`, error);
+            throw error;
+        }
+    }
+
+
+    /**
+     * Fetches VWAP for an oracle-based contract over `trailingBlocks`
+     * @param {number} oracleId - The oracle ID
+     * @param {number} blockHeight - The current block height
+     * @param {number} trailingBlocks - The number of blocks to look back
+     * @returns {Promise<number|null>} - The calculated VWAP or null if no data
+     */
+    static async getTWAP(oracleId, blockHeight, trailingBlocks) {
+        try {
+            const oracleDB = await db.getDatabase('oracleData');
+            const blockStart = blockHeight - trailingBlocks;
+
+            // Query oracle data within the block range
+            const oracleData = await oracleDB.findAsync({
+                oracleId,
+                blockHeight: { $gte: blockStart, $lte: blockHeight }
+            });
+
+            if (!oracleData || oracleData.length === 0) {
+                //console.warn(`⚠️ No Oracle VWAP data for oracle ${oracleId} in blocks ${blockStart}-${blockHeight}`);
+                return null;
+            }
+
+            // Calculate VWAP
+            let totalVolume = new BigNumber(0);
+            let sumVolumeTimesPrice = new BigNumber(0);
+
+            for (const entry of oracleData) {
+                const price = new BigNumber(entry.data.price);
+                const volume = new BigNumber(1); // Assume equal weight for each oracle entry
+
+                totalVolume = totalVolume.plus(volume);
+                sumVolumeTimesPrice = sumVolumeTimesPrice.plus(volume.times(price));
+            }
+
+            if (totalVolume.isZero()) return null;
+
+            return sumVolumeTimesPrice.dividedBy(totalVolume).decimalPlaces(8).toNumber();
+        } catch (error) {
+            console.error(`❌ Error fetching VWAP for oracle ${oracleId}:`, error);
+            return null;
+        }
+    }
+
+    // Additional methods for managing oracles
+}
+
+module.exports = OracleList;