tryethernal
diff --git a/‎run/api/explorers.js‎
Lines changed: 123 additions & 0 deletions b/‎run/api/explorers.js‎
Lines changed: 123 additions & 0 deletions
diff --git a/‎run/api/index.js‎
Lines changed: 8 additions & 0 deletions b/‎run/api/index.js‎
Lines changed: 8 additions & 0 deletions
diff --git a/‎run/api/opBatches.js‎
Lines changed: 91 additions & 0 deletions b/‎run/api/opBatches.js‎
Lines changed: 91 additions & 0 deletions
diff --git a/‎run/api/opDeposits.js‎
Lines changed: 49 additions & 0 deletions b/‎run/api/opDeposits.js‎
Lines changed: 49 additions & 0 deletions
diff --git a/‎run/api/opOutputs.js‎
Lines changed: 49 additions & 0 deletions b/‎run/api/opOutputs.js‎
Lines changed: 49 additions & 0 deletions
@@ -55,6 +55,20 @@ const secretMiddleware = require('../middlewares/secret');
  * @returns {Promise<object>} - The orbit config
  */
 
+/**
+ * Get available L1 parent workspaces for OP Stack configuration
+ * @returns {Promise<object>} - List of available parent workspaces
+ */
+router.get('/availableOpParents', authMiddleware, async (req, res, next) => {
+    try {
+        const availableParents = await db.getAvailableOpParents();
+
+        res.status(200).json({ availableParents });
+    } catch (error) {
+        return managedError(error, req, res);
+    }
+});
+
 router.get('/:id/orbitConfig', authMiddleware, async (req, res, next) => {
     const data = { ...req.query, ...req.params };
 
@@ -186,6 +200,115 @@ router.post('/:id/orbitConfig', authMiddleware, async (req, res, next) => {
     }
 });
 
+/**
+ * Get OP Stack config
+ * @returns {Promise<object>} - The OP config
+ */
+router.get('/:id/opConfig', authMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const opConfig = await db.getOpConfig(req.body.data.user.id, data.id);
+
+        res.status(200).json({ opConfig });
+    } catch (error) {
+        return managedError(error, req, res);
+    }
+});
+
+/**
+ * Update OP Stack config
+ * @param {object} config - The OP config to update
+ * @param {string} config.batchInboxAddress - Batch inbox address
+ * @param {string} config.optimismPortalAddress - Optimism portal address
+ * @param {string} config.l2OutputOracleAddress - L2 output oracle address (legacy)
+ * @param {string} config.disputeGameFactoryAddress - Dispute game factory address (modern)
+ * @param {string} config.systemConfigAddress - System config address
+ * @param {string} config.l2ToL1MessagePasserAddress - L2 to L1 message passer address
+ * @param {number} config.outputVersion - Output version (0 = legacy, 1 = fault proofs)
+ * @param {number} config.submissionInterval - Blocks between output submissions
+ * @param {number} config.finalizationPeriodSeconds - Challenge period in seconds
+ * @param {string} config.parentChainExplorer - Parent chain explorer URL
+ * @returns {Promise<object>} - The updated OP config
+ */
+router.put('/:id/opConfig', authMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const currentConfig = await db.getOpConfig(req.body.data.user.id, data.id);
+        if (!currentConfig)
+            return managedError(new Error('There is no OP config for this explorer.'), req, res);
+
+        let params = { ...req.body.params };
+
+        if (params.config.parentChainId) {
+            params.config.parentChainId = parseInt(params.config.parentChainId);
+        }
+
+        let config;
+        try {
+            config = await db.updateOpConfig(req.body.data.user.id, data.id, params.config);
+        } catch(error) {
+            return managedError(error, req, res);
+        }
+
+        res.status(200).json({ config });
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+/**
+ * Create OP Stack config
+ * @param {object} config - The OP config to create
+ * @param {number} config.parentChainId - Parent chain network ID (e.g., 1 for Ethereum mainnet)
+ * @param {string} config.batchInboxAddress - Batch inbox address
+ * @param {string} config.optimismPortalAddress - Optimism portal address
+ * @param {string} config.l2OutputOracleAddress - L2 output oracle address (legacy)
+ * @param {string} config.disputeGameFactoryAddress - Dispute game factory address (modern)
+ * @param {string} config.systemConfigAddress - System config address
+ * @param {string} config.l2ToL1MessagePasserAddress - L2 to L1 message passer address
+ * @param {number} config.outputVersion - Output version (0 = legacy, 1 = fault proofs)
+ * @param {number} config.submissionInterval - Blocks between output submissions
+ * @param {number} config.finalizationPeriodSeconds - Challenge period in seconds
+ * @param {string} config.parentChainExplorer - Parent chain explorer URL
+ * @returns {Promise<object>} - The created OP config
+ */
+router.post('/:id/opConfig', authMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const currentConfig = await db.getOpConfig(req.body.data.user.id, data.id);
+        if (currentConfig)
+            return managedError(new Error('There is already an OP config for this explorer.'), req, res);
+
+        if (!req.body.params.config.parentWorkspaceId && !req.body.params.config.parentChainId)
+            return managedError(new Error('Parent workspace is required.'), req, res);
+
+        if (!req.body.params.config.batchInboxAddress)
+            return managedError(new Error('Batch inbox address is required.'), req, res);
+
+        if (!req.body.params.config.optimismPortalAddress)
+            return managedError(new Error('Optimism portal address is required.'), req, res);
+
+        let configParams = { ...req.body.params.config };
+        if (configParams.parentChainId) {
+            configParams.parentChainId = parseInt(configParams.parentChainId);
+        }
+
+        let config;
+        try {
+            config = await db.createOpConfig(req.body.data.user.id, data.id, configParams);
+        } catch(error) {
+            return managedError(error, req, res);
+        }
+
+        res.status(200).json({ config });
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
 router.post('/:id/v2_dexes', authMiddleware, async (req, res, next) => {
     const data = req.body.data;
 
 
@@ -32,6 +32,10 @@ const caddy = require('./caddy');
 const orbitBatches = require('./orbitBatches');
 const orbitWithdrawals = require('./orbitWithdrawals');
 const orbitDeposits = require('./orbitDeposits');
+const opBatches = require('./opBatches');
+const opOutputs = require('./opOutputs');
+const opDeposits = require('./opDeposits');
+const opWithdrawals = require('./opWithdrawals');
 
 router.use('/blocks', blocks);
 router.use('/contracts', contracts);
@@ -58,6 +62,10 @@ router.use('/caddy', caddy);
 router.use('/orbitBatches', orbitBatches);
 router.use('/orbitWithdrawals', orbitWithdrawals);
 router.use('/orbitDeposits', orbitDeposits);
+router.use('/opBatches', opBatches);
+router.use('/opOutputs', opOutputs);
+router.use('/opDeposits', opDeposits);
+router.use('/opWithdrawals', opWithdrawals);
 
 if (isDemoEnabled()) {
     const demo = require('./demo');
 
@@ -0,0 +1,91 @@
+const express = require('express');
+const router = express.Router();
+const workspaceAuthMiddleware = require('../middlewares/workspaceAuth');
+const db = require('../lib/firebase');
+const { unmanagedError, managedError } = require('../lib/errors');
+const { sanitizePagination } = require('../lib/utils');
+
+/**
+ * Get paginated list of OP batches for a workspace
+ * @param {number} page - The page number
+ * @param {number} itemsPerPage - The number of items per page
+ * @param {string} order - The order to sort by
+ * @returns {Promise<Array>} - A list of OP batches
+ */
+router.get('/', workspaceAuthMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const { page, itemsPerPage, order } = sanitizePagination(data.page, data.itemsPerPage, data.order);
+        const { rows: items, count: total } = await db.getWorkspaceOpBatches(data.workspace.id, page, itemsPerPage, order);
+
+        res.status(200).json({ items, total });
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+/**
+ * Get detailed information for a specific OP batch
+ * @param {number} batchIndex - The batch index
+ * @returns {Promise<Object>} - The OP batch
+ */
+router.get('/:batchIndex', workspaceAuthMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const batch = await db.getOpBatch(data.workspace.id, data.batchIndex);
+
+        if (!batch) {
+            return res.status(404).json({ error: 'Batch not found' });
+        }
+
+        res.status(200).json(batch);
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+/**
+ * Get paginated list of L2 transactions for a specific OP batch
+ * @param {number} batchIndex - The batch index
+ * @param {number} page - The page number
+ * @param {number} itemsPerPage - The number of items per page
+ * @param {string} order - The order to sort by
+ * @returns {Promise<Array>} - A list of L2 transactions in the batch
+ */
+router.get('/:batchIndex/transactions', workspaceAuthMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const { page, itemsPerPage, order } = sanitizePagination(data.page, data.itemsPerPage, data.order);
+        const { total, items } = await db.getOpBatchTransactions(data.workspace.id, data.batchIndex, page, itemsPerPage, order);
+
+        res.status(200).json({ total, items });
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+/**
+ * Get paginated list of L2 blocks for a specific OP batch
+ * @param {number} batchIndex - The batch index
+ * @param {number} page - The page number
+ * @param {number} itemsPerPage - The number of items per page
+ * @param {string} order - The order to sort by
+ * @returns {Promise<Array>} - A list of L2 blocks in the batch
+ */
+router.get('/:batchIndex/blocks', workspaceAuthMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const { page, itemsPerPage, order } = sanitizePagination(data.page, data.itemsPerPage, data.order);
+        const { total, items } = await db.getOpBatchBlocks(data.workspace.id, data.batchIndex, page, itemsPerPage, order);
+
+        res.status(200).json({ total, items });
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+module.exports = router;
@@ -0,0 +1,49 @@
+const express = require('express');
+const router = express.Router();
+const workspaceAuthMiddleware = require('../middlewares/workspaceAuth');
+const db = require('../lib/firebase');
+const { unmanagedError } = require('../lib/errors');
+const { sanitizePagination } = require('../lib/utils');
+
+/**
+ * Get paginated list of OP deposits for a workspace
+ * @param {number} page - The page number
+ * @param {number} itemsPerPage - The number of items per page
+ * @param {string} order - The order to sort by
+ * @returns {Promise<Object>} - An object containing items (array of deposits) and total count
+ */
+router.get('/', workspaceAuthMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const { page, itemsPerPage, order } = sanitizePagination(data.page, data.itemsPerPage, data.order);
+        const { rows: items, count: total } = await db.getWorkspaceOpDeposits(data.workspace.id, page, itemsPerPage, order);
+
+        res.status(200).json({ items, total });
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+/**
+ * Get a specific OP deposit by L1 transaction hash
+ * @param {string} hash - The L1 transaction hash
+ * @returns {Promise<Object>} - The OP deposit
+ */
+router.get('/:hash', workspaceAuthMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const deposit = await db.getOpDepositByL1Hash(data.workspace.id, data.hash);
+
+        if (!deposit) {
+            return res.status(404).json({ error: 'Deposit not found' });
+        }
+
+        res.status(200).json(deposit);
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+module.exports = router;
@@ -0,0 +1,49 @@
+const express = require('express');
+const router = express.Router();
+const workspaceAuthMiddleware = require('../middlewares/workspaceAuth');
+const db = require('../lib/firebase');
+const { unmanagedError } = require('../lib/errors');
+const { sanitizePagination } = require('../lib/utils');
+
+/**
+ * Get paginated list of OP outputs for a workspace
+ * @param {number} page - The page number
+ * @param {number} itemsPerPage - The number of items per page
+ * @param {string} order - The order to sort by
+ * @returns {Promise<Array>} - A list of OP outputs
+ */
+router.get('/', workspaceAuthMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const { page, itemsPerPage, order } = sanitizePagination(data.page, data.itemsPerPage, data.order);
+        const { rows: items, count: total } = await db.getWorkspaceOpOutputs(data.workspace.id, page, itemsPerPage, order);
+
+        res.status(200).json({ items, total });
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+/**
+ * Get detailed information for a specific OP output
+ * @param {number} outputIndex - The output index
+ * @returns {Promise<Object>} - The OP output
+ */
+router.get('/:outputIndex', workspaceAuthMiddleware, async (req, res, next) => {
+    const data = { ...req.query, ...req.params };
+
+    try {
+        const output = await db.getOpOutput(data.workspace.id, data.outputIndex);
+
+        if (!output) {
+            return res.status(404).json({ error: 'Output not found' });
+        }
+
+        res.status(200).json(output);
+    } catch (error) {
+        unmanagedError(error, req, next);
+    }
+});
+
+module.exports = router;