@wopr-network/platform-core 1.42.3 → 1.44.0

package/dist/db/schema/crypto.d.ts

@@ -1,6 +1,6 @@
 /**
- * Crypto payment charges — tracks the lifecycle of each BTCPay invoice.
- * reference_id is the BTCPay invoice ID.
+ * Crypto payment charges — tracks the lifecycle of each payment.
+ * reference_id is the charge ID (e.g. "btc:bc1q...").
  *
  * amountUsdCents stores the requested amount in USD cents (integer).
  * This is NOT nanodollars — Credit.fromCents() handles the conversion
@@ -231,6 +231,57 @@ export declare const cryptoCharges: import("drizzle-orm/pg-core").PgTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        callbackUrl: import("drizzle-orm/pg-core").PgColumn<{
+            name: "callback_url";
+            tableName: "crypto_charges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expectedAmount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expected_amount";
+            tableName: "crypto_charges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        receivedAmount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "received_amount";
+            tableName: "crypto_charges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;
@@ -300,6 +351,9 @@ export declare const watcherCursors: import("drizzle-orm/pg-core").PgTableWithCo
  * Payment method registry — runtime-configurable tokens/chains.
  * Admin inserts a row to enable a new payment method. No deploy needed.
  * Contract addresses are immutable on-chain but configurable here.
+ *
+ * nextIndex is an atomic counter for HD derivation — never reuses an index.
+ * Increment via UPDATE ... SET next_index = next_index + 1 RETURNING next_index.
  */
 export declare const paymentMethods: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "payment_methods";
@@ -373,6 +427,23 @@ export declare const paymentMethods: import("drizzle-orm/pg-core").PgTableWithCo
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        network: import("drizzle-orm/pg-core").PgColumn<{
+            name: "network";
+            tableName: "payment_methods";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         contractAddress: import("drizzle-orm/pg-core").PgColumn<{
             name: "contract_address";
             tableName: "payment_methods";
@@ -526,6 +597,23 @@ export declare const paymentMethods: import("drizzle-orm/pg-core").PgTableWithCo
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        nextIndex: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_index";
+            tableName: "payment_methods";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "created_at";
             tableName: "payment_methods";
@@ -546,6 +634,380 @@ export declare const paymentMethods: import("drizzle-orm/pg-core").PgTableWithCo
     };
     dialect: "pg";
 }>;
+/**
+ * BIP-44 path allocation registry — tracks which derivation paths are in use.
+ * The server knows which paths are allocated so you never collide.
+ * The seed phrase never touches the server — only xpubs.
+ */
+export declare const pathAllocations: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "path_allocations";
+    schema: undefined;
+    columns: {
+        coinType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "coin_type";
+            tableName: "path_allocations";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        accountIndex: import("drizzle-orm/pg-core").PgColumn<{
+            name: "account_index";
+            tableName: "path_allocations";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        chainId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "chain_id";
+            tableName: "path_allocations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        xpub: import("drizzle-orm/pg-core").PgColumn<{
+            name: "xpub";
+            tableName: "path_allocations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        allocatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "allocated_at";
+            tableName: "path_allocations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Webhook delivery outbox — durable retry for payment callbacks.
+ * Inserted when a payment is confirmed. Retried until the receiver ACKs.
+ */
+export declare const webhookDeliveries: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "webhook_deliveries";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "webhook_deliveries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: "always";
+            generated: undefined;
+        }, {}, {}>;
+        chargeId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "charge_id";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        callbackUrl: import("drizzle-orm/pg-core").PgColumn<{
+            name: "callback_url";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "webhook_deliveries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextRetryAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_retry_at";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_error";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Every address ever derived — immutable append-only log.
+ * Used for auditing and ensuring no address is ever reused.
+ */
+export declare const derivedAddresses: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "derived_addresses";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "derived_addresses";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: "always";
+            generated: undefined;
+        }, {}, {}>;
+        chainId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "chain_id";
+            tableName: "derived_addresses";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        derivationIndex: import("drizzle-orm/pg-core").PgColumn<{
+            name: "derivation_index";
+            tableName: "derived_addresses";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        address: import("drizzle-orm/pg-core").PgColumn<{
+            name: "address";
+            tableName: "derived_addresses";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tenantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tenant_id";
+            tableName: "derived_addresses";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "derived_addresses";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 /** Processed transaction IDs for watchers without block cursors (e.g. BTC). */
 export declare const watcherProcessed: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "watcher_processed";

package/dist/db/schema/crypto.js

@@ -1,8 +1,8 @@
 import { sql } from "drizzle-orm";
 import { boolean, index, integer, pgTable, primaryKey, text } from "drizzle-orm/pg-core";
 /**
- * Crypto payment charges — tracks the lifecycle of each BTCPay invoice.
- * reference_id is the BTCPay invoice ID.
+ * Crypto payment charges — tracks the lifecycle of each payment.
+ * reference_id is the charge ID (e.g. "btc:bc1q...").
  *
  * amountUsdCents stores the requested amount in USD cents (integer).
  * This is NOT nanodollars — Credit.fromCents() handles the conversion
@@ -22,6 +22,11 @@ export const cryptoCharges = pgTable("crypto_charges", {
     token: text("token"),
     depositAddress: text("deposit_address"),
     derivationIndex: integer("derivation_index"),
+    callbackUrl: text("callback_url"),
+    /** Expected crypto amount in native units (e.g. "76923" sats, "50000000" USDC base units). Locked at creation. */
+    expectedAmount: text("expected_amount"),
+    /** Running total of received crypto in native units. Accumulates across partial payments. */
+    receivedAmount: text("received_amount"),
 }, (table) => [
     index("idx_crypto_charges_tenant").on(table.tenantId),
     index("idx_crypto_charges_status").on(table.status),
@@ -43,12 +48,16 @@ export const watcherCursors = pgTable("watcher_cursors", {
  * Payment method registry — runtime-configurable tokens/chains.
  * Admin inserts a row to enable a new payment method. No deploy needed.
  * Contract addresses are immutable on-chain but configurable here.
+ *
+ * nextIndex is an atomic counter for HD derivation — never reuses an index.
+ * Increment via UPDATE ... SET next_index = next_index + 1 RETURNING next_index.
  */
 export const paymentMethods = pgTable("payment_methods", {
-    id: text("id").primaryKey(), // "USDC:base", "ETH:base", "BTC:mainnet"
-    type: text("type").notNull(), // "stablecoin", "eth", "btc"
-    token: text("token").notNull(), // "USDC", "ETH", "BTC"
-    chain: text("chain").notNull(), // "base", "ethereum", "bitcoin"
+    id: text("id").primaryKey(), // "btc", "base-usdc", "arb-usdc", "doge"
+    type: text("type").notNull(), // "erc20", "native", "btc"
+    token: text("token").notNull(), // "USDC", "ETH", "BTC", "DOGE"
+    chain: text("chain").notNull(), // "base", "ethereum", "bitcoin", "arbitrum"
+    network: text("network").notNull().default("mainnet"), // "mainnet", "base", "arbitrum"
     contractAddress: text("contract_address"), // null for native (ETH, BTC)
     decimals: integer("decimals").notNull(),
     displayName: text("display_name").notNull(),
@@ -58,8 +67,53 @@ export const paymentMethods = pgTable("payment_methods", {
     oracleAddress: text("oracle_address"), // Chainlink feed address for price (null = 1:1 stablecoin)
     xpub: text("xpub"), // HD wallet extended public key for deposit address derivation
     confirmations: integer("confirmations").notNull().default(1),
+    nextIndex: integer("next_index").notNull().default(0), // atomic derivation counter, never reuses
     createdAt: text("created_at").notNull().default(sql `(now())`),
 });
+/**
+ * BIP-44 path allocation registry — tracks which derivation paths are in use.
+ * The server knows which paths are allocated so you never collide.
+ * The seed phrase never touches the server — only xpubs.
+ */
+export const pathAllocations = pgTable("path_allocations", {
+    coinType: integer("coin_type").notNull(), // BIP44 coin type (0=BTC, 60=ETH, 3=DOGE, 501=SOL)
+    accountIndex: integer("account_index").notNull(), // m/44'/{coin_type}'/{index}'
+    chainId: text("chain_id").references(() => paymentMethods.id),
+    xpub: text("xpub").notNull(),
+    allocatedAt: text("allocated_at").notNull().default(sql `(now())`),
+}, (table) => [primaryKey({ columns: [table.coinType, table.accountIndex] })]);
+/**
+ * Webhook delivery outbox — durable retry for payment callbacks.
+ * Inserted when a payment is confirmed. Retried until the receiver ACKs.
+ */
+export const webhookDeliveries = pgTable("webhook_deliveries", {
+    id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
+    chargeId: text("charge_id").notNull(),
+    callbackUrl: text("callback_url").notNull(),
+    payload: text("payload").notNull(), // JSON stringified
+    status: text("status").notNull().default("pending"), // pending, delivered, failed
+    attempts: integer("attempts").notNull().default(0),
+    nextRetryAt: text("next_retry_at"),
+    lastError: text("last_error"),
+    createdAt: text("created_at").notNull().default(sql `(now())`),
+}, (table) => [
+    index("idx_webhook_deliveries_status").on(table.status),
+    index("idx_webhook_deliveries_charge").on(table.chargeId),
+]);
+/**
+ * Every address ever derived — immutable append-only log.
+ * Used for auditing and ensuring no address is ever reused.
+ */
+export const derivedAddresses = pgTable("derived_addresses", {
+    id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
+    chainId: text("chain_id")
+        .notNull()
+        .references(() => paymentMethods.id),
+    derivationIndex: integer("derivation_index").notNull(),
+    address: text("address").notNull().unique(),
+    tenantId: text("tenant_id"),
+    createdAt: text("created_at").notNull().default(sql `(now())`),
+}, (table) => [index("idx_derived_addresses_chain").on(table.chainId)]);
 /** Processed transaction IDs for watchers without block cursors (e.g. BTC). */
 export const watcherProcessed = pgTable("watcher_processed", {
     watcherId: text("watcher_id").notNull(),