@velora-dex/sdk/dist/methods/delta/types.d.ts

Velora SDK

import type { Prettify } from 'ts-essentials';
import type { Address } from '../../types';
import type { TypedDataField } from '../common/orders/buildOrderData';
import type { Bridge, DeltaOrderType, DeltaOrderUnion, OnChainOrderMap, OnChainOrderType } from './helpers/types';
/** @description Response from POST /v2/delta/orders/build — EIP-712 typed data ready to sign. */
export type BuiltDeltaOrder<T extends DeltaOrderUnion = DeltaOrderUnion> = {
    toSign: {
        domain: {
            name: string;
            version: string;
            chainId: number;
            verifyingContract: string;
        };
        /** EIP-712 type definitions keyed by type name. */
        types: Record<string, TypedDataField[]>;
        /** The on-chain order struct value to sign. */
        value: T;
    };
    /** EIP-712 order hash. */
    orderHash: string;
};
/** @description Token identity used across v2 endpoints. */
export type DeltaPriceToken = {
    chainId: number;
    address: Address;
};
/** @description A token amount with its USD value, used uniformly for inputs, outputs, and fees. */
export type DeltaTokenAmount = {
    token: DeltaPriceToken;
    /** @description Amount in wei. */
    amount: string;
    /** @description USD value of the amount. */
    amountUSD: string;
};
/** @description Bridge tag used to mark routes as recommended / fastest / best-return. */
export type BridgeTag = 'recommended' | 'fastest' | 'best-return';
/** @description Subset of the on-chain Bridge struct returned in v2 price responses.
 *  (the full `route` object is passed to the server when building an order). */
export type DeltaRouteBridgeContractParams = Omit<Bridge, 'destinationChainId'>;
/** @description Bridge details on a route. Same-chain routes carry `null` for `route.bridge`. */
export type DeltaRouteBridge = {
    /** @description Bridge protocol identifier (e.g. "Across", "Relay", "Mayan"). */
    protocol: string;
    /** @description Estimated bridging time in milliseconds. */
    estimatedTimeMs: number;
    /** @description Tags for this route ("recommended", "fastest", "best-return"). May be empty. */
    tags: BridgeTag[];
    /** @description Bridge contract parameters as returned by the server. */
    contractParams: DeltaRouteBridgeContractParams;
};
/** @description A single step of a route (origin chain or destination chain). */
export type DeltaRouteStep = {
    /** @description The token amount entering this step (before any per-step swap). */
    input: DeltaTokenAmount;
    /** @description The token amount exiting this step (after any per-step swap). */
    output: DeltaTokenAmount;
};
/** @description A route describes how the swap flows from origin chain to destination chain. */
export type DeltaRoute = {
    /** @description Source-chain step. The on-chain Delta order's amounts come from `origin.input` and `origin.output`. */
    origin: DeltaRouteStep;
    /** @description Destination-chain step. For same-chain routes this mirrors `origin`. */
    destination: DeltaRouteStep;
    /** @description Bridge details. `null` for same-chain routes. */
    bridge: DeltaRouteBridge | null;
    /** @description Fee breakdown for this route. */
    fees: {
        /** @description Gas fee (single DeltaTokenAmount on the source chain). */
        gas: DeltaTokenAmount;
        /** @description Bridge fees (empty array for same-chain). */
        bridge: DeltaTokenAmount[];
    };
};
/** @description v2 price response: route-based, cross-chain first. */
export type DeltaPrice = {
    /** @description Unique request ID for tracing. */
    id: string;
    /** @description Order side. */
    side: 'SELL' | 'BUY';
    /** @description Token the user trades (identity only — amounts live in route.origin.input). */
    inputToken: DeltaPriceToken;
    /** @description Token the user receives (identity only — amounts live in route.destination.output). */
    outputToken: DeltaPriceToken;
    /** @description Recommended route with full amounts and bridge details. */
    route: DeltaRoute;
    /** @description Partner info attached to this price. */
    partner: {
        name: string;
        /** @description Partner fee in percent (e.g. 0.12 = 0.12%). */
        feePercent: number;
    };
    /** @description Address to approve for spending the input token. */
    spender: Address;
    /** @description Alternative routes (other bridges). Each is a full DeltaRoute. */
    alternatives: DeltaRoute[];
};
/** @description
 * A flat bridge-routes entry returned by GET /v2/delta/prices/bridge-routes (better version of v1 prices/bridge-info).
 * Can be used to populate bridge selection UIs and to validate that bridge is possible for a given src/dest pair before calling GET /v2/delta/prices.
 * */
export type BridgeRoute = {
    srcChainId: number;
    destChainId: number;
    /** @description Output tokens supported on the dest chain for this src→dest pair. */
    tokens: Address[];
};
/** @description Integrator-facing order status returned by v2 order endpoints. */
declare const DeltaOrderStatusMap: {
    readonly Pending: "PENDING";
    readonly AwaitingSignature: "AWAITING_SIGNATURE";
    readonly Active: "ACTIVE";
    readonly Suspended: "SUSPENDED";
    readonly Cancelling: "CANCELLING";
    readonly Bridging: "BRIDGING";
    readonly Completed: "COMPLETED";
    readonly Failed: "FAILED";
    readonly Expired: "EXPIRED";
    readonly Cancelled: "CANCELLED";
    readonly Refunded: "REFUNDED";
    readonly Refunding: "REFUNDING";
};
export type DeltaOrderStatus = (typeof DeltaOrderStatusMap)[keyof typeof DeltaOrderStatusMap];
/** @description Token side on an order. SELL provides an explicit `amount`; BUY provides expected/executed amounts. */
export type DeltaTokenSide = {
    chainId: number;
    token: Address;
    amount: string;
} | {
    chainId: number;
    token: Address;
    expectedAmount: string | null;
    executedAmount: string | null;
};
/** @description A single transaction entry on a v2 order. */
export type DeltaTransaction = {
    originTx: string;
    destinationTx: string | null;
    /** @description Filled percent of the slice (0–100). */
    filledPercent: number;
    spentAmount: string | null;
    receivedAmount: string | null;
};
export type BridgeRefundMetadata = {
    tx: string;
    chainId: number;
    token: Address;
    amount: string;
};
type DeltaAuctionBase = {
    id: string;
    status: DeltaOrderStatus;
    side: 'SELL' | 'BUY';
    type: DeltaOrderType;
    input: DeltaTokenSide;
    output: DeltaTokenSide;
    owner: Address;
    beneficiary: Address;
    orderHash: string;
    partner: string;
    transactions: DeltaTransaction[];
    refunds: BridgeRefundMetadata[];
    /** @description ISO datetime string. */
    createdAt: string;
    /** @description ISO datetime string. */
    updatedAt: string;
    /** @description ISO datetime string. */
    expiresAt: string;
};
/** @description Order shape returned by GET /v2/orders, /v2/orders/:id, /v2/orders/hash/:hash.
 *  Generic over `onChainOrderType` like v1's `DeltaAuction`: the type distributes over the
 *  union so that `order` narrows to the matching family (`OnChainOrderMap[T]`). */
export type DeltaAuction<T extends OnChainOrderType = OnChainOrderType> = T extends T ? Prettify<DeltaAuctionBase & {
    onChainOrderType: T;
    order: OnChainOrderMap[T];
}> : never;
export {};
//# sourceMappingURL=types.d.ts.map