@avail-project/ca-common 2.3.0 → 3.0.0

package/dist/esm/xcs/selectsources.js

@@ -1,251 +0,0 @@
-import Decimal from "decimal.js";
-import { QuoteSeriousness, QuoteType, } from "./iface";
-import { AggregateAggregatorsMode, aggregateAggregators, AutoSelectionError, } from "./autochoice";
-import { ChaindataMap, convertDecimalToBigInt, CurrencyID, } from "../data";
-const safetyMultiplier = new Decimal("1.025");
-export async function selectSources(args) {
-    const { sources, outputRequired, aggregators, commonCurrencyID = CurrencyID.USDC, prefixHeadroom = new Decimal("1.25"), } = args;
-    console.debug("XCS | SS:", {
-        sources,
-        outputRequired: outputRequired.toFixed(),
-        prefixHeadroom: prefixHeadroom.toFixed(),
-    });
-    const cotList = [];
-    const nonCOTQuotes = [];
-    for (const [idx, src] of sources.entries()) {
-        const chain = ChaindataMap.get(src.chainID);
-        if (chain == null) {
-            throw new AutoSelectionError("Chain not found");
-        }
-        const cot = chain.Currencies.find((c) => c.currencyID === commonCurrencyID);
-        if (cot == null) {
-            console.debug("XCS | SS | Skipping source — no COT on chain", { chain });
-            continue;
-        }
-        const originalHolding = {
-            chainID: src.chainID,
-            tokenAddress: src.tokenAddress,
-            amountRaw: src.amountRaw,
-        };
-        if (Buffer.compare(src.tokenAddress, cot.tokenAddress) === 0) {
-            const normalizedAmount = new Decimal(src.amountRaw.toString()).div(Decimal.pow(10, cot.decimals));
-            cotList.push({
-                amount: normalizedAmount,
-                idx,
-                chainID: src.chainID,
-                currency: cot,
-                originalHolding,
-            });
-        }
-        else {
-            nonCOTQuotes.push({
-                req: {
-                    userAddress: src.takerAddress,
-                    receiverAddress: src.receiverAddress,
-                    type: QuoteType.EXACT_IN,
-                    chain: chain.ChainID,
-                    inputToken: src.tokenAddress,
-                    inputAmount: src.amountRaw,
-                    outputToken: cot.tokenAddress,
-                    seriousness: QuoteSeriousness.PRICE_SURVEY,
-                },
-                originalHolding,
-                cur: cot,
-                idx,
-                value: src.value,
-            });
-        }
-    }
-    // Continuous-COT fast path — covers outputRequired without touching any aggregator.
-    if (cotList.length > 0 && cotList[0].idx === 0) {
-        let continuousAmount = new Decimal(0);
-        let continuousCount = 0;
-        for (const cot of cotList) {
-            if (cot.idx !== continuousCount)
-                break;
-            continuousAmount = continuousAmount.add(cot.amount);
-            continuousCount++;
-            if (continuousAmount.gte(outputRequired)) {
-                console.log("XCS | SS | Continuous COTs cover requirement, no quotes needed");
-                const usedCOTs = [];
-                let r = outputRequired;
-                for (let i = 0; i < continuousCount; i++) {
-                    const c = cotList[i];
-                    const amountToUse = Decimal.min(r, c.amount);
-                    usedCOTs.push({
-                        originalHolding: c.originalHolding,
-                        amountUsed: amountToUse,
-                        idx: c.idx,
-                        cur: c.currency,
-                    });
-                    r = r.minus(amountToUse);
-                    if (r.lte(0))
-                        break;
-                }
-                return { quoteResponses: [], usedCOTs };
-            }
-        }
-    }
-    const queue = [];
-    for (const c of cotList) {
-        queue.push({ idx: c.idx, isCOT: true, cotData: c });
-    }
-    for (const q of nonCOTQuotes) {
-        queue.push({ idx: q.idx, isCOT: false, quoteData: q });
-    }
-    queue.sort((a, b) => a.idx - b.idx);
-    // Smallest priority-ordered prefix whose cumulative value covers
-    // `outputRequired × prefixHeadroom`. Quote only that prefix initially; the batch
-    // is extended below if realised aggregator output under-delivers.
-    const target = outputRequired.mul(prefixHeadroom);
-    let cumulative = new Decimal(0);
-    let prefixCutoffIdx = null;
-    for (const item of queue) {
-        if (item.isCOT) {
-            cumulative = cumulative.add(item.cotData.amount);
-        }
-        else {
-            cumulative = cumulative.add(item.quoteData.value);
-        }
-        if (cumulative.gte(target)) {
-            prefixCutoffIdx = item.idx;
-            break;
-        }
-    }
-    console.debug("XCS | SS | Prefix selected", {
-        prefixCutoffIdx,
-        cumulative: cumulative.toFixed(),
-        target: target.toFixed(),
-    });
-    const responseByIdx = new Map();
-    const quoteAndStore = async (batch) => {
-        if (batch.length === 0)
-            return;
-        const r = await aggregateAggregators(batch.map((b) => b.req), aggregators, AggregateAggregatorsMode.MaximizeOutput);
-        for (let i = 0; i < batch.length; i++) {
-            responseByIdx.set(batch[i].idx, r[i]);
-        }
-    };
-    const initialBatch = prefixCutoffIdx == null
-        ? nonCOTQuotes
-        : nonCOTQuotes.filter((q) => q.idx <= prefixCutoffIdx);
-    console.debug("XCS | SS | Initial quote batch", {
-        initialCount: initialBatch.length,
-        totalNonCOT: nonCOTQuotes.length,
-    });
-    await quoteAndStore(initialBatch);
-    const final = [];
-    const usedCOTs = [];
-    let remainder = outputRequired;
-    for (const item of queue) {
-        if (remainder.lte(0))
-            break;
-        if (item.isCOT) {
-            const { cotData } = item;
-            const amountToUse = Decimal.min(remainder, cotData.amount);
-            usedCOTs.push({
-                originalHolding: cotData.originalHolding,
-                amountUsed: amountToUse,
-                idx: cotData.idx,
-                cur: cotData.currency,
-            });
-            remainder = remainder.minus(amountToUse);
-            console.debug("XCS | SS | cot", {
-                idx: cotData.idx,
-                amountToUse: amountToUse.toFixed(),
-                remainder: remainder.toFixed(),
-            });
-            continue;
-        }
-        const { quoteData } = item;
-        let lookup = responseByIdx.get(quoteData.idx);
-        if (lookup == null) {
-            // Prefix under-delivered: quote every non-COT we haven't yet and continue.
-            const unquoted = nonCOTQuotes.filter((q) => !responseByIdx.has(q.idx));
-            console.log("XCS | SS | Prefix under-delivered, extending batch", {
-                remaining: unquoted.length,
-            });
-            await quoteAndStore(unquoted);
-            lookup = responseByIdx.get(quoteData.idx);
-        }
-        if (lookup == null)
-            continue;
-        const { quote: resp, aggregator } = lookup;
-        if (resp == null)
-            continue;
-        console.debug("XCS | SS | quote-eval", {
-            idx: quoteData.idx,
-            remainder: remainder.toFixed(),
-            input: resp.input,
-            output: resp.output,
-        });
-        const divisor = Decimal.pow(10, quoteData.cur.decimals);
-        const oamD = new Decimal(resp.output.amount);
-        if (oamD.gt(remainder)) {
-            const indicativePrice = Decimal.div(resp.input.amountRaw.toString(), resp.output.amountRaw.toString());
-            const userBal = new Decimal(quoteData.originalHolding.amountRaw.toString());
-            let expectedInput = Decimal.min(remainder.mul(divisor).mul(indicativePrice).mul(safetyMultiplier), userBal);
-            let attempts = 0;
-            while (true) {
-                if (++attempts > 10) {
-                    throw new AutoSelectionError("Partial quote did not converge");
-                }
-                console.debug("XCS | SS | partial_quote_loop", {
-                    indicativePrice: indicativePrice.toFixed(),
-                    expectedInput: expectedInput.toFixed(),
-                    userBal: userBal.toFixed(),
-                    remainder: remainder.toFixed(),
-                });
-                const adequate = await aggregateAggregators([
-                    {
-                        ...quoteData.req,
-                        seriousness: QuoteSeriousness.SERIOUS,
-                        inputAmount: convertDecimalToBigInt(expectedInput),
-                    },
-                ], aggregators, AggregateAggregatorsMode.MaximizeOutput);
-                if (adequate.length !== 1) {
-                    throw new AutoSelectionError("Unexpected response length from aggregateAggregators");
-                }
-                const aq = adequate[0];
-                if (aq.quote == null) {
-                    throw new AutoSelectionError("Couldn't get buy quote");
-                }
-                const oam2D = new Decimal(aq.quote.output.amount);
-                if (oam2D.gte(remainder)) {
-                    final.push({
-                        quote: aq.quote,
-                        aggregator: aq.aggregator,
-                        holding: quoteData.originalHolding,
-                        chainID: Number(quoteData.req.chain.chainID),
-                    });
-                    remainder = remainder.minus(oam2D);
-                    break;
-                }
-                else if (expectedInput.eq(userBal)) {
-                    throw new AutoSelectionError("Holding was supposedly enough to meet the full requirement but ceased to be so subsequently");
-                }
-                else {
-                    expectedInput = Decimal.min(expectedInput.mul(safetyMultiplier), userBal);
-                }
-            }
-        }
-        else {
-            final.push({
-                quote: resp,
-                holding: quoteData.originalHolding,
-                aggregator,
-                chainID: Number(quoteData.req.chain.chainID),
-            });
-            remainder = remainder.minus(resp.output.amount);
-            console.debug("XCS | SS | full_quote", {
-                idx: quoteData.idx,
-                remainder: remainder.toFixed(),
-            });
-        }
-    }
-    if (remainder.gt(0)) {
-        throw new AutoSelectionError("NOT_ENOUGH_SWAP_FOR_REQUIREMENT");
-    }
-    console.log("XCS | SS | final_quotes", { quotes: final, cots: usedCOTs });
-    return { quoteResponses: final, usedCOTs };
-}

package/dist/types/_polyfill.d.ts

@@ -1 +0,0 @@
-export declare function ensureBufferPolyfill(): void;

package/dist/types/balances/ub-api.d.ts

@@ -1,14 +0,0 @@
-import Decimal from "decimal.js";
-import { Universe } from "../proto/definition";
-import { Bytes } from "../types";
-import { OmniversalChainID } from "../data";
-export type BalanceOnChain = {
-    chainID: OmniversalChainID;
-    totalValue: Decimal;
-    currencywise: {
-        tokenAddress: Buffer;
-        amount: Decimal;
-        value: Decimal;
-    }[];
-};
-export declare function getBalances(vscURL: string, universe: Universe, address: Bytes): Promise<BalanceOnChain[]>;

package/dist/types/cosmos/index.d.ts

@@ -1,6 +0,0 @@
-import { Registry as CosmosRegistry, OfflineDirectSigner, DirectSecp256k1Wallet } from "@cosmjs/proto-signing";
-import { HttpEndpoint, SigningStargateClient, SigningStargateClientOptions } from "@cosmjs/stargate";
-import { Bytes } from "../types";
-export declare const Registry: CosmosRegistry;
-export declare function createCosmosWallet(privateKey: string | Bytes): Promise<DirectSecp256k1Wallet>;
-export declare function createCosmosClient(signer: OfflineDirectSigner, endpoint: string | HttpEndpoint, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;

package/dist/types/data/chaindata.d.ts

@@ -1,20 +0,0 @@
-import { Universe } from "../proto/definition";
-import { ChainIDKeyedMap, OmniversalChainID } from "./chainid";
-import { Currency } from "./currency";
-import { ezPadTo32Hex } from "./utils";
-declare class CurrencyMap {
-    private readonly map;
-    constructor(currencies: Currency[]);
-    get(input: Parameters<typeof ezPadTo32Hex>[0]): Currency | undefined;
-}
-export type ChainDatum = {
-    ChainID: OmniversalChainID;
-    Universe: Universe;
-    ChainID32: Buffer;
-    Currencies: Currency[];
-    CurrencyMap: CurrencyMap;
-};
-export declare const Chaindata: ChainDatum[];
-export declare const ChaindataMap: ChainIDKeyedMap<ChainDatum>;
-export declare const RPCURLMap: ChainIDKeyedMap<string>;
-export {};

package/dist/types/data/chainid.d.ts

@@ -1,31 +0,0 @@
-import { type Hex } from "viem";
-import { Universe } from "../proto/definition";
-import { Bytes } from "../types";
-export declare function encodeChainID36(universe: Universe, chainID: Bytes | bigint | number): Buffer;
-export declare class OmniversalChainID {
-    readonly universe: Universe;
-    readonly chainID: bigint;
-    private readonly binaryForm;
-    constructor(universe: Universe, chainID: bigint | number | string | Bytes);
-    toString(): string;
-    toJSON(): {
-        universe: string;
-        chainID: `0x${string}`;
-    };
-    static fromJSON(input: {
-        universe: string;
-        chainID: Hex;
-    }): OmniversalChainID;
-    static fromChainID36(_input: Bytes): OmniversalChainID;
-    toBytes(): Buffer;
-    equals(rhs: OmniversalChainID): boolean;
-    static equals(lhs: OmniversalChainID, rhs: OmniversalChainID): boolean;
-}
-export declare class ChainIDKeyedMap<V> {
-    private readonly map;
-    constructor(entries?: readonly [OmniversalChainID, V][] | null);
-    get(key: OmniversalChainID): V | undefined;
-    set(key: OmniversalChainID, value: V): this;
-    getFromChainID36(key: Bytes): V | undefined;
-    entries(): Generator<[OmniversalChainID, V]>;
-}

package/dist/types/data/currency.d.ts

@@ -1,30 +0,0 @@
-import { Hex } from "viem";
-import Decimal from "decimal.js";
-import { Bytes } from "../types";
-import { PermitVariant } from "../permitutils";
-export declare enum CurrencyID {
-    USDC = 1,
-    USDT = 2,
-    ETH = 3,
-    POL = 4,
-    AVAX = 5,
-    BNB = 6,
-    HYPE = 16,
-    KAIA = 17,
-    SOPH = 18,
-    TRX = 19,
-    MON = 20,
-    CBTC = 21
-}
-export declare class Currency {
-    readonly currencyID: CurrencyID;
-    readonly decimals: number;
-    readonly permitVariant: PermitVariant;
-    readonly permitContractVersion: number;
-    readonly isGasToken: boolean;
-    readonly tokenAddress: Buffer;
-    private readonly oneUnitToAtomicUnitRatio;
-    constructor(currencyID: CurrencyID, tokenAddress: string | Bytes | number[], decimals: number, permitVariant: PermitVariant, permitContractVersion: number | undefined, isGasToken: boolean);
-    convertUnitsToAmountDecimal(input: bigint | number | Hex | Bytes): Decimal;
-    convertAmountToUnitsInBinary(input: Decimal): Buffer;
-}

package/dist/types/data/index.d.ts

@@ -1,4 +0,0 @@
-export * from './chaindata';
-export * from './chainid';
-export * from './currency';
-export * from './utils';

package/dist/types/data/utils.d.ts

@@ -1,10 +0,0 @@
-import { Hex, toHex } from "viem";
-import Decimal from "decimal.js";
-import { Bytes } from "../types";
-export declare function convertToBufferIfNecessary(buf: Bytes): Buffer<ArrayBufferLike>;
-export declare function zeroExtendBufToGivenSize(buf: Bytes, size?: number): Buffer;
-export declare function ezPadTo32Hex(input: Hex | Parameters<typeof toHex>[0]): Hex;
-export declare function convertDecimalToBigInt(dec: Decimal): bigint;
-export declare function convertBigIntToDecimal(big: bigint): Decimal;
-export declare function maxByBigInt<T>(items: readonly T[], getValue: (element: T) => bigint): T;
-export declare function minByBigInt<T>(items: readonly T[], getValue: (element: T) => bigint): T;

package/dist/types/evmabi/erc20.abi.d.ts

@@ -1,264 +0,0 @@
-export declare const ERC20ABI: readonly [{
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "name";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_spender";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "approve";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "totalSupply";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_from";
-        readonly type: "address";
-    }, {
-        readonly name: "_to";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "transferFrom";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "decimals";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint8";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [{
-        readonly name: "_owner";
-        readonly type: "address";
-    }];
-    readonly name: "balanceOf";
-    readonly outputs: readonly [{
-        readonly name: "balance";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "symbol";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_to";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "transfer";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [{
-        readonly name: "_owner";
-        readonly type: "address";
-    }, {
-        readonly name: "_spender";
-        readonly type: "address";
-    }];
-    readonly name: "allowance";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly payable: true;
-    readonly stateMutability: "payable";
-    readonly type: "fallback";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly name: "spender";
-        readonly type: "address";
-    }, {
-        readonly indexed: false;
-        readonly name: "value";
-        readonly type: "uint256";
-    }];
-    readonly name: "Approval";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly indexed: false;
-        readonly name: "value";
-        readonly type: "uint256";
-    }];
-    readonly name: "Transfer";
-    readonly type: "event";
-}, {
-    readonly comment: "From the EIP-2612 spec.";
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "owner";
-        readonly type: "address";
-    }];
-    readonly name: "nonces";
-    readonly outputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly comment: "From the EIP-2612 spec.";
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly internalType: "address";
-        readonly name: "spender";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "value";
-        readonly type: "uint256";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "deadline";
-        readonly type: "uint256";
-    }, {
-        readonly internalType: "uint8";
-        readonly name: "v";
-        readonly type: "uint8";
-    }, {
-        readonly internalType: "bytes32";
-        readonly name: "r";
-        readonly type: "bytes32";
-    }, {
-        readonly internalType: "bytes32";
-        readonly name: "s";
-        readonly type: "bytes32";
-    }];
-    readonly name: "permit";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly comment: "Available on bridged tokens on Polygon.";
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "userAddress";
-        readonly type: "address";
-    }, {
-        readonly internalType: "bytes";
-        readonly name: "functionSignature";
-        readonly type: "bytes";
-    }, {
-        readonly internalType: "bytes32";
-        readonly name: "sigR";
-        readonly type: "bytes32";
-    }, {
-        readonly internalType: "bytes32";
-        readonly name: "sigS";
-        readonly type: "bytes32";
-    }, {
-        readonly internalType: "uint8";
-        readonly name: "sigV";
-        readonly type: "uint8";
-    }];
-    readonly name: "executeMetaTransaction";
-    readonly outputs: readonly [{
-        readonly internalType: "bytes";
-        readonly name: "";
-        readonly type: "bytes";
-    }];
-    readonly stateMutability: "payable";
-    readonly type: "function";
-}, {
-    readonly comment: "Available on bridged tokens on Polygon.";
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "user";
-        readonly type: "address";
-    }];
-    readonly name: "getNonce";
-    readonly outputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "nonce";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}];