alkanesjs 1.2.5 → 1.2.7

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as bitcoin from 'bitcoinjs-lib';
 import { Network, Psbt, Transaction } from 'bitcoinjs-lib';
-import { Espo as Espo$1 } from 'espo-ts';
+import { BoxedResponse as BoxedResponse$1 } from 'bxrs';
 import { BorshSchema, Infer } from 'borsher';
 import { z } from 'zod';
 import * as ecpair from 'ecpair';
@@ -160,7 +160,7 @@ declare class WaitPacer {
 interface ProviderConfig {
     sandshrewUrl: string;
     electrumApiUrl: string;
-    espoUrl: string;
+    espoUrl?: string;
     network: Network;
     explorerUrl: string;
     defaultFeeRate?: number;
@@ -182,7 +182,7 @@ type AlkanesParsedTraceResult = {
 declare class Provider {
     readonly sandshrewUrl: string;
     readonly electrumApiUrl: string;
-    readonly espoUrl: string;
+    readonly espoUrl?: string;
     readonly network: Network;
     readonly explorerUrl: string;
     readonly pacerSettings: PacerSettings;
@@ -608,19 +608,303 @@ declare class RunesRpcProvider {
     runes_getOutpoint(txidAndVout: string, blockHeight?: string): RpcCall<RunesOutpoint>;
 }
 
-type EspoCtor = new (url: string) => Espo$1;
-declare const Espo: EspoCtor | undefined;
+type EspoAlkaneId = string;
+type EspoOutpoint = string;
+type EspoAmountString = string;
+interface EspoOkResult {
+    ok: true;
+}
+interface EspoKeyValueItem {
+    key_hex: string;
+    key_str: string | null;
+    value_hex: string;
+    value_str: string | null;
+    value_u128: bigint | null;
+    last_txid: string | null;
+}
+interface EspoGetKeysParams {
+    alkane: EspoAlkaneId;
+    try_decode_utf8?: boolean;
+    keys?: string[];
+    limit?: number;
+    page?: number;
+}
+interface EspoGetKeysOk extends EspoOkResult {
+    alkane: EspoAlkaneId;
+    page: number;
+    limit: number;
+    total: number;
+    has_more: boolean;
+    items: Record<string, EspoKeyValueItem>;
+}
+type EspoGetKeys = DeepExpand<UnwrapEspoResult<EspoGetKeysOk>>;
+interface EspoHolder {
+    address: string;
+    amount: number;
+}
+interface EspoGetHoldersParams {
+    alkane: EspoAlkaneId;
+    limit?: number;
+    page?: number;
+}
+interface EspoGetHoldersOk extends EspoOkResult {
+    alkane: EspoAlkaneId;
+    page: number;
+    limit: number;
+    total: number;
+    has_more: boolean;
+    items: EspoHolder[];
+}
+type EspoGetHolders = DeepExpand<UnwrapEspoResult<EspoGetHoldersOk>>;
+interface EspoBalanceEntry {
+    alkane: EspoAlkaneId;
+    amount: number;
+}
+interface EspoOutpointBalance {
+    outpoint: EspoOutpoint;
+    entries: EspoBalanceEntry[];
+}
+interface EspoOutpointBalanceWithAddress extends EspoOutpointBalance {
+    address?: string;
+}
+interface EspoGetAddressBalancesOk extends EspoOkResult {
+    address: string;
+    balances: Record<EspoAlkaneId, number>;
+    outpoints?: EspoOutpointBalance[];
+}
+type EspoGetAddressBalances = DeepExpand<UnwrapEspoResult<EspoGetAddressBalancesOk>>;
+interface EspoGetOutpointBalancesOk extends EspoOkResult {
+    outpoint: EspoOutpoint;
+    items: EspoOutpointBalanceWithAddress[];
+}
+type EspoGetOutpointBalances = DeepExpand<UnwrapEspoResult<EspoGetOutpointBalancesOk>>;
+interface EspoGetHoldersCountOk extends EspoOkResult {
+    count: number;
+}
+type EspoGetHoldersCount = DeepExpand<UnwrapEspoResult<EspoGetHoldersCountOk>>;
+interface EspoGetAddressOutpointsOk extends EspoOkResult {
+    address: string;
+    outpoints: EspoOutpointBalance[];
+}
+type EspoGetAddressOutpoints = DeepExpand<UnwrapEspoResult<EspoGetAddressOutpointsOk>>;
+interface EspoCandle {
+    ts: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+interface EspoGetCandlesParams {
+    pool: EspoAlkaneId;
+    timeframe?: "10m" | "1h" | "1d" | "1w" | "1M" | "m10" | "h1" | "d1" | "w1" | "m1";
+    side?: "base" | "quote";
+    limit?: number;
+    size?: number;
+    page?: number;
+    now?: number;
+}
+interface EspoGetCandlesOk extends EspoOkResult {
+    pool: EspoAlkaneId;
+    timeframe: string;
+    side: "base" | "quote";
+    page: number;
+    limit: number;
+    total: number;
+    has_more: boolean;
+    candles: EspoCandle[];
+}
+type EspoGetCandles = DeepExpand<UnwrapEspoResult<EspoGetCandlesOk>>;
+type EspoTradeSide = "buy" | "sell" | "neutral";
+interface EspoTrade {
+    timestamp: number;
+    txid: string;
+    address: string;
+    xpubkey: Uint8Array;
+    base_inflow: bigint;
+    quote_inflow: bigint;
+    side: EspoTradeSide;
+    amount: number;
+}
+interface EspoGetTradesParams {
+    pool: EspoAlkaneId;
+    limit?: number;
+    page?: number;
+    side?: "base" | "quote";
+    filter_side?: "buy" | "sell" | "all" | "a" | "b" | "s";
+    sort?: string;
+    dir?: "asc" | "desc" | "ascending" | "descending";
+    direction?: "asc" | "desc" | "ascending" | "descending";
+}
+interface EspoGetTradesOk extends EspoOkResult {
+    pool: EspoAlkaneId;
+    side: "base" | "quote";
+    filter_side: "all" | "buy" | "sell";
+    sort: string;
+    dir: "asc" | "desc";
+    page: number;
+    limit: number;
+    total: number;
+    has_more: boolean;
+    trades: EspoTrade[];
+}
+type EspoGetTrades = DeepExpand<UnwrapEspoResult<EspoGetTradesOk>>;
+interface EspoPool {
+    base: EspoAlkaneId;
+    quote: EspoAlkaneId;
+    base_reserve: bigint;
+    quote_reserve: bigint;
+    source: "live";
+}
+interface EspoGetPoolsParams {
+    limit?: number;
+    page?: number;
+}
+interface EspoGetPoolsOk extends EspoOkResult {
+    page: number;
+    limit: number;
+    total: number;
+    has_more: boolean;
+    pools: Record<EspoAlkaneId, EspoPool>;
+}
+type EspoGetPools = DeepExpand<UnwrapEspoResult<EspoGetPoolsOk>>;
+interface EspoSwapHop {
+    pool: EspoAlkaneId;
+    token_in: EspoAlkaneId;
+    token_out: EspoAlkaneId;
+    amount_in: bigint;
+    amount_out: bigint;
+}
+interface EspoFindBestSwapPathParams {
+    mode?: "exact_in" | "exact_out" | "implicit";
+    token_in: EspoAlkaneId;
+    token_out: EspoAlkaneId;
+    amount_in?: EspoAmountString | number;
+    amount_out_min?: EspoAmountString | number;
+    amount_out?: EspoAmountString | number;
+    amount_in_max?: EspoAmountString | number;
+    available_in?: EspoAmountString | number;
+    fee_bps?: number;
+    max_hops?: number;
+}
+interface EspoFindBestSwapPathOk extends EspoOkResult {
+    mode: string;
+    token_in: EspoAlkaneId;
+    token_out: EspoAlkaneId;
+    fee_bps: number;
+    max_hops: number;
+    amount_in: bigint;
+    amount_out: bigint;
+    hops: EspoSwapHop[];
+}
+type EspoFindBestSwapPath = DeepExpand<UnwrapEspoResult<EspoFindBestSwapPathOk>>;
+interface EspoGetBestMevSwapOk extends EspoOkResult {
+    token: EspoAlkaneId;
+    fee_bps: number;
+    max_hops: number;
+    amount_in: bigint;
+    amount_out: bigint;
+    profit: bigint;
+    hops: EspoSwapHop[];
+}
+type EspoGetBestMevSwap = DeepExpand<UnwrapEspoResult<EspoGetBestMevSwapOk>>;
+interface EspoTipHeight {
+    height: number;
+}
+type Keys = readonly PropertyKey[];
+type Strip<T, K extends Keys> = Omit<T, Extract<K[number], keyof T>>;
+type UnwrapEspoResult<T> = Strip<T, ["ok", "error", "hint"]>;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type DeepExpand<T> = T extends Primitive ? T : T extends Array<infer U> ? Array<DeepExpand<U>> : {
+    [K in keyof T]: DeepExpand<T[K]>;
+};
+
+type AmountLike = EspoAmountString | number | bigint;
+type GetKeysOptions = Partial<Omit<EspoGetKeysParams, "alkane" | "try_decode_utf8">> & {
+    try_decode_utf8?: boolean;
+    tryDecodeUtf8?: boolean;
+};
+type GetHoldersOptions = Partial<Omit<EspoGetHoldersParams, "alkane">>;
+type GetAddressBalancesOptions = {
+    include_outpoints?: boolean;
+    includeOutpoints?: boolean;
+};
+type GetCandlesOptions = Partial<Omit<EspoGetCandlesParams, "pool">>;
+type GetTradesOptions = Partial<Omit<EspoGetTradesParams, "pool" | "filter_side">> & {
+    filter_side?: EspoGetTradesParams["filter_side"];
+    filterSide?: EspoGetTradesParams["filter_side"];
+};
+type GetPoolsOptions = Partial<EspoGetPoolsParams>;
+interface FindBestSwapPathOptions {
+    mode?: EspoFindBestSwapPathParams["mode"];
+    amount_in?: AmountLike;
+    amountIn?: AmountLike;
+    amount_out_min?: AmountLike;
+    amountOutMin?: AmountLike;
+    amount_out?: AmountLike;
+    amountOut?: AmountLike;
+    amount_in_max?: AmountLike;
+    amountInMax?: AmountLike;
+    available_in?: AmountLike;
+    availableIn?: AmountLike;
+    fee_bps?: number;
+    feeBps?: number;
+    max_hops?: number;
+    maxHops?: number;
+}
+type GetBestMevSwapOptions = {
+    fee_bps?: number;
+    feeBps?: number;
+    max_hops?: number;
+    maxHops?: number;
+};
+declare class Espo {
+    rpc_url: string;
+    constructor(url: string);
+    private resultToBoxed;
+    private callAndUnbox;
+    private normalizeAmountLike;
+    private parseAmountString;
+    private normalizeBalanceEntry;
+    private hexStringToUint8Array;
+    private toBigIntAmount;
+    private toOptionalBigInt;
+    private normalizePool;
+    private normalizePoolsRecord;
+    private normalizeSwapHop;
+    private normalizeTrade;
+    private normalizeOutpointBalance;
+    private normalizeOutpointBalanceWithAddress;
+    private normalizeBalancesRecord;
+    ping(): Promise<BoxedResponse$1<"pong", string>>;
+    ammdataPing(): Promise<BoxedResponse$1<"pong", string>>;
+    getTipHeight(): Promise<BoxedResponse$1<UnwrapEspoResult<EspoTipHeight>, string>>;
+    getHoldersCount(alkane: EspoAlkaneId): Promise<BoxedResponse$1<EspoGetHoldersCount, string>>;
+    getKeys(alkane: EspoAlkaneId, options?: GetKeysOptions): Promise<BoxedResponse$1<EspoGetKeys, string>>;
+    getHolders(alkane: EspoAlkaneId, options?: GetHoldersOptions): Promise<BoxedResponse$1<EspoGetHolders, string>>;
+    getAddressBalances(address: string, options?: GetAddressBalancesOptions): Promise<BoxedResponse$1<EspoGetAddressBalances, string>>;
+    getOutpointBalances(outpoint: EspoOutpoint): Promise<BoxedResponse$1<EspoGetOutpointBalances, string>>;
+    getAddressOutpoints(address: string): Promise<BoxedResponse$1<EspoGetAddressOutpoints, string>>;
+    getCandles(pool: EspoAlkaneId, options?: GetCandlesOptions): Promise<BoxedResponse$1<EspoGetCandles, string>>;
+    getTrades(pool: EspoAlkaneId, options?: GetTradesOptions): Promise<BoxedResponse$1<EspoGetTrades, string>>;
+    getPools(options?: GetPoolsOptions): Promise<BoxedResponse$1<EspoGetPools, string>>;
+    findBestSwapPath(tokenIn: EspoAlkaneId, tokenOut: EspoAlkaneId, options?: FindBestSwapPathOptions): Promise<BoxedResponse$1<EspoFindBestSwapPath, string>>;
+    getBestMevSwap(token: EspoAlkaneId, options?: GetBestMevSwapOptions): Promise<BoxedResponse$1<EspoGetBestMevSwap, string>>;
+}
+
 declare class EspoRpcProvider extends Espo {
     constructor(providerOrUrl: Provider | string);
 }
 
 declare class BaseRpcProvider {
+    private readonly coreProvider;
+    private espoProvider?;
     readonly electrum: ElectrumApiProvider;
     readonly ord: OrdRpcProvider;
     readonly alkanes: AlkanesRpcProvider;
     readonly sandshrew: SandshrewRpcProvider;
     readonly runes: RunesRpcProvider;
-    readonly espo: EspoRpcProvider;
+    get espo(): EspoRpcProvider;
     constructor(coreProvider: Provider);
 }