@fileverse/api 0.0.1

package/dist/worker.js

@@ -0,0 +1,2846 @@
+// src/config/index.ts
+import dotenv from "dotenv";
+import path from "path";
+import fs from "fs";
+import os from "os";
+
+// src/cli/constants.generated.ts
+var STATIC_CONFIG = {
+  API_URL: "https://prod-apps-storage-5cdacc06ff79.herokuapp.com/",
+  SERVER_DID: "did:key:z6Mkroj9bxTin6Z5S9qwx2G2b87NPrCX7S85FhCpmBGPcDCz",
+  PROXY_SERVER_DID: "did:key:z6MkrZSmq8D6vQG87YbjUQatXeptaCCXWdTx8fYaWxWbRUHB",
+  NETWORK_NAME: "gnosis",
+  DEFAULT_PORT: "8001",
+  DEFAULT_RPC_URL: "https://rpc.gnosischain.com",
+  PIMLICO_PROXY_URL: "https://pimlico-proxy-0a326da116f8.herokuapp.com/",
+  SERVICE_NAME: "fileverse-api",
+  LOG_LEVEL: "info",
+  FRONTEND_URL: "https://docs.fileverse.io"
+};
+
+// src/config/index.ts
+var projectEnvPath = path.join(process.cwd(), "config", ".env");
+var userEnvPath = path.join(os.homedir(), ".fileverse", ".env");
+function getEnvPath() {
+  if (fs.existsSync(projectEnvPath)) {
+    return projectEnvPath;
+  }
+  return userEnvPath;
+}
+function loadConfig(override = true) {
+  const envPath = getEnvPath();
+  dotenv.config({ path: envPath, override });
+}
+loadConfig(false);
+function getRuntimeConfig() {
+  return {
+    get API_KEY() {
+      return process.env.API_KEY;
+    },
+    get RPC_URL() {
+      return process.env.RPC_URL || STATIC_CONFIG.DEFAULT_RPC_URL;
+    },
+    get DB_PATH() {
+      return process.env.DB_PATH;
+    },
+    get PORT() {
+      return process.env.PORT || STATIC_CONFIG.DEFAULT_PORT;
+    },
+    get NODE_ENV() {
+      return process.env.NODE_ENV || "production";
+    },
+    get FRONTEND_URL() {
+      return process.env.FRONTEND_URL || STATIC_CONFIG.FRONTEND_URL;
+    }
+  };
+}
+function validateDbPath() {
+  const dbPath = process.env.DB_PATH;
+  if (!dbPath) {
+    console.error("Error: DB_PATH environment variable is required");
+    console.error("Please set DB_PATH in your .env file (config/.env or ~/.fileverse/.env) or run the CLI first");
+    process.exit(1);
+  }
+  const dbDir = path.dirname(dbPath.trim());
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true });
+  }
+}
+var config = {
+  ...STATIC_CONFIG,
+  get SERVICE_NAME() {
+    return STATIC_CONFIG.SERVICE_NAME;
+  },
+  get LOG_LEVEL() {
+    return STATIC_CONFIG.LOG_LEVEL;
+  },
+  get NETWORK_NAME() {
+    return STATIC_CONFIG.NETWORK_NAME;
+  },
+  get UPLOAD_SERVER_URL() {
+    return STATIC_CONFIG.API_URL;
+  },
+  get UPLOAD_SERVER_DID() {
+    return STATIC_CONFIG.SERVER_DID;
+  },
+  get API_KEY() {
+    return process.env.API_KEY;
+  },
+  get RPC_URL() {
+    return process.env.RPC_URL || STATIC_CONFIG.DEFAULT_RPC_URL;
+  },
+  get DB_PATH() {
+    return process.env.DB_PATH;
+  },
+  get PORT() {
+    return process.env.PORT || STATIC_CONFIG.DEFAULT_PORT;
+  },
+  get NODE_ENV() {
+    return process.env.NODE_ENV || "production";
+  },
+  get IP() {
+    return process.env.IP || "0.0.0.0";
+  },
+  get FRONTEND_URL() {
+    return process.env.FRONTEND_URL || STATIC_CONFIG.FRONTEND_URL;
+  }
+};
+
+// src/infra/logger.ts
+import pino from "pino";
+var isProduction = config.NODE_ENV === "production";
+var pinoInstance = pino({
+  name: STATIC_CONFIG.SERVICE_NAME,
+  level: STATIC_CONFIG.LOG_LEVEL,
+  formatters: {
+    bindings: (bindings) => ({ name: bindings.name }),
+    level: (label) => ({ level: label })
+  },
+  serializers: {
+    err(err) {
+      if (!err) return err;
+      if (isProduction) {
+        return { type: err.name, message: err.message };
+      }
+      return {
+        type: err.name,
+        message: err.message,
+        stack: err.stack
+      };
+    }
+  },
+  transport: config.NODE_ENV !== "production" ? {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname",
+      errorProps: "*",
+      errorLikeObjectKeys: ["err", "error"]
+    }
+  } : void 0
+});
+var createLogMethod = (level) => {
+  return (...args) => {
+    const [first, ...rest] = args;
+    const log = pinoInstance[level].bind(pinoInstance);
+    if (typeof first === "object" && first !== null && !(first instanceof Error)) {
+      log(first, ...rest);
+      return;
+    }
+    if (rest.length > 0) {
+      const last = rest[rest.length - 1];
+      if (last instanceof Error) {
+        log({ err: last }, first, ...rest.slice(0, -1));
+        return;
+      }
+    }
+    if (first instanceof Error) {
+      log({ err: first }, first.message);
+      return;
+    }
+    log(first, ...rest);
+  };
+};
+var logger = {
+  trace: createLogMethod("trace"),
+  debug: createLogMethod("debug"),
+  info: createLogMethod("info"),
+  warn: createLogMethod("warn"),
+  error: createLogMethod("error"),
+  fatal: createLogMethod("fatal"),
+  get level() {
+    return pinoInstance.level;
+  },
+  set level(lvl) {
+    pinoInstance.level = lvl;
+  },
+  child: pinoInstance.child.bind(pinoInstance)
+};
+
+// src/infra/database/connection.ts
+import Database from "better-sqlite3";
+var DatabaseConnectionManager = class _DatabaseConnectionManager {
+  static instance;
+  db = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_DatabaseConnectionManager.instance) {
+      _DatabaseConnectionManager.instance = new _DatabaseConnectionManager();
+    }
+    return _DatabaseConnectionManager.instance;
+  }
+  getConnection() {
+    if (!this.db) {
+      const dbPath = config.DB_PATH;
+      this.db = new Database(dbPath, {
+        verbose: config.NODE_ENV === "development" ? (msg) => logger.debug(String(msg)) : void 0
+      });
+      this.db.pragma("journal_mode = WAL");
+      this.db.pragma("foreign_keys = ON");
+      this.db.prepare("SELECT 1").get();
+      logger.info(`SQLite database connected: ${dbPath}`);
+    }
+    return this.db;
+  }
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      logger.info("Database connection closed");
+    }
+  }
+  isConnected() {
+    return this.db !== null && this.db.open;
+  }
+};
+var databaseConnectionManager = DatabaseConnectionManager.getInstance();
+
+// src/domain/file/constants.ts
+var DEFAULT_LIST_LIMIT = 10;
+
+// src/infra/database/query-builder.ts
+function getDb() {
+  return databaseConnectionManager.getConnection();
+}
+var QueryBuilder = class {
+  static select(sql, params = []) {
+    const stmt = getDb().prepare(sql);
+    return stmt.all(params);
+  }
+  static selectOne(sql, params = []) {
+    const stmt = getDb().prepare(sql);
+    return stmt.get(params);
+  }
+  static execute(sql, params = []) {
+    const stmt = getDb().prepare(sql);
+    const result = stmt.run(params);
+    return {
+      changes: result.changes,
+      lastInsertRowid: result.lastInsertRowid
+    };
+  }
+  static transaction(callback) {
+    return getDb().transaction(callback)();
+  }
+  static paginate(sql, options = {}) {
+    let query = sql;
+    if (options.orderBy) {
+      query += ` ORDER BY ${options.orderBy} ${options.orderDirection || "ASC"}`;
+    }
+    const hasOffset = (options.offset ?? 0) > 0;
+    const limit = options.limit ?? (hasOffset ? DEFAULT_LIST_LIMIT : void 0);
+    if (limit) {
+      query += ` LIMIT ${limit}`;
+    }
+    if (hasOffset) {
+      query += ` OFFSET ${options.offset}`;
+    }
+    return query;
+  }
+};
+
+// src/infra/database/index.ts
+function getDb2() {
+  return databaseConnectionManager.getConnection();
+}
+var database_default = getDb2;
+
+// src/infra/database/models/files.model.ts
+import { uuidv7 } from "uuidv7";
+var FilesModel = class {
+  static TABLE = "files";
+  static parseFile(fileRaw) {
+    let metadata = {};
+    try {
+      if (fileRaw.metadata) {
+        metadata = typeof fileRaw.metadata === "string" ? JSON.parse(fileRaw.metadata) : fileRaw.metadata;
+      }
+    } catch (e) {
+      metadata = {};
+    }
+    return {
+      _id: fileRaw._id,
+      ddocId: fileRaw.ddocId,
+      title: fileRaw.title,
+      content: fileRaw.content,
+      localVersion: fileRaw.localVersion,
+      onchainVersion: fileRaw.onchainVersion,
+      syncStatus: fileRaw.syncStatus,
+      isDeleted: fileRaw.isDeleted,
+      onChainFileId: fileRaw.onChainFileId ?? null,
+      portalAddress: fileRaw.portalAddress,
+      metadata: metadata || {},
+      createdAt: fileRaw.createdAt,
+      updatedAt: fileRaw.updatedAt,
+      linkKey: fileRaw.linkKey,
+      linkKeyNonce: fileRaw.linkKeyNonce,
+      commentKey: fileRaw.commentKey,
+      link: fileRaw.link
+    };
+  }
+  static findAll(portalAddress, limit, skip) {
+    const whereClause = "isDeleted = 0 AND portalAddress = ?";
+    const params = [portalAddress];
+    const countSql = `
+      SELECT COUNT(*) as count 
+      FROM ${this.TABLE} 
+      WHERE ${whereClause}
+    `;
+    const totalResult = QueryBuilder.selectOne(countSql, params);
+    const total = totalResult?.count || 0;
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE}
+      WHERE ${whereClause}
+    `;
+    const completeSql = QueryBuilder.paginate(sql, {
+      limit,
+      offset: skip,
+      orderBy: "createdAt",
+      orderDirection: "DESC"
+    });
+    const filesRaw = QueryBuilder.select(completeSql, params);
+    const files = filesRaw.map(this.parseFile);
+    const hasNext = skip !== void 0 && limit !== void 0 ? skip + limit < total : false;
+    return { files, total, hasNext };
+  }
+  static findById(_id, portalAddress) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE _id = ? AND isDeleted = 0 AND portalAddress = ?
+    `;
+    const result = QueryBuilder.selectOne(sql, [_id, portalAddress]);
+    return result ? this.parseFile(result) : void 0;
+  }
+  static findByIdIncludingDeleted(_id) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE _id = ?
+    `;
+    const result = QueryBuilder.selectOne(sql, [_id]);
+    return result ? this.parseFile(result) : void 0;
+  }
+  static findByIdExcludingDeleted(_id) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE _id = ? AND isDeleted = 0
+    `;
+    const result = QueryBuilder.selectOne(sql, [_id]);
+    return result ? this.parseFile(result) : void 0;
+  }
+  static findByDDocId(ddocId, portalAddress) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE ddocId = ? AND isDeleted = 0 AND portalAddress = ?
+    `;
+    const result = QueryBuilder.selectOne(sql, [ddocId, portalAddress]);
+    return result ? this.parseFile(result) : void 0;
+  }
+  static searchByTitle(searchTerm, portalAddress, limit, skip) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE LOWER(title) LIKE LOWER(?) AND isDeleted = 0 AND portalAddress = ?
+    `;
+    const completeSql = QueryBuilder.paginate(sql, {
+      limit,
+      offset: skip,
+      orderBy: "createdAt",
+      orderDirection: "DESC"
+    });
+    const filesRaw = QueryBuilder.select(completeSql, [`%${searchTerm}%`, portalAddress]);
+    return filesRaw.map(this.parseFile);
+  }
+  static create(input) {
+    const _id = uuidv7();
+    const sql = `
+      INSERT INTO ${this.TABLE} 
+      (_id, title, content, ddocId, portalAddress) 
+      VALUES (?, ?, ?, ?, ?)
+    `;
+    QueryBuilder.execute(sql, [_id, input.title, input.content, input.ddocId, input.portalAddress]);
+    const created = this.findById(_id, input.portalAddress);
+    if (!created) {
+      throw new Error("Failed to create file");
+    }
+    return created;
+  }
+  static update(_id, payload, portalAddress) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const keys = [];
+    const values = [];
+    for (const [k, v] of Object.entries(payload)) {
+      if (v !== void 0) {
+        if (k === "metadata" && typeof v === "object") {
+          keys.push(`${k} = ?`);
+          values.push(JSON.stringify(v));
+        } else {
+          keys.push(`${k} = ?`);
+          values.push(v);
+        }
+      }
+    }
+    keys.push("updatedAt = ?");
+    values.push(now, _id, portalAddress);
+    const updateChain = keys.join(", ");
+    const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE _id = ? AND portalAddress = ?`;
+    QueryBuilder.execute(sql, values);
+    const updated = this.findById(_id, portalAddress);
+    if (!updated) {
+      throw new Error("Failed to update file");
+    }
+    return updated;
+  }
+  static softDelete(_id) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sql = `
+      UPDATE ${this.TABLE} 
+      SET isDeleted = 1, syncStatus = 'pending', updatedAt = ?
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [now, _id]);
+    const deleted = this.findByIdIncludingDeleted(_id);
+    if (!deleted) {
+      throw new Error("Failed to delete file");
+    }
+    return deleted;
+  }
+};
+
+// src/infra/database/models/portals.model.ts
+import { uuidv7 as uuidv72 } from "uuidv7";
+var PortalsModel = class {
+  static TABLE = "portals";
+  static findByPortalAddress(portalAddress) {
+    const sql = `SELECT _id, portalAddress, portalSeed, ownerAddress, createdAt, updatedAt FROM ${this.TABLE} WHERE portalAddress = ?`;
+    return QueryBuilder.selectOne(sql, [portalAddress]);
+  }
+  static create(input) {
+    const _id = uuidv72();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sql = `INSERT INTO ${this.TABLE} (_id, portalAddress, portalSeed, ownerAddress, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?)`;
+    QueryBuilder.execute(sql, [_id, input.portalAddress, input.portalSeed, input.ownerAddress, now, now]);
+    const created = this.findByPortalAddress(input.portalAddress);
+    if (!created) {
+      throw new Error("Failed to create portal");
+    }
+    return created;
+  }
+  static update(portalAddress, input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const keys = [];
+    const values = [];
+    for (const [k, v] of Object.entries(input)) {
+      if (v !== void 0) {
+        keys.push(`${k} = ?`);
+        values.push(v);
+      }
+    }
+    keys.push("updatedAt = ?");
+    values.push(now);
+    const updateChain = keys.join(", ");
+    const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE portalAddress = ?`;
+    values.push(portalAddress);
+    QueryBuilder.execute(sql, values);
+    const updated = this.findByPortalAddress(portalAddress);
+    if (!updated) {
+      throw new Error("Failed to update portal");
+    }
+    return updated;
+  }
+  static upsert(input) {
+    const existing = this.findByPortalAddress(input.portalAddress);
+    if (existing) {
+      return this.update(input.portalAddress, {
+        portalSeed: input.portalSeed,
+        ownerAddress: input.ownerAddress
+      });
+    }
+    return this.create(input);
+  }
+};
+
+// src/infra/database/models/apikeys.model.ts
+import { uuidv7 as uuidv73 } from "uuidv7";
+
+// src/infra/database/models/events.model.ts
+import { uuidv7 as uuidv74 } from "uuidv7";
+
+// src/infra/worker/workerSignal.ts
+import { EventEmitter } from "events";
+var WorkerSignal = class extends EventEmitter {
+};
+var workerSignal = new WorkerSignal();
+workerSignal.setMaxListeners(20);
+function notifyNewEvent() {
+  workerSignal.emit("newEvent");
+}
+function onNewEvent(callback) {
+  workerSignal.on("newEvent", callback);
+  return () => workerSignal.off("newEvent", callback);
+}
+
+// src/infra/database/models/events.model.ts
+var RETRY_DELAYS_MS = [5e3, 3e4, 12e4];
+var EventsModel = class {
+  static TABLE = "events";
+  static create(input) {
+    const _id = uuidv74();
+    const timestamp = Date.now();
+    const status = "pending";
+    const sql = `
+      INSERT INTO ${this.TABLE} 
+      (_id, type, timestamp, fileId, portalAddress, status, retryCount, lastError, lockedAt, nextRetryAt) 
+      VALUES (?, ?, ?, ?, ?, ?, 0, NULL, NULL, NULL)
+    `;
+    QueryBuilder.execute(sql, [_id, input.type, timestamp, input.fileId, input.portalAddress, status]);
+    notifyNewEvent();
+    return {
+      _id,
+      type: input.type,
+      timestamp,
+      fileId: input.fileId,
+      portalAddress: input.portalAddress,
+      status,
+      retryCount: 0,
+      lastError: null,
+      lockedAt: null,
+      nextRetryAt: null
+    };
+  }
+  static findById(_id) {
+    const sql = `SELECT * FROM ${this.TABLE} WHERE _id = ?`;
+    const row = QueryBuilder.selectOne(sql, [_id]);
+    return row ? this.parseEvent(row) : void 0;
+  }
+  static findNextPending() {
+    const sql = `
+      SELECT * FROM ${this.TABLE}
+      WHERE status = 'pending'
+      ORDER BY timestamp ASC
+      LIMIT 1
+    `;
+    const row = QueryBuilder.selectOne(sql, []);
+    return row ? this.parseEvent(row) : void 0;
+  }
+  static findNextEligible(lockedFileIds) {
+    const now = Date.now();
+    const exclusionClause = lockedFileIds.length > 0 ? `AND e1.fileId NOT IN (${lockedFileIds.map(() => "?").join(", ")})` : "";
+    const sql = `
+      SELECT e1.* FROM ${this.TABLE} e1
+      WHERE e1.status = 'pending'
+      AND (e1.nextRetryAt IS NULL OR e1.nextRetryAt <= ?)
+      ${exclusionClause}
+      AND NOT EXISTS (
+        SELECT 1 FROM ${this.TABLE} e2
+        WHERE e2.fileId = e1.fileId
+        AND e2.status = 'pending'
+        AND e2.timestamp < e1.timestamp
+      )
+      ORDER BY e1.timestamp ASC
+      LIMIT 1
+    `;
+    const params = [now, ...lockedFileIds];
+    const row = QueryBuilder.selectOne(sql, params);
+    return row ? this.parseEvent(row) : void 0;
+  }
+  static markProcessing(_id) {
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'processing',
+          lockedAt = ?
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [Date.now(), _id]);
+  }
+  static markProcessed(_id) {
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'processed',
+          lockedAt = NULL
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [_id]);
+  }
+  static scheduleRetry(_id, errorMsg) {
+    const event = this.findById(_id);
+    if (!event) return;
+    const delay = RETRY_DELAYS_MS[Math.min(event.retryCount, RETRY_DELAYS_MS.length - 1)];
+    const nextRetryAt = Date.now() + delay;
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          retryCount = retryCount + 1,
+          lastError = ?,
+          nextRetryAt = ?,
+          lockedAt = NULL
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+  }
+  static scheduleRetryAfter(_id, errorMsg, retryAfterMs) {
+    const nextRetryAt = Date.now() + retryAfterMs;
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          lastError = ?,
+          nextRetryAt = ?,
+          lockedAt = NULL
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+  }
+  static markFailed(_id, errorMsg) {
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'failed',
+          lastError = ?,
+          lockedAt = NULL
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [errorMsg, _id]);
+  }
+  static listFailed(portalAddress) {
+    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+    const sql = `
+      SELECT * FROM ${this.TABLE}
+      WHERE status = 'failed'
+      ${portalClause}
+      ORDER BY timestamp ASC
+    `;
+    const params = portalAddress != null ? [portalAddress] : [];
+    const rows = QueryBuilder.select(sql, params);
+    return rows.map((row) => this.parseEvent(row));
+  }
+  static resetFailedToPending(_id, portalAddress) {
+    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          retryCount = 0,
+          lastError = NULL,
+          nextRetryAt = NULL,
+          lockedAt = NULL
+      WHERE _id = ?
+      AND status = 'failed'
+      ${portalClause}
+    `;
+    const params = portalAddress != null ? [_id, portalAddress] : [_id];
+    const result = QueryBuilder.execute(sql, params);
+    if (result.changes > 0) {
+      notifyNewEvent();
+    }
+    return result.changes > 0;
+  }
+  static resetAllFailedToPending(portalAddress) {
+    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          retryCount = 0,
+          lastError = NULL,
+          nextRetryAt = NULL,
+          lockedAt = NULL
+      WHERE status = 'failed'
+      ${portalClause}
+    `;
+    const params = portalAddress != null ? [portalAddress] : [];
+    const result = QueryBuilder.execute(sql, params);
+    if (result.changes > 0) {
+      notifyNewEvent();
+    }
+    return result.changes;
+  }
+  static resetStaleEvents(staleThreshold) {
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          lockedAt = NULL,
+          userOpHash = NULL,
+          pendingPayload = NULL
+      WHERE status = 'processing'
+      AND lockedAt IS NOT NULL
+      AND lockedAt < ?
+    `;
+    const result = QueryBuilder.execute(sql, [staleThreshold]);
+    return result.changes;
+  }
+  static setEventPendingOp(_id, userOpHash, payload) {
+    const sql = `UPDATE ${this.TABLE} SET userOpHash = ?, pendingPayload = ? WHERE _id = ?`;
+    QueryBuilder.execute(sql, [userOpHash, JSON.stringify(payload), _id]);
+  }
+  static clearEventPendingOp(_id) {
+    const sql = `UPDATE ${this.TABLE} SET userOpHash = NULL, pendingPayload = NULL WHERE _id = ?`;
+    QueryBuilder.execute(sql, [_id]);
+  }
+  static parseEvent(row) {
+    return {
+      _id: row._id,
+      type: row.type,
+      timestamp: row.timestamp,
+      fileId: row.fileId,
+      portalAddress: row.portalAddress ?? "",
+      status: row.status,
+      retryCount: row.retryCount,
+      lastError: row.lastError,
+      lockedAt: row.lockedAt,
+      nextRetryAt: row.nextRetryAt,
+      userOpHash: row.userOpHash ?? null,
+      pendingPayload: row.pendingPayload ?? null
+    };
+  }
+};
+
+// src/sdk/key-store.ts
+import { eciesDecrypt, eciesEncrypt, generateECKeyPair } from "@fileverse/crypto/ecies";
+var KeyStore = class {
+  constructor(seed, address, authTokenProvider) {
+    this.authTokenProvider = authTokenProvider;
+    this.portalKeySeed = seed;
+    this.portalAddress = address;
+    this.authTokenProvider = authTokenProvider;
+  }
+  portalKeySeed;
+  portalAddress;
+  getPortalAddress() {
+    if (!this.portalAddress) {
+      throw new Error("Portal address is not set");
+    }
+    return this.portalAddress;
+  }
+  getAppEncryptionKey() {
+    if (!this.portalKeySeed) {
+      throw new Error("Portal key seed is not set");
+    }
+    const keyPair = generateECKeyPair(this.portalKeySeed);
+    return keyPair.publicKey;
+  }
+  getAppDecryptionKey() {
+    if (!this.portalKeySeed) {
+      throw new Error("Portal key seed is not set");
+    }
+    const keyPair = generateECKeyPair(this.portalKeySeed);
+    return keyPair.privateKey;
+  }
+  encryptData(data) {
+    return eciesEncrypt(this.getAppEncryptionKey(), data);
+  }
+  decryptData(data) {
+    return eciesDecrypt(this.getAppDecryptionKey(), data);
+  }
+  getAuthToken(audienceDid) {
+    return this.authTokenProvider.getAuthToken(audienceDid);
+  }
+};
+
+// src/sdk/auth-token-provider.ts
+import * as ucans from "@ucans/ucans";
+var AuthTokenProvider = class {
+  DEFAULT_OPTIONS = {
+    namespace: "file",
+    segment: "CREATE",
+    scheme: "storage"
+  };
+  keyPair;
+  portalAddress;
+  constructor(keyPair, portalAddress) {
+    this.keyPair = keyPair;
+    this.portalAddress = portalAddress;
+  }
+  async getAuthToken(audienceDid, options = this.DEFAULT_OPTIONS) {
+    const ucan = await ucans.build({
+      audience: audienceDid,
+      issuer: this.keyPair,
+      lifetimeInSeconds: 7 * 86400,
+      capabilities: [
+        {
+          with: {
+            scheme: options.scheme,
+            hierPart: this.portalAddress.toLocaleLowerCase()
+          },
+          can: { namespace: options.namespace, segments: [options.segment] }
+        }
+      ]
+    });
+    return ucans.encode(ucan);
+  }
+};
+
+// src/domain/portal/publish.ts
+import { fromUint8Array as fromUint8Array3, toUint8Array as toUint8Array3 } from "js-base64";
+import { stringToBytes } from "viem";
+import { deriveHKDFKey } from "@fileverse/crypto/kdf";
+import { generateKeyPairFromSeed } from "@stablelib/ed25519";
+import * as ucans2 from "@ucans/ucans";
+
+// src/sdk/smart-agent.ts
+import { toHex as toHex2 } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/sdk/pimlico-utils.ts
+import { createPublicClient, http, hexToBigInt, toHex, toBytes } from "viem";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import { createSmartAccountClient } from "permissionless";
+import { toSafeSmartAccount } from "permissionless/accounts";
+import { entryPoint07Address } from "viem/account-abstraction";
+
+// src/constants/chains.ts
+import { sepolia, gnosis } from "viem/chains";
+
+// src/constants/events.ts
+var ADDED_FILE_EVENT = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "fileId",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "appFileId",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "enum FileverseApp.FileType",
+        name: "fileType",
+        type: "uint8"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "metadataIPFSHash",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "contentIPFSHash",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "gateIPFSHash",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "version",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "by",
+        type: "address"
+      }
+    ],
+    name: "AddedFile",
+    type: "event"
+  }
+];
+var EDITED_FILE_EVENT = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "fileId",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "appFileId",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "enum FileverseApp.FileType",
+        name: "fileType",
+        type: "uint8"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "metadataIPFSHash",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "contentIPFSHash",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "gateIPFSHash",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "version",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "by",
+        type: "address"
+      }
+    ],
+    name: "EditedFile",
+    type: "event"
+  }
+];
+var DELETED_FILE_EVENT = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "fileId",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "appFileId",
+        type: "string"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "by",
+        type: "address"
+      }
+    ],
+    name: "DeletedFile",
+    type: "event"
+  }
+];
+
+// src/constants/methods.ts
+var ADD_FILE_METHOD = [
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_appFileId",
+        type: "string"
+      },
+      {
+        internalType: "enum FileverseApp.FileType",
+        name: "fileType",
+        type: "uint8"
+      },
+      {
+        internalType: "string",
+        name: "_metadataIPFSHash",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "_contentIPFSHash",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "_gateIPFSHash",
+        type: "string"
+      },
+      {
+        internalType: "uint256",
+        name: "version",
+        type: "uint256"
+      }
+    ],
+    name: "addFile",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var EDIT_FILE_METHOD = [
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "fileId",
+        type: "uint256"
+      },
+      {
+        internalType: "string",
+        name: "_appFileId",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "_metadataIPFSHash",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "_contentIPFSHash",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "_gateIPFSHash",
+        type: "string"
+      },
+      {
+        internalType: "enum FileverseApp.FileType",
+        name: "fileType",
+        type: "uint8"
+      },
+      {
+        internalType: "uint256",
+        name: "version",
+        type: "uint256"
+      }
+    ],
+    name: "editFile",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var DELETED_FILE_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "fileId",
+        type: "uint256"
+      }
+    ],
+    name: "deleteFile",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/constants/index.ts
+var NETWORK_NAME = STATIC_CONFIG.NETWORK_NAME;
+var UPLOAD_SERVER_URL = STATIC_CONFIG.API_URL;
+var getRpcUrl = () => getRuntimeConfig().RPC_URL;
+var getPimlicoUrl = () => `${STATIC_CONFIG.PIMLICO_PROXY_URL}api/${NETWORK_NAME}/rpc`;
+var CHAIN_MAP = {
+  gnosis,
+  sepolia
+};
+var CHAIN = CHAIN_MAP[NETWORK_NAME];
+
+// src/sdk/pimlico-utils.ts
+import { generatePrivateKey } from "viem/accounts";
+var getPublicClient = () => createPublicClient({
+  transport: http(getRpcUrl(), {
+    retryCount: 0
+  }),
+  chain: CHAIN
+});
+var getPimlicoClient = (authToken, portalAddress, invokerAddress) => createPimlicoClient({
+  transport: http(getPimlicoUrl(), {
+    retryCount: 0,
+    fetchOptions: {
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        contract: portalAddress,
+        invoker: invokerAddress
+      }
+    }
+  }),
+  entryPoint: {
+    address: entryPoint07Address,
+    version: "0.7"
+  }
+});
+var signerToSmartAccount = async (signer) => await toSafeSmartAccount({
+  client: getPublicClient(),
+  owners: [signer],
+  entryPoint: {
+    address: entryPoint07Address,
+    version: "0.7"
+  },
+  version: "1.4.1"
+});
+var getSmartAccountClient = async (signer, authToken, portalAddress) => {
+  const smartAccount = await signerToSmartAccount(signer);
+  const pimlicoClient = getPimlicoClient(authToken, portalAddress, smartAccount.address);
+  return createSmartAccountClient({
+    account: smartAccount,
+    chain: CHAIN,
+    paymaster: pimlicoClient,
+    bundlerTransport: http(getPimlicoUrl(), {
+      fetchOptions: {
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          contract: portalAddress,
+          invoker: smartAccount.address
+        }
+      },
+      retryCount: 0
+    }),
+    userOperation: {
+      estimateFeesPerGas: async () => (await pimlicoClient.getUserOperationGasPrice()).fast
+    }
+  });
+};
+var getNonce = () => hexToBigInt(
+  toHex(toBytes(generatePrivateKey()).slice(0, 24), {
+    size: 32
+  })
+);
+var waitForUserOpReceipt = async (hash, authToken, portalAddress, invokerAddress, timeout = 12e4) => {
+  const pimlicoClient = getPimlicoClient(authToken, portalAddress, invokerAddress);
+  return pimlicoClient.waitForUserOperationReceipt({
+    hash,
+    timeout
+  });
+};
+
+// src/sdk/smart-agent.ts
+var AgentClient = class {
+  constructor(authTokenProvider) {
+    this.authTokenProvider = authTokenProvider;
+    this.authTokenProvider = authTokenProvider;
+  }
+  smartAccountAgent = null;
+  MAX_CALL_GAS_LIMIT = 5e5;
+  authOptions = { namespace: "proxy", segment: "ACCESS", scheme: "pimlico" };
+  async initializeAgentClient(keyMaterial) {
+    const agentAccount = privateKeyToAccount(toHex2(keyMaterial));
+    const authToken = await this.authTokenProvider.getAuthToken(STATIC_CONFIG.PROXY_SERVER_DID, this.authOptions);
+    const smartAccountClient = await getSmartAccountClient(
+      agentAccount,
+      authToken,
+      this.authTokenProvider.portalAddress
+    );
+    this.smartAccountAgent = smartAccountClient;
+  }
+  getSmartAccountAgent() {
+    if (!this.smartAccountAgent) throw new Error("Agent client not initialized");
+    return this.smartAccountAgent;
+  }
+  getAgentAddress() {
+    const smartAccountAgent = this.getSmartAccountAgent();
+    if (!smartAccountAgent.account) throw new Error("Agent account not found");
+    return smartAccountAgent.account.address;
+  }
+  getAgentAccount() {
+    const smartAccountAgent = this.getSmartAccountAgent();
+    if (!smartAccountAgent.account) throw new Error("Agent account not found");
+    return smartAccountAgent.account;
+  }
+  destroyAgentClient() {
+    this.smartAccountAgent = null;
+  }
+  async getCallData(request) {
+    const agentAccount = this.getAgentAccount();
+    if (Array.isArray(request)) {
+      if (request.length === 0 || request.length > 10) throw new Error("Request length must be between 1 and 10");
+      const encodedCallData = request.map((req) => ({
+        to: req.contractAddress,
+        data: req.data,
+        value: BigInt(0)
+      }));
+      return await agentAccount.encodeCalls(encodedCallData);
+    }
+    return await agentAccount.encodeCalls([
+      {
+        to: request.contractAddress,
+        data: request.data,
+        value: BigInt(0)
+      }
+    ]);
+  }
+  async sendUserOperation(request, customGasLimit) {
+    try {
+      const smartAccountAgent = this.getSmartAccountAgent();
+      const callData = await this.getCallData(request);
+      return await smartAccountAgent.sendUserOperation({
+        callData,
+        callGasLimit: BigInt(customGasLimit || this.MAX_CALL_GAS_LIMIT),
+        nonce: getNonce()
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  async executeUserOperationRequest(request, timeout, customGasLimit) {
+    const userOpHash = await this.sendUserOperation(request, customGasLimit);
+    const { authToken, portalAddress, invokerAddress } = await this.getAuthParams();
+    const receipt = await waitForUserOpReceipt(userOpHash, authToken, portalAddress, invokerAddress, timeout);
+    if (!receipt.success) throw new Error(`Failed to execute user operation: ${receipt.reason}`);
+    return receipt;
+  }
+  async getAuthParams() {
+    const authToken = await this.authTokenProvider.getAuthToken(STATIC_CONFIG.PROXY_SERVER_DID, this.authOptions);
+    return {
+      authToken,
+      portalAddress: this.authTokenProvider.portalAddress,
+      invokerAddress: this.getAgentAddress()
+    };
+  }
+};
+
+// src/sdk/file-manager.ts
+import { fromUint8Array as fromUint8Array2, toUint8Array as toUint8Array2 } from "js-base64";
+
+// src/sdk/file-utils.ts
+import { getArgon2idHash } from "@fileverse/crypto/argon";
+import { bytesToBase64, generateRandomBytes as generateRandomBytes2 } from "@fileverse/crypto/utils";
+import { derivePBKDF2Key, encryptAesCBC } from "@fileverse/crypto/kdf";
+import { secretBoxEncrypt } from "@fileverse/crypto/nacl";
+import hkdf from "futoin-hkdf";
+import tweetnacl from "tweetnacl";
+import { fromUint8Array, toUint8Array } from "js-base64";
+
+// node_modules/@noble/ciphers/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abool(b) {
+  if (typeof b !== "boolean")
+    throw new Error(`boolean expected, not ${b}`);
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u8(arr) {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes(key, void 0, "key");
+    if (!isLE)
+      throw new Error("Non little-endian hardware is not yet supported");
+    if (params.nonceLength !== void 0) {
+      const nonce = args[0];
+      abytes(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
+    }
+    const tagl = params.tagLength;
+    if (tagl && args[1] !== void 0)
+      abytes(args[1], void 0, "AAD");
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== void 0) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output, void 0, "output");
+      }
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data);
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data);
+        if (tagl && data.length < tagl)
+          throw new Error('"ciphertext" expected length bigger than tagLength=' + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
+  }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === void 0)
+    return new Uint8Array(expectedLength);
+  if (out.length !== expectedLength)
+    throw new Error('"output" expected Uint8Array of length ' + expectedLength + ", got: " + out.length);
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function u64Lengths(dataLength, aadLength, isLE2) {
+  abool(isLE2);
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  view.setBigUint64(0, BigInt(aadLength), isLE2);
+  view.setBigUint64(8, BigInt(dataLength), isLE2);
+  return num;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+
+// node_modules/@noble/ciphers/_polyval.js
+var BLOCK_SIZE = 16;
+var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+var ZEROS32 = u32(ZEROS16);
+var POLY = 225;
+var mul2 = (s0, s1, s2, s3) => {
+  const hiBit = s3 & 1;
+  return {
+    s3: s2 << 31 | s3 >>> 1,
+    s2: s1 << 31 | s2 >>> 1,
+    s1: s0 << 31 | s1 >>> 1,
+    s0: s0 >>> 1 ^ POLY << 24 & -(hiBit & 1)
+    // reduce % poly
+  };
+};
+var swapLE = (n) => (n >>> 0 & 255) << 24 | (n >>> 8 & 255) << 16 | (n >>> 16 & 255) << 8 | n >>> 24 & 255 | 0;
+function _toGHASHKey(k) {
+  k.reverse();
+  const hiBit = k[15] & 1;
+  let carry = 0;
+  for (let i = 0; i < k.length; i++) {
+    const t = k[i];
+    k[i] = t >>> 1 | carry;
+    carry = (t & 1) << 7;
+  }
+  k[0] ^= -hiBit & 225;
+  return k;
+}
+var estimateWindow = (bytes) => {
+  if (bytes > 64 * 1024)
+    return 8;
+  if (bytes > 1024)
+    return 4;
+  return 2;
+};
+var GHASH = class {
+  blockLen = BLOCK_SIZE;
+  outputLen = BLOCK_SIZE;
+  s0 = 0;
+  s1 = 0;
+  s2 = 0;
+  s3 = 0;
+  finished = false;
+  t;
+  W;
+  windowSize;
+  // We select bits per window adaptively based on expectedLength
+  constructor(key, expectedLength) {
+    abytes(key, 16, "key");
+    key = copyBytes(key);
+    const kView = createView(key);
+    let k0 = kView.getUint32(0, false);
+    let k1 = kView.getUint32(4, false);
+    let k2 = kView.getUint32(8, false);
+    let k3 = kView.getUint32(12, false);
+    const doubles = [];
+    for (let i = 0; i < 128; i++) {
+      doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });
+      ({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2(k0, k1, k2, k3));
+    }
+    const W = estimateWindow(expectedLength || 1024);
+    if (![1, 2, 4, 8].includes(W))
+      throw new Error("ghash: invalid window size, expected 2, 4 or 8");
+    this.W = W;
+    const bits = 128;
+    const windows = bits / W;
+    const windowSize = this.windowSize = 2 ** W;
+    const items = [];
+    for (let w = 0; w < windows; w++) {
+      for (let byte = 0; byte < windowSize; byte++) {
+        let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+        for (let j = 0; j < W; j++) {
+          const bit = byte >>> W - j - 1 & 1;
+          if (!bit)
+            continue;
+          const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W * w + j];
+          s0 ^= d0, s1 ^= d1, s2 ^= d2, s3 ^= d3;
+        }
+        items.push({ s0, s1, s2, s3 });
+      }
+    }
+    this.t = items;
+  }
+  _updateBlock(s0, s1, s2, s3) {
+    s0 ^= this.s0, s1 ^= this.s1, s2 ^= this.s2, s3 ^= this.s3;
+    const { W, t, windowSize } = this;
+    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
+    const mask = (1 << W) - 1;
+    let w = 0;
+    for (const num of [s0, s1, s2, s3]) {
+      for (let bytePos = 0; bytePos < 4; bytePos++) {
+        const byte = num >>> 8 * bytePos & 255;
+        for (let bitPos = 8 / W - 1; bitPos >= 0; bitPos--) {
+          const bit = byte >>> W * bitPos & mask;
+          const { s0: e0, s1: e1, s2: e2, s3: e3 } = t[w * windowSize + bit];
+          o0 ^= e0, o1 ^= e1, o2 ^= e2, o3 ^= e3;
+          w += 1;
+        }
+      }
+    }
+    this.s0 = o0;
+    this.s1 = o1;
+    this.s2 = o2;
+    this.s3 = o3;
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    data = copyBytes(data);
+    const b32 = u32(data);
+    const blocks = Math.floor(data.length / BLOCK_SIZE);
+    const left = data.length % BLOCK_SIZE;
+    for (let i = 0; i < blocks; i++) {
+      this._updateBlock(b32[i * 4 + 0], b32[i * 4 + 1], b32[i * 4 + 2], b32[i * 4 + 3]);
+    }
+    if (left) {
+      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));
+      this._updateBlock(ZEROS32[0], ZEROS32[1], ZEROS32[2], ZEROS32[3]);
+      clean(ZEROS32);
+    }
+    return this;
+  }
+  destroy() {
+    const { t } = this;
+    for (const elm of t) {
+      elm.s0 = 0, elm.s1 = 0, elm.s2 = 0, elm.s3 = 0;
+    }
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { s0, s1, s2, s3 } = this;
+    const o32 = u32(out);
+    o32[0] = s0;
+    o32[1] = s1;
+    o32[2] = s2;
+    o32[3] = s3;
+    return out;
+  }
+  digest() {
+    const res = new Uint8Array(BLOCK_SIZE);
+    this.digestInto(res);
+    this.destroy();
+    return res;
+  }
+};
+var Polyval = class extends GHASH {
+  constructor(key, expectedLength) {
+    abytes(key);
+    const ghKey = _toGHASHKey(copyBytes(key));
+    super(ghKey, expectedLength);
+    clean(ghKey);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    data = copyBytes(data);
+    const b32 = u32(data);
+    const left = data.length % BLOCK_SIZE;
+    const blocks = Math.floor(data.length / BLOCK_SIZE);
+    for (let i = 0; i < blocks; i++) {
+      this._updateBlock(swapLE(b32[i * 4 + 3]), swapLE(b32[i * 4 + 2]), swapLE(b32[i * 4 + 1]), swapLE(b32[i * 4 + 0]));
+    }
+    if (left) {
+      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));
+      this._updateBlock(swapLE(ZEROS32[3]), swapLE(ZEROS32[2]), swapLE(ZEROS32[1]), swapLE(ZEROS32[0]));
+      clean(ZEROS32);
+    }
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { s0, s1, s2, s3 } = this;
+    const o32 = u32(out);
+    o32[0] = s0;
+    o32[1] = s1;
+    o32[2] = s2;
+    o32[3] = s3;
+    return out.reverse();
+  }
+};
+function wrapConstructorWithKey(hashCons) {
+  const hashC = (msg, key) => hashCons(key, msg.length).update(msg).digest();
+  const tmp = hashCons(new Uint8Array(16), 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (key, expectedLength) => hashCons(key, expectedLength);
+  return hashC;
+}
+var ghash = wrapConstructorWithKey((key, expectedLength) => new GHASH(key, expectedLength));
+var polyval = wrapConstructorWithKey((key, expectedLength) => new Polyval(key, expectedLength));
+
+// node_modules/@noble/ciphers/aes.js
+var BLOCK_SIZE2 = 16;
+var BLOCK_SIZE32 = 4;
+var EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE2);
+var POLY2 = 283;
+function validateKeyLength(key) {
+  if (![16, 24, 32].includes(key.length))
+    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key.length);
+}
+function mul22(n) {
+  return n << 1 ^ POLY2 & -(n >> 7);
+}
+function mul(a, b) {
+  let res = 0;
+  for (; b > 0; b >>= 1) {
+    res ^= a & -(b & 1);
+    a = mul22(a);
+  }
+  return res;
+}
+var sbox = /* @__PURE__ */ (() => {
+  const t = new Uint8Array(256);
+  for (let i = 0, x = 1; i < 256; i++, x ^= mul22(x))
+    t[i] = x;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i = 0; i < 255; i++) {
+    let x = t[255 - i];
+    x |= x << 8;
+    box[t[i]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+  }
+  clean(t);
+  return box;
+})();
+var rotr32_8 = (n) => n << 24 | n >>> 8;
+var rotl32_8 = (n) => n << 8 | n >>> 24;
+function genTtable(sbox2, fn) {
+  if (sbox2.length !== 256)
+    throw new Error("Wrong sbox length");
+  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
+  const T1 = T0.map(rotl32_8);
+  const T2 = T1.map(rotl32_8);
+  const T3 = T2.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i = 0; i < 256; i++) {
+    for (let j = 0; j < 256; j++) {
+      const idx = i * 256 + j;
+      T01[idx] = T0[i] ^ T1[j];
+      T23[idx] = T2[i] ^ T3[j];
+      sbox22[idx] = sbox2[i] << 8 | sbox2[j];
+    }
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
+}
+var tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
+var xPowers = /* @__PURE__ */ (() => {
+  const p = new Uint8Array(16);
+  for (let i = 0, x = 1; i < 16; i++, x = mul22(x))
+    p[i] = x;
+  return p;
+})();
+function expandKeyLE(key) {
+  abytes(key);
+  const len = key.length;
+  validateKeyLength(key);
+  const { sbox2 } = tableEncoding;
+  const toClean = [];
+  if (!isAligned32(key))
+    toClean.push(key = copyBytes(key));
+  const k32 = u32(key);
+  const Nk = k32.length;
+  const subByte = (n) => applySbox(sbox2, n, n, n, n);
+  const xk = new Uint32Array(len + 28);
+  xk.set(k32);
+  for (let i = Nk; i < xk.length; i++) {
+    let t = xk[i - 1];
+    if (i % Nk === 0)
+      t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];
+    else if (Nk > 6 && i % Nk === 4)
+      t = subByte(t);
+    xk[i] = xk[i - Nk] ^ t;
+  }
+  clean(...toClean);
+  return xk;
+}
+function apply0123(T01, T23, s0, s1, s2, s3) {
+  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
+}
+function applySbox(sbox2, s0, s1, s2, s3) {
+  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
+}
+function encrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableEncoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i = 0; i < rounds; i++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function ctr32(xk, isLE2, nonce, src, dst) {
+  abytes(nonce, BLOCK_SIZE2, "nonce");
+  abytes(src);
+  dst = getOutput(src.length, dst);
+  const ctr = nonce;
+  const c32 = u32(ctr);
+  const view = createView(ctr);
+  const src32 = u32(src);
+  const dst32 = u32(dst);
+  const ctrPos = isLE2 ? 0 : 12;
+  const srcLen = src.length;
+  let ctrNum = view.getUint32(ctrPos, isLE2);
+  let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);
+  for (let i = 0; i + 4 <= src32.length; i += 4) {
+    dst32[i + 0] = src32[i + 0] ^ s0;
+    dst32[i + 1] = src32[i + 1] ^ s1;
+    dst32[i + 2] = src32[i + 2] ^ s2;
+    dst32[i + 3] = src32[i + 3] ^ s3;
+    ctrNum = ctrNum + 1 >>> 0;
+    view.setUint32(ctrPos, ctrNum, isLE2);
+    ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));
+  }
+  const start = BLOCK_SIZE2 * Math.floor(src32.length / BLOCK_SIZE32);
+  if (start < srcLen) {
+    const b32 = new Uint32Array([s0, s1, s2, s3]);
+    const buf = u8(b32);
+    for (let i = start, pos = 0; i < srcLen; i++, pos++)
+      dst[i] = src[i] ^ buf[pos];
+    clean(b32);
+  }
+  return dst;
+}
+function computeTag(fn, isLE2, key, data, AAD) {
+  const aadLength = AAD ? AAD.length : 0;
+  const h = fn.create(key, data.length + aadLength);
+  if (AAD)
+    h.update(AAD);
+  const num = u64Lengths(8 * data.length, 8 * aadLength, isLE2);
+  h.update(data);
+  h.update(num);
+  const res = h.digest();
+  clean(num);
+  return res;
+}
+var gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {
+  if (nonce.length < 8)
+    throw new Error("aes/gcm: invalid nonce length");
+  const tagLength = 16;
+  function _computeTag(authKey, tagMask, data) {
+    const tag = computeTag(ghash, false, authKey, data, AAD);
+    for (let i = 0; i < tagMask.length; i++)
+      tag[i] ^= tagMask[i];
+    return tag;
+  }
+  function deriveKeys() {
+    const xk = expandKeyLE(key);
+    const authKey = EMPTY_BLOCK.slice();
+    const counter = EMPTY_BLOCK.slice();
+    ctr32(xk, false, counter, counter, authKey);
+    if (nonce.length === 12) {
+      counter.set(nonce);
+    } else {
+      const nonceLen = EMPTY_BLOCK.slice();
+      const view = createView(nonceLen);
+      view.setBigUint64(8, BigInt(nonce.length * 8), false);
+      const g = ghash.create(authKey).update(nonce).update(nonceLen);
+      g.digestInto(counter);
+      g.destroy();
+    }
+    const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);
+    return { xk, authKey, counter, tagMask };
+  }
+  return {
+    encrypt(plaintext) {
+      const { xk, authKey, counter, tagMask } = deriveKeys();
+      const out = new Uint8Array(plaintext.length + tagLength);
+      const toClean = [xk, authKey, counter, tagMask];
+      if (!isAligned32(plaintext))
+        toClean.push(plaintext = copyBytes(plaintext));
+      ctr32(xk, false, counter, plaintext, out.subarray(0, plaintext.length));
+      const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));
+      toClean.push(tag);
+      out.set(tag, plaintext.length);
+      clean(...toClean);
+      return out;
+    },
+    decrypt(ciphertext) {
+      const { xk, authKey, counter, tagMask } = deriveKeys();
+      const toClean = [xk, authKey, tagMask, counter];
+      if (!isAligned32(ciphertext))
+        toClean.push(ciphertext = copyBytes(ciphertext));
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = _computeTag(authKey, tagMask, data);
+      toClean.push(tag);
+      if (!equalBytes(tag, passedTag))
+        throw new Error("aes/gcm: invalid ghash tag");
+      const out = ctr32(xk, false, counter, data);
+      clean(...toClean);
+      return out;
+    }
+  };
+});
+function isBytes32(a) {
+  return a instanceof Uint32Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint32Array";
+}
+function encryptBlock(xk, block) {
+  abytes(block, 16, "block");
+  if (!isBytes32(xk))
+    throw new Error("_encryptBlock accepts result of expandKeyLE");
+  const b32 = u32(block);
+  let { s0, s1, s2, s3 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);
+  b32[0] = s0, b32[1] = s1, b32[2] = s2, b32[3] = s3;
+  return block;
+}
+function dbl(block) {
+  let carry = 0;
+  for (let i = BLOCK_SIZE2 - 1; i >= 0; i--) {
+    const newCarry = (block[i] & 128) >>> 7;
+    block[i] = block[i] << 1 | carry;
+    carry = newCarry;
+  }
+  if (carry) {
+    block[BLOCK_SIZE2 - 1] ^= 135;
+  }
+  return block;
+}
+function xorBlock(a, b) {
+  if (a.length !== b.length)
+    throw new Error("xorBlock: blocks must have same length");
+  for (let i = 0; i < a.length; i++) {
+    a[i] = a[i] ^ b[i];
+  }
+  return a;
+}
+var _CMAC = class {
+  buffer;
+  destroyed;
+  k1;
+  k2;
+  xk;
+  constructor(key) {
+    abytes(key);
+    validateKeyLength(key);
+    this.xk = expandKeyLE(key);
+    this.buffer = new Uint8Array(0);
+    this.destroyed = false;
+    const L = new Uint8Array(BLOCK_SIZE2);
+    encryptBlock(this.xk, L);
+    this.k1 = dbl(L);
+    this.k2 = dbl(new Uint8Array(this.k1));
+  }
+  update(data) {
+    const { destroyed, buffer } = this;
+    if (destroyed)
+      throw new Error("CMAC instance was destroyed");
+    abytes(data);
+    const newBuffer = new Uint8Array(buffer.length + data.length);
+    newBuffer.set(buffer);
+    newBuffer.set(data, buffer.length);
+    this.buffer = newBuffer;
+    return this;
+  }
+  // see https://www.rfc-editor.org/rfc/rfc4493.html#section-2.4
+  digest() {
+    if (this.destroyed)
+      throw new Error("CMAC instance was destroyed");
+    const { buffer } = this;
+    const msgLen = buffer.length;
+    let n = Math.ceil(msgLen / BLOCK_SIZE2);
+    let flag;
+    if (n === 0) {
+      n = 1;
+      flag = false;
+    } else {
+      flag = msgLen % BLOCK_SIZE2 === 0;
+    }
+    const lastBlockStart = (n - 1) * BLOCK_SIZE2;
+    const lastBlockData = buffer.subarray(lastBlockStart);
+    let m_last;
+    if (flag) {
+      m_last = xorBlock(new Uint8Array(lastBlockData), this.k1);
+    } else {
+      const padded = new Uint8Array(BLOCK_SIZE2);
+      padded.set(lastBlockData);
+      padded[lastBlockData.length] = 128;
+      m_last = xorBlock(padded, this.k2);
+    }
+    let x = new Uint8Array(BLOCK_SIZE2);
+    for (let i = 0; i < n - 1; i++) {
+      const m_i = buffer.subarray(i * BLOCK_SIZE2, (i + 1) * BLOCK_SIZE2);
+      xorBlock(x, m_i);
+      encryptBlock(this.xk, x);
+    }
+    xorBlock(x, m_last);
+    encryptBlock(this.xk, x);
+    clean(m_last);
+    return x;
+  }
+  destroy() {
+    const { buffer, destroyed, xk, k1, k2 } = this;
+    if (destroyed)
+      return;
+    this.destroyed = true;
+    clean(buffer, xk, k1, k2);
+  }
+};
+var cmac = (key, message) => new _CMAC(key).update(message).digest();
+cmac.create = (key) => new _CMAC(key);
+
+// src/sdk/file-encryption.ts
+import { generateRandomBytes } from "@fileverse/crypto/utils";
+var KEY_LEN = 32;
+var IV_LEN = 12;
+var TAG_LEN = 16;
+var bytesToB64 = (b) => Buffer.from(b).toString("base64");
+function gcmEncrypt(plaintext) {
+  const key = generateRandomBytes(KEY_LEN);
+  const iv = generateRandomBytes(IV_LEN);
+  if (key.length !== KEY_LEN) throw new Error("key must be 32 bytes");
+  if (iv.length !== IV_LEN) throw new Error("iv must be 12 bytes");
+  const out = gcm(key, iv).encrypt(plaintext);
+  const ciphertext = out.subarray(0, out.length - TAG_LEN);
+  const authTag = out.subarray(out.length - TAG_LEN);
+  return {
+    ciphertext,
+    authTag: bytesToB64(authTag),
+    key: bytesToB64(key),
+    iv: bytesToB64(iv)
+  };
+}
+
+// src/sdk/file-utils.ts
+import { toAESKey, aesEncrypt } from "@fileverse/crypto/webcrypto";
+import axios from "axios";
+import { encodeFunctionData, parseEventLogs } from "viem";
+var deriveKeyFromAg2Hash = async (pass, salt) => {
+  const key = await getArgon2idHash(pass, salt);
+  return hkdf(Buffer.from(key), tweetnacl.secretbox.keyLength, {
+    info: Buffer.from("encryptionKey")
+  });
+};
+var decryptSecretKey = async (docId, nonce, encryptedSecretKey) => {
+  const derivedKey = await deriveKeyFromAg2Hash(docId, toUint8Array(nonce));
+  return tweetnacl.secretbox.open(toUint8Array(encryptedSecretKey), toUint8Array(nonce), derivedKey);
+};
+var getExistingEncryptionMaterial = async (existingEncryptedSecretKey, existingNonce, docId) => {
+  const secretKey = await decryptSecretKey(docId, existingNonce, existingEncryptedSecretKey);
+  return {
+    encryptedSecretKey: existingEncryptedSecretKey,
+    nonce: toUint8Array(existingNonce),
+    secretKey
+  };
+};
+var getNaclSecretKey = async (ddocId) => {
+  const { secretKey } = tweetnacl.box.keyPair();
+  const nonce = tweetnacl.randomBytes(tweetnacl.secretbox.nonceLength);
+  const derivedKey = await deriveKeyFromAg2Hash(ddocId, nonce);
+  const encryptedSecretKey = fromUint8Array(tweetnacl.secretbox(secretKey, nonce, derivedKey), true);
+  return { nonce, encryptedSecretKey, secretKey };
+};
+var generateLinkKeyMaterial = async (params) => {
+  if (params.linkKeyNonce && params.linkKey) {
+    const { encryptedSecretKey: encryptedSecretKey2, nonce: nonce2, secretKey: secretKey2 } = await getExistingEncryptionMaterial(
+      params.linkKey,
+      params.linkKeyNonce,
+      params.ddocId
+    );
+    if (secretKey2) return { encryptedSecretKey: encryptedSecretKey2, nonce: nonce2, secretKey: secretKey2 };
+  }
+  const { secretKey, nonce, encryptedSecretKey } = await getNaclSecretKey(params.ddocId);
+  return { secretKey, nonce, encryptedSecretKey };
+};
+var jsonToFile = (json, fileName) => {
+  const blob = new Blob([JSON.stringify(json)], {
+    type: "application/json"
+  });
+  const file = new File([blob], fileName, {
+    type: "application/json"
+  });
+  return file;
+};
+var appendAuthTagIvToBlob = async (blob, authTag, iv) => {
+  const encryptedFileBytes = await blob.arrayBuffer();
+  const encryptedBytes = new Uint8Array(encryptedFileBytes);
+  const combinedLength = encryptedBytes.length + authTag.length + iv.length;
+  const combinedArray = new Uint8Array(combinedLength);
+  let offset = 0;
+  combinedArray.set(encryptedBytes, offset);
+  offset += encryptedBytes.length;
+  combinedArray.set(authTag, offset);
+  offset += authTag.length;
+  combinedArray.set(iv, offset);
+  return new Blob([combinedArray], { type: blob.type });
+};
+var encryptFile = async (file) => {
+  const arrayBuffer = await file.arrayBuffer();
+  const plaintext = new Uint8Array(arrayBuffer);
+  const { ciphertext, authTag, key, iv } = gcmEncrypt(plaintext);
+  const encryptedBlob = new Blob([ciphertext], { type: file.type });
+  const encryptedBlobWithAuthTagIv = await appendAuthTagIvToBlob(
+    encryptedBlob,
+    toUint8Array(authTag),
+    toUint8Array(iv)
+  );
+  return {
+    encryptedFile: new File([encryptedBlobWithAuthTagIv], file.name),
+    key
+  };
+};
+var getNonceAppendedCipherText = (nonce, cipherText) => {
+  return fromUint8Array(nonce, true) + "__n__" + fromUint8Array(cipherText, true);
+};
+var jsonToBytes = (json) => new TextEncoder().encode(JSON.stringify(json));
+var buildLinklock = (key, fileKey, commentKey) => {
+  const ikm = generateRandomBytes2();
+  const kdfSalt = generateRandomBytes2();
+  const derivedEphermalKey = derivePBKDF2Key(ikm, kdfSalt);
+  const { iv, cipherText } = encryptAesCBC(
+    {
+      key: derivedEphermalKey,
+      message: fileKey
+    },
+    "base64"
+  );
+  const { iv: commentIv, cipherText: commentCipherText } = encryptAesCBC(
+    {
+      key: derivedEphermalKey,
+      message: commentKey
+    },
+    "base64"
+  );
+  const encryptedIkm = secretBoxEncrypt(ikm, key);
+  const lockedFileKey = iv + "__n__" + cipherText;
+  const lockedChatKey = commentIv + "__n__" + commentCipherText;
+  const keyMaterial = bytesToBase64(kdfSalt) + "__n__" + encryptedIkm;
+  const fileKeyNonce = generateRandomBytes2(24);
+  const encryptedFileKey = tweetnacl.secretbox(jsonToBytes({ key: fromUint8Array(fileKey) }), fileKeyNonce, key);
+  const chatKeyNonce = generateRandomBytes2(24);
+  const encryptedChatKey = tweetnacl.secretbox(commentKey, chatKeyNonce, key);
+  return {
+    lockedFileKey: getNonceAppendedCipherText(fileKeyNonce, encryptedFileKey),
+    lockedChatKey: getNonceAppendedCipherText(chatKeyNonce, encryptedChatKey),
+    lockedFileKey_v2: lockedFileKey,
+    lockedChatKey_v2: lockedChatKey,
+    keyMaterial
+  };
+};
+var encryptTitleWithFileKey = async (args) => {
+  const key = await toAESKey(toUint8Array(args.key));
+  if (!key) throw new Error("Key is undefined");
+  const titleBytes = new TextEncoder().encode(args.title);
+  const encryptedTitle = await aesEncrypt(key, titleBytes, "base64");
+  return encryptedTitle;
+};
+var uploadFileToIPFS = async (fileParams, authParams) => {
+  const { file, ipfsType, appFileId } = fileParams;
+  const { token, invoker, contractAddress } = authParams;
+  const body = new FormData();
+  body.append("file", file);
+  body.append("ipfsType", ipfsType);
+  body.append("appFileId", appFileId);
+  body.append("sourceApp", "ddoc");
+  const uploadEndpoint = UPLOAD_SERVER_URL + "upload";
+  const response = await axios.post(uploadEndpoint, body, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      contract: contractAddress,
+      invoker,
+      chain: process.env.chainId
+    }
+  });
+  return response.data.ipfsHash;
+};
+var getEditFileTrxCalldata = (args) => {
+  return encodeFunctionData({
+    abi: EDIT_FILE_METHOD,
+    functionName: "editFile",
+    args: [BigInt(args.fileId), args.appFileId, args.metadataHash, args.contentHash, args.gateHash, 2, BigInt(0)]
+  });
+};
+var getAddFileTrxCalldata = (args) => {
+  return encodeFunctionData({
+    abi: ADD_FILE_METHOD,
+    functionName: "addFile",
+    args: [args.appFileId, 2, args.metadataHash, args.contentHash, args.gateHash, BigInt(0)]
+  });
+};
+var prepareCallData = (args) => {
+  if (args.fileId) {
+    return getEditFileTrxCalldata({
+      fileId: args.fileId,
+      appFileId: args.appFileId,
+      metadataHash: args.metadataHash,
+      contentHash: args.contentHash,
+      gateHash: args.gateHash
+    });
+  }
+  return getAddFileTrxCalldata(args);
+};
+var prepareDeleteFileCallData = (args) => {
+  return encodeFunctionData({
+    abi: DELETED_FILE_ABI,
+    functionName: "deleteFile",
+    args: [BigInt(args.onChainFileId)]
+  });
+};
+var createEncryptedContentFile = async (content) => {
+  const contentFile = jsonToFile(
+    { file: content, source: "ddoc" },
+    `${fromUint8Array(generateRandomBytes2(16))}-CONTENT`
+  );
+  return encryptFile(contentFile);
+};
+var buildFileMetadata = (params) => ({
+  title: params.encryptedTitle,
+  size: params.encryptedFileSize,
+  mimeType: "application/json",
+  appLock: params.appLock,
+  ownerLock: params.ownerLock,
+  ddocId: params.ddocId,
+  nonce: params.nonce,
+  owner: params.owner,
+  version: "4",
+  sourceApp: "fileverse-api"
+});
+var parseFileEventLog = (logs, eventName, abi) => {
+  const [parsedLog] = parseEventLogs({ abi, logs, eventName });
+  if (!parsedLog) throw new Error(`${eventName} event not found`);
+  const fileId = parsedLog.args.fileId;
+  if (fileId === void 0 || fileId === null) throw new Error("FileId not found in event logs");
+  return Number(fileId);
+};
+var uploadAllFilesToIPFS = async (params, authParams) => {
+  const { metadata, encryptedFile, linkLock, ddocId } = params;
+  const [metadataHash, contentHash, gateHash] = await Promise.all([
+    uploadFileToIPFS(
+      {
+        file: jsonToFile(metadata, `${fromUint8Array(generateRandomBytes2(16))}-METADATA`),
+        ipfsType: "METADATA",
+        appFileId: ddocId
+      },
+      authParams
+    ),
+    uploadFileToIPFS(
+      {
+        file: encryptedFile,
+        ipfsType: "CONTENT",
+        appFileId: ddocId
+      },
+      authParams
+    ),
+    uploadFileToIPFS(
+      {
+        file: jsonToFile(linkLock, `${fromUint8Array(generateRandomBytes2(16))}-GATE`),
+        ipfsType: "GATE",
+        appFileId: ddocId
+      },
+      authParams
+    )
+  ]);
+  return { metadataHash, contentHash, gateHash };
+};
+
+// src/sdk/file-manager.ts
+import { generateAESKey, exportAESKey } from "@fileverse/crypto/webcrypto";
+import { markdownToYjs } from "@fileverse/content-processor";
+var FileManager = class {
+  keyStore;
+  agentClient;
+  constructor(keyStore, agentClient) {
+    this.keyStore = keyStore;
+    this.agentClient = agentClient;
+  }
+  createLocks(key, encryptedSecretKey, commentKey) {
+    const appLock = {
+      lockedFileKey: this.keyStore.encryptData(toUint8Array2(key)),
+      lockedLinkKey: this.keyStore.encryptData(toUint8Array2(encryptedSecretKey)),
+      lockedChatKey: this.keyStore.encryptData(commentKey)
+    };
+    return { appLock, ownerLock: { ...appLock } };
+  }
+  async getAuthParams() {
+    return {
+      token: await this.keyStore.getAuthToken(STATIC_CONFIG.SERVER_DID),
+      contractAddress: this.keyStore.getPortalAddress(),
+      invoker: this.agentClient.getAgentAddress()
+    };
+  }
+  async executeFileOperation(callData) {
+    return this.agentClient.executeUserOperationRequest(
+      {
+        contractAddress: this.keyStore.getPortalAddress(),
+        data: callData
+      },
+      1e6
+    );
+  }
+  async sendFileOperation(callData) {
+    return this.agentClient.sendUserOperation(
+      {
+        contractAddress: this.keyStore.getPortalAddress(),
+        data: callData
+      },
+      1e6
+    );
+  }
+  async getProxyAuthParams() {
+    return this.agentClient.getAuthParams();
+  }
+  async submitAddFileTrx(file) {
+    logger.debug(`Preparing to add file ${file.ddocId}`);
+    const { encryptedSecretKey, nonce, secretKey } = await generateLinkKeyMaterial({
+      ddocId: file.ddocId,
+      linkKey: file.linkKey,
+      linkKeyNonce: file.linkKeyNonce
+    });
+    const yJSContent = markdownToYjs(file.content);
+    const { encryptedFile, key } = await createEncryptedContentFile(yJSContent);
+    logger.debug(`Generated encrypted content file for file ${file.ddocId}`);
+    const commentKey = await exportAESKey(await generateAESKey(128));
+    const { appLock, ownerLock } = this.createLocks(key, encryptedSecretKey, commentKey);
+    const linkLock = buildLinklock(secretKey, toUint8Array2(key), commentKey);
+    const encryptedTitle = await encryptTitleWithFileKey({
+      title: file.title || "Untitled",
+      key
+    });
+    const metadata = buildFileMetadata({
+      encryptedTitle,
+      encryptedFileSize: encryptedFile.size,
+      appLock,
+      ownerLock,
+      ddocId: file.ddocId,
+      nonce: fromUint8Array2(nonce),
+      owner: this.agentClient.getAgentAddress()
+    });
+    const authParams = await this.getAuthParams();
+    const { metadataHash, contentHash, gateHash } = await uploadAllFilesToIPFS(
+      { metadata, encryptedFile, linkLock, ddocId: file.ddocId },
+      authParams
+    );
+    logger.debug(`Uploaded files to IPFS for file ${file.ddocId}`);
+    const callData = prepareCallData({
+      metadataHash,
+      contentHash,
+      gateHash,
+      appFileId: file.ddocId,
+      fileId: file.fileId
+    });
+    logger.debug(`Prepared call data for file ${file.ddocId}`);
+    const userOpHash = await this.sendFileOperation(callData);
+    logger.debug(`Submitted user op for file ${file.ddocId}`);
+    return {
+      userOpHash,
+      linkKey: encryptedSecretKey,
+      linkKeyNonce: fromUint8Array2(nonce),
+      commentKey: fromUint8Array2(commentKey),
+      metadata
+    };
+  }
+  async updateFile(file) {
+    logger.debug(`Updating file ${file.ddocId} with onChainFileId ${file.onChainFileId}`);
+    const { encryptedSecretKey, nonce, secretKey } = await generateLinkKeyMaterial({
+      ddocId: file.ddocId,
+      linkKey: file.linkKey,
+      linkKeyNonce: file.linkKeyNonce
+    });
+    logger.debug(`Generating encrypted content file for file ${file.ddocId} with onChainFileId ${file.onChainFileId}`);
+    const yjsContent = markdownToYjs(file.content);
+    const { encryptedFile, key } = await createEncryptedContentFile(yjsContent);
+    const commentKey = toUint8Array2(file.commentKey);
+    const { appLock, ownerLock } = this.createLocks(key, encryptedSecretKey, commentKey);
+    const linkLock = buildLinklock(secretKey, toUint8Array2(key), commentKey);
+    const encryptedTitle = await encryptTitleWithFileKey({
+      title: file.title || "Untitled",
+      key
+    });
+    const metadata = buildFileMetadata({
+      encryptedTitle,
+      encryptedFileSize: encryptedFile.size,
+      appLock,
+      ownerLock,
+      ddocId: file.ddocId,
+      nonce: fromUint8Array2(nonce),
+      owner: this.agentClient.getAgentAddress()
+    });
+    const authParams = await this.getAuthParams();
+    logger.debug(`Uploading files to IPFS for file ${file.ddocId} with onChainFileId ${file.onChainFileId}`);
+    const { metadataHash, contentHash, gateHash } = await uploadAllFilesToIPFS(
+      { metadata, encryptedFile, linkLock, ddocId: file.ddocId },
+      authParams
+    );
+    const callData = prepareCallData({
+      metadataHash,
+      contentHash,
+      gateHash,
+      appFileId: file.ddocId,
+      fileId: file.onChainFileId
+    });
+    logger.debug(`Executing file operation for file ${file.ddocId} with onChainFileId ${file.onChainFileId}`);
+    const { logs } = await this.executeFileOperation(callData);
+    const onChainFileId = parseFileEventLog(logs, "EditedFile", EDITED_FILE_EVENT);
+    return { onChainFileId, metadata };
+  }
+  async deleteFile(file) {
+    logger.debug(`Deleting file ${file.ddocId} with onChainFileId ${file.onChainFileId}`);
+    const callData = prepareDeleteFileCallData({
+      onChainFileId: file.onChainFileId
+    });
+    logger.debug(`Prepared call data for deleting file ${file.ddocId} with onChainFileId ${file.onChainFileId}`);
+    const { logs } = await this.executeFileOperation(callData);
+    parseFileEventLog(logs, "DeletedFile", DELETED_FILE_EVENT);
+    logger.debug(`Executed file operation for deleting file ${file.ddocId} with onChainFileId ${file.onChainFileId}`);
+    return {
+      fileId: file.id,
+      onChainFileId: file.onChainFileId,
+      metadata: file.metadata
+    };
+  }
+};
+
+// src/domain/portal/publish.ts
+function getPortalData(fileId) {
+  const file = FilesModel.findByIdIncludingDeleted(fileId);
+  if (!file) {
+    throw new Error(`File with _id ${fileId} not found`);
+  }
+  const portalDetails = PortalsModel.findByPortalAddress(file.portalAddress);
+  if (!portalDetails) {
+    throw new Error(`Portal with address ${file.portalAddress} not found`);
+  }
+  const apiKey = getRuntimeConfig().API_KEY;
+  if (!apiKey) {
+    throw new Error("API key is not set");
+  }
+  return { file, portalDetails, apiKey };
+}
+function deriveCollaboratorKeys(apiKeySeed) {
+  const salt = new Uint8Array([0]);
+  const privateAccountKey = deriveHKDFKey(apiKeySeed, salt, stringToBytes("COLLABORATOR_PRIVATE_KEY"));
+  const ucanDerivedSecret = deriveHKDFKey(apiKeySeed, salt, stringToBytes("COLLABORATOR_UCAN_SECRET"));
+  const { secretKey: ucanSecret } = generateKeyPairFromSeed(ucanDerivedSecret);
+  return { privateAccountKey, ucanSecret };
+}
+var createFileManager = async (portalSeed, portalAddress, ucanSecret, privateAccountKey) => {
+  const keyPair = ucans2.EdKeypair.fromSecretKey(fromUint8Array3(ucanSecret), {
+    exportable: true
+  });
+  const authTokenProvider = new AuthTokenProvider(keyPair, portalAddress);
+  const keyStore = new KeyStore(toUint8Array3(portalSeed), portalAddress, authTokenProvider);
+  const agentClient = new AgentClient(authTokenProvider);
+  await agentClient.initializeAgentClient(privateAccountKey);
+  return new FileManager(keyStore, agentClient);
+};
+var executeOperation = async (fileManager, file, operation) => {
+  if (operation === "update") {
+    const result = await fileManager.updateFile(file);
+    return { success: true, ...result };
+  }
+  if (operation === "delete") {
+    const result = await fileManager.deleteFile(file);
+    return { success: true, ...result };
+  }
+  throw new Error(`Invalid operation: ${operation}`);
+};
+var handleExistingFileOp = async (fileId, operation) => {
+  try {
+    const { file, portalDetails, apiKey } = getPortalData(fileId);
+    const apiKeySeed = toUint8Array3(apiKey);
+    const { privateAccountKey, ucanSecret } = deriveCollaboratorKeys(apiKeySeed);
+    const fileManager = await createFileManager(
+      portalDetails.portalSeed,
+      portalDetails.portalAddress,
+      ucanSecret,
+      privateAccountKey
+    );
+    return executeOperation(fileManager, file, operation);
+  } catch (error) {
+    logger.error(`Failed to publish file ${fileId}:`, error);
+    throw error;
+  }
+};
+var handleNewFileOp = async (fileId) => {
+  const { file, portalDetails, apiKey } = getPortalData(fileId);
+  const apiKeySeed = toUint8Array3(apiKey);
+  const { privateAccountKey, ucanSecret } = deriveCollaboratorKeys(apiKeySeed);
+  const fileManager = await createFileManager(
+    portalDetails.portalSeed,
+    portalDetails.portalAddress,
+    ucanSecret,
+    privateAccountKey
+  );
+  return fileManager.submitAddFileTrx(file);
+};
+var getProxyAuthParams = async (fileId) => {
+  const { portalDetails, apiKey } = getPortalData(fileId);
+  const apiKeySeed = toUint8Array3(apiKey);
+  const { privateAccountKey, ucanSecret } = deriveCollaboratorKeys(apiKeySeed);
+  const fileManager = await createFileManager(
+    portalDetails.portalSeed,
+    portalDetails.portalAddress,
+    ucanSecret,
+    privateAccountKey
+  );
+  return fileManager.getProxyAuthParams();
+};
+
+// src/errors/rate-limit.ts
+import { HttpRequestError } from "viem";
+var RateLimitError = class extends Error {
+  retryAfterSeconds;
+  constructor(retryAfterSeconds, message = "Rate limit exceeded") {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+var MAX_RETRY_AFTER_SECONDS = 300;
+var DEFAULT_RETRY_AFTER_SECONDS = 3600;
+function parseRetryAfterRaw(raw) {
+  if (!raw) return DEFAULT_RETRY_AFTER_SECONDS;
+  const parsed = parseInt(raw, 10);
+  if (!Number.isNaN(parsed) && parsed >= 0) return Math.min(parsed, MAX_RETRY_AFTER_SECONDS);
+  const date = Date.parse(raw);
+  if (!Number.isNaN(date)) {
+    const seconds = Math.max(0, Math.ceil((date - Date.now()) / 1e3));
+    return Math.min(seconds, MAX_RETRY_AFTER_SECONDS);
+  }
+  return DEFAULT_RETRY_AFTER_SECONDS;
+}
+var parseRetryAfterFromHeaders = (headers) => parseRetryAfterRaw(headers?.get("Retry-After") ?? null);
+function normalizeRateLimitError(error) {
+  if (!(error instanceof HttpRequestError) || error.status !== 429) return error;
+  const retryAfter = parseRetryAfterFromHeaders(error.headers);
+  const message = "Beta API rate limit reached. Try again in an hour please!";
+  return new RateLimitError(retryAfter, message);
+}
+
+// src/infra/worker/eventProcessor.ts
+var processEvent = async (event) => {
+  const { fileId, type } = event;
+  try {
+    switch (type) {
+      case "create":
+        await processCreateEvent(event);
+        break;
+      case "update":
+        await processUpdateEvent(event);
+        break;
+      case "delete":
+        await processDeleteEvent(event);
+        break;
+      default:
+        throw new Error(`Unknown event type: ${type}`);
+    }
+    return { success: true };
+  } catch (error) {
+    const normalized = normalizeRateLimitError(error);
+    if (normalized instanceof RateLimitError) throw normalized;
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`Error processing ${type} event for file ${fileId}:`, errorMsg);
+    return { success: false, error: errorMsg };
+  }
+};
+var onTransactionSuccess = (fileId, file, onChainFileId, pending) => {
+  const frontendUrl = getRuntimeConfig().FRONTEND_URL;
+  const payload = {
+    onchainVersion: file.localVersion,
+    onChainFileId,
+    linkKey: pending.linkKey,
+    linkKeyNonce: pending.linkKeyNonce,
+    commentKey: pending.commentKey,
+    metadata: pending.metadata,
+    link: `${frontendUrl}/${file.portalAddress}/${onChainFileId}#key=${pending.linkKey}`
+  };
+  const updatedFile = FilesModel.update(fileId, payload, file.portalAddress);
+  if (updatedFile.localVersion === updatedFile.onchainVersion) {
+    FilesModel.update(fileId, { syncStatus: "synced" }, file.portalAddress);
+  }
+};
+var processCreateEvent = async (event) => {
+  const { fileId } = event;
+  const file = FilesModel.findByIdIncludingDeleted(fileId);
+  if (!file) {
+    throw new Error(`File ${fileId} not found`);
+  }
+  if (file.isDeleted === 1) {
+    logger.info(`File ${fileId} is deleted, skipping create event`);
+    return;
+  }
+  const waitContext = await getProxyAuthParams(fileId);
+  const timeout = 12e4;
+  if (event.userOpHash) {
+    const receipt2 = await waitForUserOpReceipt(
+      event.userOpHash,
+      waitContext.authToken,
+      waitContext.portalAddress,
+      waitContext.invokerAddress,
+      timeout
+    );
+    if (!receipt2.success) {
+      EventsModel.clearEventPendingOp(event._id);
+      throw new Error(`User operation failed: ${receipt2.reason}`);
+    }
+    const onChainFileId2 = parseFileEventLog(receipt2.logs, "AddedFile", ADDED_FILE_EVENT);
+    const pending = JSON.parse(event.pendingPayload);
+    onTransactionSuccess(fileId, file, onChainFileId2, pending);
+    EventsModel.clearEventPendingOp(event._id);
+    logger.info(`File ${file.ddocId} created and published successfully (resumed from pending op)`);
+    return;
+  }
+  const result = await handleNewFileOp(fileId);
+  EventsModel.setEventPendingOp(event._id, result.userOpHash, {
+    linkKey: result.linkKey,
+    linkKeyNonce: result.linkKeyNonce,
+    commentKey: result.commentKey,
+    metadata: result.metadata
+  });
+  const receipt = await waitForUserOpReceipt(
+    result.userOpHash,
+    waitContext.authToken,
+    waitContext.portalAddress,
+    waitContext.invokerAddress,
+    timeout
+  );
+  if (!receipt.success) {
+    EventsModel.clearEventPendingOp(event._id);
+    throw new Error(`User operation failed: ${receipt.reason}`);
+  }
+  const onChainFileId = parseFileEventLog(receipt.logs, "AddedFile", ADDED_FILE_EVENT);
+  onTransactionSuccess(fileId, file, onChainFileId, {
+    linkKey: result.linkKey,
+    linkKeyNonce: result.linkKeyNonce,
+    commentKey: result.commentKey,
+    metadata: result.metadata
+  });
+  EventsModel.clearEventPendingOp(event._id);
+  logger.info(`File ${file.ddocId} created and published successfully`);
+};
+var processUpdateEvent = async (event) => {
+  const { fileId } = event;
+  const file = FilesModel.findByIdExcludingDeleted(fileId);
+  if (!file) {
+    return;
+  }
+  if (file.localVersion <= file.onchainVersion) {
+    return;
+  }
+  const result = await handleExistingFileOp(fileId, "update");
+  if (!result.success) {
+    throw new Error(`Publish failed for file ${fileId}`);
+  }
+  const payload = {
+    onchainVersion: file.localVersion,
+    metadata: result.metadata
+  };
+  const updatedFile = FilesModel.update(fileId, payload, file.portalAddress);
+  if (updatedFile.localVersion === updatedFile.onchainVersion) {
+    FilesModel.update(fileId, { syncStatus: "synced" }, file.portalAddress);
+  }
+  logger.info(`File ${file.ddocId} updated and published successfully`);
+};
+var processDeleteEvent = async (event) => {
+  const { fileId } = event;
+  const file = FilesModel.findByIdIncludingDeleted(fileId);
+  if (!file) {
+    return;
+  }
+  if (file.isDeleted === 1 && file.syncStatus === "synced") {
+    logger.info(`File ${fileId} deletion already synced, skipping`);
+    return;
+  }
+  const payload = {
+    syncStatus: "synced",
+    isDeleted: 1
+  };
+  if (file.onChainFileId !== null || file.onChainFileId !== void 0) {
+    const result = await handleExistingFileOp(fileId, "delete");
+    if (!result.success) {
+      throw new Error(`Publish failed for file ${fileId}`);
+    }
+    payload.onchainVersion = file.localVersion;
+    payload.metadata = result.metadata;
+    payload.isDeleted = 1;
+  }
+  FilesModel.update(fileId, payload, file.portalAddress);
+  logger.info(`File ${fileId} delete event processed (syncStatus set to synced)`);
+};
+
+// src/infra/worker/worker.ts
+var DEFAULT_CONCURRENCY = 5;
+var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+var SIGNAL_RETRY_DELAY_MS = 50;
+var FALLBACK_POLL_MS = 3e4;
+var MAX_RETRIES = 10;
+var FileEventsWorker = class {
+  isRunning = false;
+  concurrency;
+  activeProcessors = /* @__PURE__ */ new Map();
+  signalCleanup = null;
+  pendingSignal = false;
+  wakeResolver = null;
+  constructor(concurrency2 = DEFAULT_CONCURRENCY) {
+    this.concurrency = concurrency2;
+  }
+  start() {
+    if (this.isRunning) {
+      logger.warn("Worker is already running");
+      return;
+    }
+    this.isRunning = true;
+    const staleCount = this.recoverStaleEvents();
+    if (staleCount > 0) {
+      logger.info(`Recovered ${staleCount} stale event(s)`);
+    }
+    this.signalCleanup = onNewEvent(() => {
+      this.pendingSignal = true;
+      this.wakeUp();
+    });
+    logger.debug(`File events worker started (concurrency: ${this.concurrency})`);
+    this.run();
+  }
+  async run() {
+    while (this.isRunning) {
+      const foundEvents = await this.fillSlots();
+      logger.debug(`Found ${foundEvents ? "events" : "no events"} to process`);
+      if (this.activeProcessors.size === 0) {
+        if (this.pendingSignal && !foundEvents) {
+          this.pendingSignal = false;
+          await this.sleep(SIGNAL_RETRY_DELAY_MS);
+          continue;
+        }
+        this.pendingSignal = false;
+        await this.waitForSignalOrTimeout(FALLBACK_POLL_MS);
+      } else {
+        await Promise.race(this.activeProcessors.values());
+      }
+    }
+  }
+  async fillSlots() {
+    let foundAny = false;
+    while (this.activeProcessors.size < this.concurrency && this.isRunning) {
+      const lockedFileIds = Array.from(this.activeProcessors.keys());
+      const event = EventsModel.findNextEligible(lockedFileIds);
+      if (!event) break;
+      foundAny = true;
+      EventsModel.markProcessing(event._id);
+      const processor = this.processEventWrapper(event);
+      this.activeProcessors.set(event.fileId, processor);
+    }
+    logger.debug(`Slots filled: ${this.activeProcessors.size}`);
+    return foundAny;
+  }
+  async processEventWrapper(event) {
+    try {
+      const result = await processEvent(event);
+      if (result.success) {
+        EventsModel.markProcessed(event._id);
+      } else {
+        this.handleFailure(event, result.error);
+      }
+    } catch (err) {
+      this.handleFailure(event, err);
+    } finally {
+      this.activeProcessors.delete(event.fileId);
+    }
+  }
+  handleFailure(event, error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    if (error instanceof RateLimitError) {
+      const retryAfterMs = error.retryAfterSeconds * 1e3;
+      EventsModel.scheduleRetryAfter(event._id, errorMsg, retryAfterMs);
+      logger.warn(`Event ${event._id} rate limited; retry after ${error.retryAfterSeconds}s`);
+      return;
+    }
+    if (event.retryCount < MAX_RETRIES) {
+      EventsModel.scheduleRetry(event._id, errorMsg);
+      logger.warn(`Event ${event._id} failed (retry ${event.retryCount + 1}/${MAX_RETRIES}): ${errorMsg}`);
+    } else {
+      EventsModel.markFailed(event._id, errorMsg);
+      logger.error(`Event ${event._id} permanently failed after ${MAX_RETRIES} retries: ${errorMsg}`);
+    }
+  }
+  recoverStaleEvents() {
+    const staleThreshold = Date.now() - STALE_THRESHOLD_MS;
+    return EventsModel.resetStaleEvents(staleThreshold);
+  }
+  wakeUp() {
+    if (this.wakeResolver) {
+      this.wakeResolver();
+      this.wakeResolver = null;
+    }
+  }
+  waitForSignalOrTimeout(ms) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.wakeResolver = null;
+        resolve();
+      }, ms);
+      this.wakeResolver = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async close() {
+    if (!this.isRunning) {
+      return;
+    }
+    logger.info("Closing worker gracefully...");
+    this.isRunning = false;
+    if (this.signalCleanup) {
+      this.signalCleanup();
+      this.signalCleanup = null;
+    }
+    this.wakeUp();
+    this.wakeResolver = null;
+    if (this.activeProcessors.size > 0) {
+      logger.info(`Waiting for ${this.activeProcessors.size} active processor(s) to complete...`);
+      await Promise.all(this.activeProcessors.values());
+    }
+    logger.info("Worker closed");
+  }
+  isActive() {
+    return this.isRunning;
+  }
+  getActiveCount() {
+    return this.activeProcessors.size;
+  }
+};
+function createWorker(concurrency2 = DEFAULT_CONCURRENCY) {
+  return new FileEventsWorker(concurrency2);
+}
+
+// src/appWorker.ts
+var DEFAULT_CONCURRENCY2 = 5;
+var worker = null;
+function startWorker(concurrency2 = DEFAULT_CONCURRENCY2) {
+  if (worker?.isActive()) {
+    return;
+  }
+  worker = createWorker(concurrency2);
+  worker.start();
+}
+async function closeWorker() {
+  if (worker) {
+    await worker.close();
+    worker = null;
+  }
+}
+function isWorkerActive() {
+  return worker?.isActive() ?? false;
+}
+
+// src/infra/reporter.ts
+var Reporter = class {
+  async reportError(message) {
+    console.error("Error reported:", message);
+  }
+};
+var reporter_default = new Reporter();
+
+// src/infra/database/migrations/index.ts
+var STABLE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS files (
+  _id TEXT PRIMARY KEY,
+  ddocId TEXT NOT NULL,
+  title TEXT NOT NULL,
+  content TEXT NOT NULL,
+  localVersion INTEGER NOT NULL DEFAULT 1,
+  onchainVersion INTEGER NOT NULL DEFAULT 0,
+  syncStatus TEXT NOT NULL DEFAULT 'pending',
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  isDeleted INTEGER NOT NULL DEFAULT 0,
+  portalAddress TEXT NOT NULL,
+  metadata TEXT DEFAULT '{}',
+  onChainFileId INTEGER,
+  commentKey TEXT,
+  linkKey TEXT,
+  linkKeyNonce TEXT,
+  link TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_files_createdAt ON files(createdAt);
+CREATE INDEX IF NOT EXISTS idx_files_syncStatus ON files(syncStatus);
+CREATE INDEX IF NOT EXISTS idx_files_title ON files(title);
+CREATE INDEX IF NOT EXISTS idx_files_portalAddress ON files(portalAddress);
+
+CREATE TABLE IF NOT EXISTS portals (
+  _id TEXT PRIMARY KEY,
+  portalAddress TEXT NOT NULL UNIQUE,
+  portalSeed TEXT NOT NULL UNIQUE,
+  ownerAddress TEXT NOT NULL,
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS api_keys (
+  _id TEXT PRIMARY KEY,
+  apiKeySeed TEXT NOT NULL UNIQUE,
+  name TEXT NOT NULL,
+  collaboratorAddress TEXT NOT NULL UNIQUE,
+  portalAddress TEXT NOT NULL,
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  isDeleted INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS events (
+  _id TEXT PRIMARY KEY,
+  type TEXT NOT NULL CHECK (type IN ('create', 'update', 'delete')),
+  timestamp INTEGER NOT NULL,
+  fileId TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'processing', 'processed', 'failed')),
+  retryCount INTEGER NOT NULL DEFAULT 0,
+  lastError TEXT,
+  lockedAt INTEGER,
+  nextRetryAt INTEGER,
+  userOpHash TEXT,
+  pendingPayload TEXT,
+  portalAddress TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_events_pending_eligible ON events (status, nextRetryAt, timestamp) WHERE status = 'pending';
+CREATE INDEX IF NOT EXISTS idx_events_file_pending_ts ON events (fileId, status, timestamp) WHERE status = 'pending';
+CREATE INDEX IF NOT EXISTS idx_events_processing_locked ON events (status, lockedAt) WHERE status = 'processing';
+CREATE INDEX IF NOT EXISTS idx_events_failed_portal ON events (portalAddress, status) WHERE status = 'failed';
+
+CREATE TABLE IF NOT EXISTS folders (
+  _id TEXT PRIMARY KEY,
+  onchainFileId INTEGER NOT NULL,
+  folderId TEXT NOT NULL,
+  folderRef TEXT NOT NULL,
+  folderName TEXT NOT NULL,
+  portalAddress TEXT NOT NULL,
+  metadataIPFSHash TEXT NOT NULL,
+  contentIPFSHash TEXT NOT NULL,
+  isDeleted INTEGER NOT NULL DEFAULT 0,
+  lastTransactionHash TEXT,
+  lastTransactionBlockNumber INTEGER NOT NULL,
+  lastTransactionBlockTimestamp INTEGER NOT NULL,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_folders_folderRef_folderId ON folders(folderRef, folderId);
+CREATE INDEX IF NOT EXISTS idx_folders_folderRef ON folders(folderRef);
+CREATE INDEX IF NOT EXISTS idx_folders_created_at ON folders(created_at);
+`;
+function runMigrations() {
+  const db = database_default();
+  db.exec(STABLE_SCHEMA);
+  logger.debug("Database schema ready");
+}
+
+// src/worker.ts
+validateDbPath();
+runMigrations();
+var concurrency = parseInt(process.env.WORKER_CONCURRENCY || "5", 10);
+startWorker(concurrency);
+setTimeout(() => {
+  if (isWorkerActive()) {
+    logger.info("File events worker started and active");
+    return;
+  }
+  logger.error("Worker failed to start");
+  process.exit(1);
+}, 100);
+var shutdown = async () => {
+  logger.info("Shutting down worker gracefully...");
+  await closeWorker();
+  process.exit(0);
+};
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+/*! Bundled license information:
+
+@noble/ciphers/utils.js:
+  (*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=worker.js.map