@morpho-dev/router 0.0.12 → 0.0.14

package/dist/index.node.d.cts

@@ -1,8 +1,18 @@
-import { Offer, Errors } from '@morpho-dev/mempool';
+import { Offer, Errors, Format } from '@morpho-dev/mempool';
 export * from '@morpho-dev/mempool';
 import * as viem from 'viem';
 import { Address, Account, Hex, PublicClient } from 'viem';
 import { Chain as Chain$2 } from 'viem/chains';
+import * as node_modules_zod_openapi_dist_components_DkyUTLcs_js from 'node_modules/zod-openapi/dist/components-DkyUTLcs.js';
+import * as zod_v4 from 'zod/v4';
+import { z, ZodError } from 'zod/v4';
+import * as zod_v4_core from 'zod/v4/core';
+import { PGlite } from '@electric-sql/pglite';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { drizzle as drizzle$1 } from 'drizzle-orm/pglite';
+import { Pool } from 'pg';
+export * from 'drizzle-orm';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
 
 type Compute<type> = {
     [key in keyof type]: type[key];
@@ -36,22 +46,173 @@ declare namespace Chain$1 {
   export { type Chain$1_Chain as Chain, type Chain$1_ChainId as ChainId, type Chain$1_ChainName as ChainName, Chain$1_chainIds as chainIds, Chain$1_chainNames as chainNames, Chain$1_chains as chains, Chain$1_getChain as getChain };
 }
 
+declare const OpenApi: node_modules_zod_openapi_dist_components_DkyUTLcs_js.OpenAPIObject;
+
+declare const schemas: {
+    readonly get_offers: z.ZodObject<{
+        creators: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
+        side: z.ZodOptional<z.ZodEnum<{
+            buy: "buy";
+            sell: "sell";
+        }>>;
+        chains: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number[], string>>>;
+        loan_tokens: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
+        status: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<("valid" | "callback_not_supported" | "callback_error" | "unverified")[], string>>>;
+        callback_addresses: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
+        min_amount: z.ZodOptional<z.ZodBigInt>;
+        max_amount: z.ZodOptional<z.ZodBigInt>;
+        min_rate: z.ZodOptional<z.ZodBigInt>;
+        max_rate: z.ZodOptional<z.ZodBigInt>;
+        min_maturity: z.ZodPipe<z.ZodOptional<z.ZodBigInt>, z.ZodTransform<number | undefined, bigint | undefined>>;
+        max_maturity: z.ZodPipe<z.ZodOptional<z.ZodBigInt>, z.ZodTransform<number | undefined, bigint | undefined>>;
+        min_expiry: z.ZodPipe<z.ZodOptional<z.ZodBigInt>, z.ZodTransform<number | undefined, bigint | undefined>>;
+        max_expiry: z.ZodPipe<z.ZodOptional<z.ZodBigInt>, z.ZodTransform<number | undefined, bigint | undefined>>;
+        collateral_assets: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
+        collateral_oracles: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
+        collateral_tuple: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<{
+            asset: string;
+            oracle: string | undefined;
+            lltv: number | undefined;
+        }[], string>>>;
+        min_lltv: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+        max_lltv: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+        sort_by: z.ZodOptional<z.ZodEnum<{
+            rate: "rate";
+            maturity: "maturity";
+            expiry: "expiry";
+            amount: "amount";
+        }>>;
+        sort_order: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>>;
+    }, z.core.$strip>;
+    readonly match_offers: z.ZodObject<{
+        side: z.ZodEnum<{
+            buy: "buy";
+            sell: "sell";
+        }>;
+        chain_id: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>;
+        rate: z.ZodOptional<z.ZodBigInt>;
+        collaterals: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<{
+            asset: string;
+            oracle: string;
+            lltv: bigint;
+        }[], string>>>;
+        maturity: z.ZodPipe<z.ZodOptional<z.ZodBigInt>, z.ZodTransform<number | undefined, bigint | undefined>>;
+        min_maturity: z.ZodPipe<z.ZodOptional<z.ZodBigInt>, z.ZodTransform<number | undefined, bigint | undefined>>;
+        max_maturity: z.ZodPipe<z.ZodOptional<z.ZodBigInt>, z.ZodTransform<number | undefined, bigint | undefined>>;
+        loan_token: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        creator: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        status: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<("valid" | "callback_not_supported" | "callback_error" | "unverified")[], string>>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>>;
+    }, z.core.$strip>;
+};
+type Action = keyof typeof schemas;
+declare function parse<A extends Action>(action: A, query: unknown): z.infer<(typeof schemas)[A]>;
+declare function safeParse<A extends Action>(action: A, query: unknown): z.ZodSafeParseResult<z.infer<(typeof schemas)[A]>>;
+
+declare const index$1_OpenApi: typeof OpenApi;
+declare const index$1_parse: typeof parse;
+declare const index$1_safeParse: typeof safeParse;
+declare namespace index$1 {
+  export { index$1_OpenApi as OpenApi, index$1_parse as parse, index$1_safeParse as safeParse };
+}
+
 declare const OfferStatusValues: readonly ["valid", "callback_not_supported", "callback_error", "unverified"];
 type OfferStatus = (typeof OfferStatusValues)[number];
 type OfferMetadata = {
     issue: string;
 };
 type RouterOffer = Offer.Offer & {
+    consumed: bigint;
     status: OfferStatus;
     metadata?: OfferMetadata;
 };
+declare const RouterOfferSchema: (parameters?: {
+    omitHash?: boolean;
+}) => zod_v4.ZodObject<{
+    offering: zod_v4.ZodPipe<zod_v4.ZodString, zod_v4.ZodTransform<`0x${string}`, string>>;
+    assets: zod_v4.ZodBigInt;
+    rate: zod_v4.ZodBigInt;
+    maturity: zod_v4.ZodNumber;
+    expiry: zod_v4.ZodNumber;
+    start: zod_v4.ZodNumber;
+    nonce: zod_v4.ZodBigInt;
+    buy: zod_v4.ZodBoolean;
+    chainId: zod_v4.ZodBigInt;
+    loanToken: zod_v4.ZodPipe<zod_v4.ZodString, zod_v4.ZodTransform<`0x${string}`, string>>;
+    collaterals: zod_v4.ZodArray<zod_v4.ZodObject<{
+        asset: zod_v4.ZodPipe<zod_v4.ZodString, zod_v4.ZodTransform<`0x${string}`, string>>;
+        oracle: zod_v4.ZodPipe<zod_v4.ZodString, zod_v4.ZodTransform<`0x${string}`, string>>;
+        lltv: zod_v4.ZodBigInt;
+    }, zod_v4_core.$strip>>;
+    callback: zod_v4.ZodObject<{
+        address: zod_v4.ZodPipe<zod_v4.ZodString, zod_v4.ZodTransform<`0x${string}`, string>>;
+        data: zod_v4.ZodPipe<zod_v4.ZodString, zod_v4.ZodTransform<`0x${string}`, string>>;
+        gasLimit: zod_v4.ZodBigInt;
+    }, zod_v4_core.$strip>;
+    signature: zod_v4.ZodOptional<zod_v4.ZodPipe<zod_v4.ZodString, zod_v4.ZodTransform<`0x${string}`, string>>>;
+    createdAt: zod_v4.ZodOptional<zod_v4.ZodNumber>;
+    consumed: z.ZodBigInt;
+    status: z.ZodEnum<{
+        valid: "valid";
+        callback_not_supported: "callback_not_supported";
+        callback_error: "callback_error";
+        unverified: "unverified";
+    }>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        issue: z.ZodString;
+    }, z.core.$strip>>;
+}, zod_v4_core.$strip>;
+/**
+ * Creates a router offer from a plain object.
+ * @throws {InvalidRouterOfferError} If the router offer is invalid.
+ * @param input - The router offer to create.
+ * @returns The created router offer with its hash.
+ */
+declare function from(input: Omit<RouterOffer, "hash">): RouterOffer;
+declare namespace from {
+    type ErrorType = InvalidRouterOfferError;
+}
+/**
+ * Creates a router offer from a snake case object.
+ * @throws {InvalidRouterOfferError} If the router offer is invalid.
+ * @param input - The router offer to create.
+ * @returns The created router offer with its hash.
+ */
+declare function fromSnakeCase(input: Format.Snake<Omit<RouterOffer, "hash">>): RouterOffer;
+declare namespace fromSnakeCase {
+    type ErrorType = InvalidRouterOfferError;
+}
+/**
+ * Converts a router offer to a snake case object.
+ * @param offer - The router offer to convert.
+ * @returns The converted router offer.
+ */
+declare function toSnakeCase(offer: RouterOffer): Format.Snake<RouterOffer>;
+declare function random(): RouterOffer;
+declare class InvalidRouterOfferError extends Errors.BaseError<ZodError | Error> {
+    readonly name = "RouterOffer.InvalidRouterOfferError";
+    constructor(error: ZodError | Error);
+}
 
+type RouterOffer$1_InvalidRouterOfferError = InvalidRouterOfferError;
+declare const RouterOffer$1_InvalidRouterOfferError: typeof InvalidRouterOfferError;
 type RouterOffer$1_OfferMetadata = OfferMetadata;
 type RouterOffer$1_OfferStatus = OfferStatus;
 declare const RouterOffer$1_OfferStatusValues: typeof OfferStatusValues;
 type RouterOffer$1_RouterOffer = RouterOffer;
+declare const RouterOffer$1_RouterOfferSchema: typeof RouterOfferSchema;
+declare const RouterOffer$1_from: typeof from;
+declare const RouterOffer$1_fromSnakeCase: typeof fromSnakeCase;
+declare const RouterOffer$1_random: typeof random;
+declare const RouterOffer$1_toSnakeCase: typeof toSnakeCase;
 declare namespace RouterOffer$1 {
-  export { type RouterOffer$1_OfferMetadata as OfferMetadata, type RouterOffer$1_OfferStatus as OfferStatus, RouterOffer$1_OfferStatusValues as OfferStatusValues, type RouterOffer$1_RouterOffer as RouterOffer };
+  export { RouterOffer$1_InvalidRouterOfferError as InvalidRouterOfferError, type RouterOffer$1_OfferMetadata as OfferMetadata, type RouterOffer$1_OfferStatus as OfferStatus, RouterOffer$1_OfferStatusValues as OfferStatusValues, type RouterOffer$1_RouterOffer as RouterOffer, RouterOffer$1_RouterOfferSchema as RouterOfferSchema, RouterOffer$1_from as from, RouterOffer$1_fromSnakeCase as fromSnakeCase, RouterOffer$1_random as random, RouterOffer$1_toSnakeCase as toSnakeCase };
 }
 
 type GetParameters = {
@@ -203,6 +364,758 @@ declare class HttpGetOffersFailedError extends Errors.BaseError {
     });
 }
 
+type PgDB = ReturnType<typeof drizzle> & {
+    name: "pg";
+    pool: Pool;
+};
+type PGLiteDB = ReturnType<typeof drizzle$1> & {
+    name: "pglite";
+    pool: PGlite;
+};
+type DB = PgDB | PGLiteDB;
+declare function create$1({ type, endpoint, }: {
+    type?: "pg" | "pglite";
+    endpoint?: string;
+}): DB;
+declare function applyMigrations(db: DB): Promise<void>;
+declare function applyMigrationsPostgres(db: DB): Promise<void>;
+declare function clean(db: DB): Promise<void>;
+
+type OfferDB_DB = DB;
+declare const OfferDB_applyMigrations: typeof applyMigrations;
+declare const OfferDB_applyMigrationsPostgres: typeof applyMigrationsPostgres;
+declare const OfferDB_clean: typeof clean;
+declare namespace OfferDB {
+  export { type OfferDB_DB as DB, OfferDB_applyMigrations as applyMigrations, OfferDB_applyMigrationsPostgres as applyMigrationsPostgres, OfferDB_clean as clean, create$1 as create };
+}
+
+type GetOffersFilters = {
+    creators?: string[];
+    side?: "buy" | "sell";
+    chains?: number[];
+    loanTokens?: string[];
+    status?: OfferStatus[];
+    callbackAddresses?: string[];
+    minAmount?: bigint;
+    maxAmount?: bigint;
+    minRate?: bigint;
+    maxRate?: bigint;
+    minMaturity?: number;
+    maxMaturity?: number;
+    minExpiry?: number;
+    maxExpiry?: number;
+    collateralAssets?: string[];
+    collateralOracles?: string[];
+    collateralTuple?: Array<{
+        asset: string;
+        oracle?: string;
+        lltv?: number;
+    }>;
+    minLltv?: number;
+    maxLltv?: number;
+    sortBy?: "rate" | "maturity" | "expiry" | "amount";
+    sortOrder?: "asc" | "desc";
+    cursor?: string;
+    limit?: number;
+};
+interface FindMatchingOffersParams {
+    side: "buy" | "sell";
+    chainId: number;
+    rate?: bigint;
+    collaterals?: Array<{
+        asset: string;
+        oracle: string;
+        lltv: bigint;
+    }>;
+    maturity?: number;
+    minMaturity?: number;
+    maxMaturity?: number;
+    loanToken?: string;
+    creator?: string;
+    /** Filter by offer status; if omitted defaults to ["valid"] */
+    status?: OfferStatus[];
+    /** Cursor string returned by a previous call, for pagination */
+    cursor?: string;
+    /** Page size; defaults to 20 */
+    limit?: number;
+}
+interface GetAllParams {
+    query?: GetOffersFilters;
+}
+type OfferRepositoryConfig = {
+    /** The database instance to use for operations. */
+    db: DB;
+};
+/**
+ * The `OfferRepository` is responsible for managing offer data in the database.
+ */
+type OfferRepository = {
+    /** Create a single offer in the database. */
+    create: (parameters: {
+        offer: Offer.Offer;
+        status: OfferStatus;
+        metadata?: OfferMetadata;
+    }) => Promise<string>;
+    /** Create multiple offers in the database. */
+    createMany: (parameters: {
+        offer: Offer.Offer;
+        status: OfferStatus;
+        metadata?: OfferMetadata;
+    }[]) => Promise<string[]>;
+    /** Get all offers from the database with optional filtering, sorting, and pagination. */
+    getAll: (params?: GetAllParams) => Promise<{
+        offers: RouterOffer[];
+        nextCursor: string | null;
+    }>;
+    /** Find offers that match the specified parameters, with cursor pagination. */
+    findMatchingOffers: (params: FindMatchingOffersParams) => Promise<{
+        offers: RouterOffer[];
+        nextCursor: string | null;
+    }>;
+    /** Delete an offer and its associated collaterals by hash. */
+    delete: (hash: Offer.Offer["hash"]) => Promise<boolean>;
+    /** Delete multiple offers and their associated collaterals by hashes. */
+    deleteMany: (hashes: Offer.Offer["hash"][]) => Promise<number>;
+    /** Update the status of an offer. */
+    updateStatus: (parameters: {
+        offerHash: Offer.Offer["hash"];
+        status: OfferStatus;
+        metadata?: OfferMetadata;
+    }) => Promise<void>;
+    updateConsumedAmount: (parameters: {
+        chainId: Offer.Offer["chainId"];
+        offering: Offer.Offer["offering"];
+        nonce: Offer.Offer["nonce"];
+        consumed: bigint;
+    }) => Promise<void>;
+};
+/**
+ * Creates a new OfferRepository instance.
+ */
+declare function create(config: OfferRepositoryConfig): OfferRepository;
+type TestOfferRepository = OfferRepository;
+declare function createTest(): TestOfferRepository;
+
+type OfferRepository$1_FindMatchingOffersParams = FindMatchingOffersParams;
+type OfferRepository$1_GetAllParams = GetAllParams;
+type OfferRepository$1_GetOffersFilters = GetOffersFilters;
+type OfferRepository$1_OfferRepository = OfferRepository;
+type OfferRepository$1_OfferRepositoryConfig = OfferRepositoryConfig;
+type OfferRepository$1_TestOfferRepository = TestOfferRepository;
+declare const OfferRepository$1_create: typeof create;
+declare const OfferRepository$1_createTest: typeof createTest;
+declare namespace OfferRepository$1 {
+  export { type OfferRepository$1_FindMatchingOffersParams as FindMatchingOffersParams, type OfferRepository$1_GetAllParams as GetAllParams, type OfferRepository$1_GetOffersFilters as GetOffersFilters, type OfferRepository$1_OfferRepository as OfferRepository, type OfferRepository$1_OfferRepositoryConfig as OfferRepositoryConfig, type OfferRepository$1_TestOfferRepository as TestOfferRepository, OfferRepository$1_create as create, OfferRepository$1_createTest as createTest };
+}
+
+declare const offers: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "offers";
+    schema: undefined;
+    columns: {
+        hash: drizzle_orm_pg_core.PgColumn<{
+            name: "hash";
+            tableName: "offers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 66;
+        }>;
+        offering: drizzle_orm_pg_core.PgColumn<{
+            name: "offering";
+            tableName: "offers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 42;
+        }>;
+        assets: drizzle_orm_pg_core.PgColumn<{
+            name: "assets";
+            tableName: "offers";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rate: drizzle_orm_pg_core.PgColumn<{
+            name: "rate";
+            tableName: "offers";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maturity: drizzle_orm_pg_core.PgColumn<{
+            name: "maturity";
+            tableName: "offers";
+            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;
+        }, {}, {}>;
+        expiry: drizzle_orm_pg_core.PgColumn<{
+            name: "expiry";
+            tableName: "offers";
+            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;
+        }, {}, {}>;
+        start: drizzle_orm_pg_core.PgColumn<{
+            name: "start";
+            tableName: "offers";
+            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;
+        }, {}, {}>;
+        nonce: drizzle_orm_pg_core.PgColumn<{
+            name: "nonce";
+            tableName: "offers";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        buy: drizzle_orm_pg_core.PgColumn<{
+            name: "buy";
+            tableName: "offers";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        chainId: drizzle_orm_pg_core.PgColumn<{
+            name: "chain_id";
+            tableName: "offers";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        loanToken: drizzle_orm_pg_core.PgColumn<{
+            name: "loan_token";
+            tableName: "offers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 42;
+        }>;
+        callbackAddress: drizzle_orm_pg_core.PgColumn<{
+            name: "callback_address";
+            tableName: "offers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 42;
+        }>;
+        callbackData: drizzle_orm_pg_core.PgColumn<{
+            name: "callback_data";
+            tableName: "offers";
+            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;
+        }, {}, {}>;
+        callbackGasLimit: drizzle_orm_pg_core.PgColumn<{
+            name: "callback_gas_limit";
+            tableName: "offers";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        signature: drizzle_orm_pg_core.PgColumn<{
+            name: "signature";
+            tableName: "offers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 132;
+        }>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "offers";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const offerCollaterals: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "offer_collaterals";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "offer_collaterals";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        offerHash: drizzle_orm_pg_core.PgColumn<{
+            name: "offer_hash";
+            tableName: "offer_collaterals";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 66;
+        }>;
+        asset: drizzle_orm_pg_core.PgColumn<{
+            name: "asset";
+            tableName: "offer_collaterals";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 42;
+        }>;
+        oracle: drizzle_orm_pg_core.PgColumn<{
+            name: "oracle";
+            tableName: "offer_collaterals";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 42;
+        }>;
+        lltv: drizzle_orm_pg_core.PgColumn<{
+            name: "lltv";
+            tableName: "offer_collaterals";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const offerStatus: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "offer_status";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "offer_status";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        offerHash: drizzle_orm_pg_core.PgColumn<{
+            name: "offer_hash";
+            tableName: "offer_status";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 66;
+        }>;
+        status: drizzle_orm_pg_core.PgColumn<{
+            name: "status";
+            tableName: "offer_status";
+            dataType: "string";
+            columnType: "PgText";
+            data: "valid" | "callback_not_supported" | "callback_error" | "unverified";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "valid" | "callback_not_supported" | "callback_error" | "unverified";
+        }>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "offer_status";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "offer_status";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const consumed: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "consumed_per_user_and_nonce";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "consumed_per_user_and_nonce";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        chainId: drizzle_orm_pg_core.PgColumn<{
+            name: "chain_id";
+            tableName: "consumed_per_user_and_nonce";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        offering: drizzle_orm_pg_core.PgColumn<{
+            name: "offering";
+            tableName: "consumed_per_user_and_nonce";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 42;
+        }>;
+        nonce: drizzle_orm_pg_core.PgColumn<{
+            name: "nonce";
+            tableName: "consumed_per_user_and_nonce";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        consumed: drizzle_orm_pg_core.PgColumn<{
+            name: "consumed";
+            tableName: "consumed_per_user_and_nonce";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "consumed_per_user_and_nonce";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+
+/**
+ * Start a local router server.
+ * @example
+ * ```ts
+ * import { Router } from "@morpho-dev/router";
+ * await Router.serve(); // local router server running on http://localhost:8081
+ * ```
+ */
+declare function serve(parameters: {
+    port: number;
+    store?: OfferRepository;
+}): Promise<void>;
+
 type index_Client = Client;
 type index_GetParameters = GetParameters;
 type index_HttpForbiddenError = HttpForbiddenError;
@@ -220,8 +1133,9 @@ type index_RouterClientConfig = RouterClientConfig;
 declare const index_connect: typeof connect;
 declare const index_get: typeof get;
 declare const index_match: typeof match;
+declare const index_serve: typeof serve;
 declare namespace index {
-  export { type index_Client as Client, type index_GetParameters as GetParameters, index_HttpForbiddenError as HttpForbiddenError, index_HttpGetOffersFailedError as HttpGetOffersFailedError, index_HttpRateLimitError as HttpRateLimitError, index_HttpUnauthorizedError as HttpUnauthorizedError, index_InvalidUrlError as InvalidUrlError, type index_MatchParameters as MatchParameters, type index_RouterClientConfig as RouterClientConfig, index_connect as connect, index_get as get, index_match as match };
+  export { type index_Client as Client, type index_GetParameters as GetParameters, index_HttpForbiddenError as HttpForbiddenError, index_HttpGetOffersFailedError as HttpGetOffersFailedError, index_HttpRateLimitError as HttpRateLimitError, index_HttpUnauthorizedError as HttpUnauthorizedError, index_InvalidUrlError as InvalidUrlError, type index_MatchParameters as MatchParameters, type index_RouterClientConfig as RouterClientConfig, index_connect as connect, index_get as get, index_match as match, index_serve as serve };
 }
 
 declare const users: Account[];
@@ -297,13 +1211,13 @@ declare const types: readonly ["offer_created", "offer_matched", "offer_validati
 type Type = (typeof types)[number];
 type EventPayload = {
     offer_created: {
-        readonly offer: RouterOffer;
+        readonly offer: Offer.Offer;
     };
     offer_matched: {
-        readonly offer: RouterOffer;
+        readonly offer: Offer.Offer;
     };
     offer_validation: {
-        readonly offer: RouterOffer;
+        readonly offer: Offer.Offer;
     };
 };
 type BaseEvent<T extends Type> = {
@@ -347,6 +1261,19 @@ declare namespace RouterEvent$1 {
  */
 declare function batch$1<T>(array: Array<T>, batchSize: number): Generator<T[], void, unknown>;
 
+type Cursor = {
+    sort: "rate" | "maturity" | "expiry" | "amount";
+    dir: "asc" | "desc";
+    rate?: string;
+    maturity?: number;
+    expiry?: number;
+    assets?: string;
+    hash: string;
+};
+declare function validateCursor(cursor: unknown): cursor is Cursor;
+declare function encodeCursor(c: Cursor): string;
+declare function decodeCursor(token?: string): Cursor | null;
+
 /**
  * Polls a function at a specified interval.
  * Inspired by https://github.com/wevm/viem/blob/845994d20275d08ff892018e237a4b599eeefb6a/src/utils/poll.ts
@@ -606,4 +1533,4 @@ declare namespace Validation {
   export { type Validation_Issue as Issue, type Validation_Result as Result, Validation_run as run };
 }
 
-export { Chain$1 as Chain, type Compute, EVM, Logger$1 as Logger, index as Router, RouterEvent$1 as RouterEvent, RouterOffer$1 as RouterOffer, Validation, ValidationRule, batch$1 as batch, poll, wait };
+export { index$1 as ApiSchema, Chain$1 as Chain, type Compute, type Cursor, EVM, Logger$1 as Logger, OfferDB, OfferRepository$1 as OfferRepository, index as Router, RouterEvent$1 as RouterEvent, RouterOffer$1 as RouterOffer, Validation, ValidationRule, batch$1 as batch, consumed, decodeCursor, encodeCursor, offerCollaterals, offerStatus, offers, poll, validateCursor, wait };