@avail-project/ca-common 1.0.0-beta.1

package/dist/types/proto/definition.d.ts

@@ -0,0 +1,373 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import Long from "long";
+export declare const protobufPackage = "";
+export declare enum RFFSourceState {
+    WAITING = 0,
+    DEPOSITED = 1,
+    UNRECOGNIZED = -1
+}
+export declare function rFFSourceStateFromJSON(object: any): RFFSourceState;
+export declare function rFFSourceStateToJSON(object: RFFSourceState): string;
+export declare enum Universe {
+    ETHEREUM = 0,
+    FUEL = 1,
+    SOLANA = 2,
+    TRON = 3,
+    UNRECOGNIZED = -1
+}
+export declare function universeFromJSON(object: any): Universe;
+export declare function universeToJSON(object: Universe): string;
+/**
+ * PageRequest is to be embedded in gRPC request messages for efficient
+ * pagination. Ex:
+ *
+ *  message SomeRequest {
+ *          Foo some_parameter = 1;
+ *          PageRequest pagination = 2;
+ *  }
+ */
+export interface PageRequest {
+    /**
+     * key is a value returned in PageResponse.next_key to begin
+     * querying the next page most efficiently. Only one of offset or key
+     * should be set.
+     */
+    key: Uint8Array;
+    /**
+     * offset is a numeric offset that can be used when key is unavailable.
+     * It is less efficient than using key. Only one of offset or key should
+     * be set.
+     */
+    offset: Long;
+    /**
+     * limit is the total number of results to be returned in the result page.
+     * If left empty it will default to a value to be set by each app.
+     */
+    limit: Long;
+    /**
+     * count_total is set to true  to indicate that the result set should include
+     * a count of the total number of items available for pagination in UIs.
+     * count_total is only respected when offset is used. It is ignored when key
+     * is set.
+     */
+    countTotal: boolean;
+    /** reverse is set to true if results are to be returned in the descending order. */
+    reverse: boolean;
+}
+/**
+ * PageResponse is to be embedded in gRPC response messages where the
+ * corresponding request message has used PageRequest.
+ *
+ *  message SomeResponse {
+ *          repeated Bar results = 1;
+ *          PageResponse page = 2;
+ *  }
+ */
+export interface PageResponse {
+    /**
+     * next_key is the key to be passed to PageRequest.key to
+     * query the next page most efficiently. It will be empty if
+     * there are no more results.
+     */
+    nextKey: Uint8Array;
+    /**
+     * total is total number of results available if PageRequest.count_total
+     * was set, its value is undefined otherwise
+     */
+    total: Long;
+}
+export interface RFFSourcePair {
+    universe: Universe;
+    chainID: Uint8Array;
+    contractAddress: Uint8Array;
+    value: Uint8Array;
+    status: RFFSourceState;
+}
+export interface SignatureDatum {
+    universe: Universe;
+    address: Uint8Array;
+    signature: Uint8Array;
+    /** is to be left empty by the creator and is to be filled in during signature verification */
+    hash: Uint8Array;
+}
+export interface RFFDestinationPair {
+    contractAddress: Uint8Array;
+    /** amount */
+    value: Uint8Array;
+}
+export interface RequestForFunds {
+    id: Long;
+    sources: RFFSourcePair[];
+    destinationUniverse: Universe;
+    destinationChainID: Uint8Array;
+    recipientAddress: Uint8Array;
+    destinations: RFFDestinationPair[];
+    nonce: Uint8Array;
+    expiry: Long;
+    signatureData: SignatureDatum[];
+    /** Cosmos user (???)/Cosmos internal fields */
+    user: string;
+    /** the EVM address that fulfilled it on the destination chain */
+    fulfilledBy: Uint8Array;
+    fulfilledAt: Long;
+    deposited: boolean;
+    fulfilled: boolean;
+    /** todo: remove settled, using solver amount instead */
+    settled: boolean;
+    refunded: boolean;
+    creationBlock: Long;
+}
+export interface MsgCreateRequestForFunds {
+    sources: RFFSourcePair[];
+    destinationUniverse: Universe;
+    destinationChainID: Uint8Array;
+    recipientAddress: Uint8Array;
+    destinations: RFFDestinationPair[];
+    nonce: Uint8Array;
+    expiry: Long;
+    user: string;
+    signatureData: SignatureDatum[];
+}
+export interface MsgCreateRequestForFundsResponse {
+    id: Long;
+}
+export interface QueryGetRequestForFundsRequest {
+    id: Long;
+}
+export interface QueryGetRequestForFundsResponse {
+    requestForFunds?: RequestForFunds | undefined;
+}
+export interface QueryAllRequestForFundsRequest {
+    pagination?: PageRequest | undefined;
+}
+export interface QueryAllRequestForFundsResponse {
+    requestForFunds: RequestForFunds[];
+    pagination?: PageResponse | undefined;
+}
+export interface RouteFee {
+    sourceUniverse: Universe;
+    destinationUniverse: Universe;
+    sourceChainID: Uint8Array;
+    destinationChainID: Uint8Array;
+    sourceTokenAddress: Uint8Array;
+    destinationTokenAddress: Uint8Array;
+    /** 7 ↔ 9 are reserved for new fields */
+    feeBP: number;
+}
+export interface SolverAddress {
+    universe: Universe;
+    address: Uint8Array;
+    signature: Uint8Array;
+}
+export interface SolverData {
+    cosmosAddress: string;
+    advertisedFees: RouteFee[];
+    addresses: SolverAddress[];
+}
+export interface QueryGetSolverDataRequest {
+    cosmosAddress: string;
+}
+export interface QueryGetSolverDataResponse {
+    solverData?: SolverData | undefined;
+}
+export interface QueryAllSolverDataRequest {
+    pagination?: PageRequest | undefined;
+}
+export interface QueryAllSolverDataResponse {
+    solverData: SolverData[];
+    pagination?: PageResponse | undefined;
+}
+export interface MsgCreateSolverData {
+    cosmosAddress: string;
+    advertisedFees: RouteFee[];
+    addresses: SolverAddress[];
+}
+export interface MsgCreateSolverDataResponse {
+}
+export interface MsgUpdateSolverData {
+    cosmosAddress: string;
+    advertisedFees: RouteFee[];
+    addresses: SolverAddress[];
+}
+export interface MsgUpdateSolverDataResponse {
+}
+export interface Settlement {
+    id: Uint8Array;
+    universe: Universe;
+    chainId: Uint8Array;
+    amounts: Uint8Array[];
+    contractAddresses: Uint8Array[];
+    filler: Uint8Array[];
+    success: boolean;
+}
+export interface QueryGetSettlementRequest {
+    id: Long;
+}
+export interface QueryGetSettlementResponse {
+    Settlement?: Settlement | undefined;
+}
+export interface QueryAllSettlementRequest {
+    pagination?: PageRequest | undefined;
+}
+export interface QueryAllSettlementResponse {
+    Settlement: Settlement[];
+    pagination?: PageResponse | undefined;
+}
+export interface QueryRequestForFundsByAddressRequest {
+    account: string;
+    pagination?: PageRequest | undefined;
+}
+export interface FixedFeeTuple {
+    universe: Universe;
+    chainID: Uint8Array;
+    tokenAddress: Uint8Array;
+    fee: Uint8Array;
+}
+export interface AdminFeeRecipient {
+    universe: Universe;
+    address: Uint8Array;
+}
+export interface ProtocolFees {
+    feeBP: Long;
+    collectionFees: FixedFeeTuple[];
+    fulfilmentFees: FixedFeeTuple[];
+    admin: string;
+    feeRecipients: AdminFeeRecipient[];
+}
+export interface QueryGetProtocolFeesRequest {
+}
+export interface QueryGetProtocolFeesResponse {
+    ProtocolFees?: ProtocolFees | undefined;
+}
+export interface MsgCreateProtocolFees {
+    creator: string;
+    feeBP: Long;
+    collectionFees: FixedFeeTuple[];
+    fulfilmentFees: FixedFeeTuple[];
+    feeRecipients: AdminFeeRecipient[];
+}
+export interface MsgCreateProtocolFeesResponse {
+}
+export interface MsgUpdateProtocolFees {
+    creator: string;
+    feeBP: Long;
+    collectionFees: FixedFeeTuple[];
+    fulfilmentFees: FixedFeeTuple[];
+    feeRecipients: AdminFeeRecipient[];
+}
+export interface MsgUpdateProtocolFeesResponse {
+}
+export interface PriceOracleDatum {
+    universe: Universe;
+    chainID: Uint8Array;
+    tokenAddress: Uint8Array;
+    price: Uint8Array;
+    decimals: number;
+}
+export interface PriceOracleData {
+    priceData: PriceOracleDatum[];
+}
+export interface QueryGetPriceOracleDataRequest {
+}
+export interface QueryGetPriceOracleDataResponse {
+    PriceOracleData?: PriceOracleData | undefined;
+}
+export interface MsgRefundReq {
+    creator: string;
+    rffID: Long;
+}
+export interface MsgRefundReqResponse {
+}
+export interface DepositVEPacket {
+    id: Long;
+    gasRefunded: boolean;
+}
+export interface FillVEPacket {
+    id: Long;
+    fillerAddress: Uint8Array;
+    transactionHash: Uint8Array;
+}
+export interface MsgDoubleCheckTx {
+    creator: string;
+    txUniverse: Universe;
+    txChainID: Uint8Array;
+    packet?: {
+        $case: "depositPacket";
+        value: DepositVEPacket;
+    } | {
+        $case: "fillPacket";
+        value: FillVEPacket;
+    } | undefined;
+}
+export declare const PageRequest: MessageFns<PageRequest>;
+export declare const PageResponse: MessageFns<PageResponse>;
+export declare const RFFSourcePair: MessageFns<RFFSourcePair>;
+export declare const SignatureDatum: MessageFns<SignatureDatum>;
+export declare const RFFDestinationPair: MessageFns<RFFDestinationPair>;
+export declare const RequestForFunds: MessageFns<RequestForFunds>;
+export declare const MsgCreateRequestForFunds: MessageFns<MsgCreateRequestForFunds>;
+export declare const MsgCreateRequestForFundsResponse: MessageFns<MsgCreateRequestForFundsResponse>;
+export declare const QueryGetRequestForFundsRequest: MessageFns<QueryGetRequestForFundsRequest>;
+export declare const QueryGetRequestForFundsResponse: MessageFns<QueryGetRequestForFundsResponse>;
+export declare const QueryAllRequestForFundsRequest: MessageFns<QueryAllRequestForFundsRequest>;
+export declare const QueryAllRequestForFundsResponse: MessageFns<QueryAllRequestForFundsResponse>;
+export declare const RouteFee: MessageFns<RouteFee>;
+export declare const SolverAddress: MessageFns<SolverAddress>;
+export declare const SolverData: MessageFns<SolverData>;
+export declare const QueryGetSolverDataRequest: MessageFns<QueryGetSolverDataRequest>;
+export declare const QueryGetSolverDataResponse: MessageFns<QueryGetSolverDataResponse>;
+export declare const QueryAllSolverDataRequest: MessageFns<QueryAllSolverDataRequest>;
+export declare const QueryAllSolverDataResponse: MessageFns<QueryAllSolverDataResponse>;
+export declare const MsgCreateSolverData: MessageFns<MsgCreateSolverData>;
+export declare const MsgCreateSolverDataResponse: MessageFns<MsgCreateSolverDataResponse>;
+export declare const MsgUpdateSolverData: MessageFns<MsgUpdateSolverData>;
+export declare const MsgUpdateSolverDataResponse: MessageFns<MsgUpdateSolverDataResponse>;
+export declare const Settlement: MessageFns<Settlement>;
+export declare const QueryGetSettlementRequest: MessageFns<QueryGetSettlementRequest>;
+export declare const QueryGetSettlementResponse: MessageFns<QueryGetSettlementResponse>;
+export declare const QueryAllSettlementRequest: MessageFns<QueryAllSettlementRequest>;
+export declare const QueryAllSettlementResponse: MessageFns<QueryAllSettlementResponse>;
+export declare const QueryRequestForFundsByAddressRequest: MessageFns<QueryRequestForFundsByAddressRequest>;
+export declare const FixedFeeTuple: MessageFns<FixedFeeTuple>;
+export declare const AdminFeeRecipient: MessageFns<AdminFeeRecipient>;
+export declare const ProtocolFees: MessageFns<ProtocolFees>;
+export declare const QueryGetProtocolFeesRequest: MessageFns<QueryGetProtocolFeesRequest>;
+export declare const QueryGetProtocolFeesResponse: MessageFns<QueryGetProtocolFeesResponse>;
+export declare const MsgCreateProtocolFees: MessageFns<MsgCreateProtocolFees>;
+export declare const MsgCreateProtocolFeesResponse: MessageFns<MsgCreateProtocolFeesResponse>;
+export declare const MsgUpdateProtocolFees: MessageFns<MsgUpdateProtocolFees>;
+export declare const MsgUpdateProtocolFeesResponse: MessageFns<MsgUpdateProtocolFeesResponse>;
+export declare const PriceOracleDatum: MessageFns<PriceOracleDatum>;
+export declare const PriceOracleData: MessageFns<PriceOracleData>;
+export declare const QueryGetPriceOracleDataRequest: MessageFns<QueryGetPriceOracleDataRequest>;
+export declare const QueryGetPriceOracleDataResponse: MessageFns<QueryGetPriceOracleDataResponse>;
+export declare const MsgRefundReq: MessageFns<MsgRefundReq>;
+export declare const MsgRefundReqResponse: MessageFns<MsgRefundReqResponse>;
+export declare const DepositVEPacket: MessageFns<DepositVEPacket>;
+export declare const FillVEPacket: MessageFns<FillVEPacket>;
+export declare const MsgDoubleCheckTx: MessageFns<MsgDoubleCheckTx>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+    value: unknown;
+} ? {
+    $case: T["$case"];
+    value?: DeepPartial<T["value"]>;
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/types/proto/grpc.d.ts

@@ -0,0 +1,75 @@
+import { grpc } from "@improbable-eng/grpc-web";
+import Long from "long";
+import { QueryAllRequestForFundsRequest, QueryAllRequestForFundsResponse, QueryAllSettlementRequest, QueryAllSettlementResponse, QueryAllSolverDataRequest, QueryAllSolverDataResponse, QueryGetPriceOracleDataRequest, QueryGetPriceOracleDataResponse, QueryGetProtocolFeesRequest, QueryGetProtocolFeesResponse, QueryGetRequestForFundsRequest, QueryGetRequestForFundsResponse, QueryGetSettlementRequest, QueryGetSettlementResponse, QueryGetSolverDataRequest, QueryGetSolverDataResponse, QueryRequestForFundsByAddressRequest } from "./definition";
+export declare const protobufPackage = "xarchain.chainabstraction";
+export interface Query {
+    RequestForFunds(request: DeepPartial<QueryGetRequestForFundsRequest>, metadata?: grpc.Metadata): Promise<QueryGetRequestForFundsResponse>;
+    RequestForFundsAll(request: DeepPartial<QueryAllRequestForFundsRequest>, metadata?: grpc.Metadata): Promise<QueryAllRequestForFundsResponse>;
+    RequestForFundsByAddress(request: DeepPartial<QueryRequestForFundsByAddressRequest>, metadata?: grpc.Metadata): Promise<QueryAllRequestForFundsResponse>;
+    SolverData(request: DeepPartial<QueryGetSolverDataRequest>, metadata?: grpc.Metadata): Promise<QueryGetSolverDataResponse>;
+    SolverDataAll(request: DeepPartial<QueryAllSolverDataRequest>, metadata?: grpc.Metadata): Promise<QueryAllSolverDataResponse>;
+    Settlement(request: DeepPartial<QueryGetSettlementRequest>, metadata?: grpc.Metadata): Promise<QueryGetSettlementResponse>;
+    SettlementAll(request: DeepPartial<QueryAllSettlementRequest>, metadata?: grpc.Metadata): Promise<QueryAllSettlementResponse>;
+    ProtocolFees(request: DeepPartial<QueryGetProtocolFeesRequest>, metadata?: grpc.Metadata): Promise<QueryGetProtocolFeesResponse>;
+    PriceOracleData(request: DeepPartial<QueryGetPriceOracleDataRequest>, metadata?: grpc.Metadata): Promise<QueryGetPriceOracleDataResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    RequestForFunds(request: DeepPartial<QueryGetRequestForFundsRequest>, metadata?: grpc.Metadata): Promise<QueryGetRequestForFundsResponse>;
+    RequestForFundsAll(request: DeepPartial<QueryAllRequestForFundsRequest>, metadata?: grpc.Metadata): Promise<QueryAllRequestForFundsResponse>;
+    RequestForFundsByAddress(request: DeepPartial<QueryRequestForFundsByAddressRequest>, metadata?: grpc.Metadata): Promise<QueryAllRequestForFundsResponse>;
+    SolverData(request: DeepPartial<QueryGetSolverDataRequest>, metadata?: grpc.Metadata): Promise<QueryGetSolverDataResponse>;
+    SolverDataAll(request: DeepPartial<QueryAllSolverDataRequest>, metadata?: grpc.Metadata): Promise<QueryAllSolverDataResponse>;
+    Settlement(request: DeepPartial<QueryGetSettlementRequest>, metadata?: grpc.Metadata): Promise<QueryGetSettlementResponse>;
+    SettlementAll(request: DeepPartial<QueryAllSettlementRequest>, metadata?: grpc.Metadata): Promise<QueryAllSettlementResponse>;
+    ProtocolFees(request: DeepPartial<QueryGetProtocolFeesRequest>, metadata?: grpc.Metadata): Promise<QueryGetProtocolFeesResponse>;
+    PriceOracleData(request: DeepPartial<QueryGetPriceOracleDataRequest>, metadata?: grpc.Metadata): Promise<QueryGetPriceOracleDataResponse>;
+}
+export declare const QueryDesc: {
+    serviceName: string;
+};
+export declare const QueryRequestForFundsDesc: UnaryMethodDefinitionish;
+export declare const QueryRequestForFundsAllDesc: UnaryMethodDefinitionish;
+export declare const QueryRequestForFundsByAddressDesc: UnaryMethodDefinitionish;
+export declare const QuerySolverDataDesc: UnaryMethodDefinitionish;
+export declare const QuerySolverDataAllDesc: UnaryMethodDefinitionish;
+export declare const QuerySettlementDesc: UnaryMethodDefinitionish;
+export declare const QuerySettlementAllDesc: UnaryMethodDefinitionish;
+export declare const QueryProtocolFeesDesc: UnaryMethodDefinitionish;
+export declare const QueryPriceOracleDataDesc: UnaryMethodDefinitionish;
+interface UnaryMethodDefinitionishR extends grpc.UnaryMethodDefinition<any, any> {
+    requestStream: any;
+    responseStream: any;
+}
+type UnaryMethodDefinitionish = UnaryMethodDefinitionishR;
+interface Rpc {
+    unary<T extends UnaryMethodDefinitionish>(methodDesc: T, request: any, metadata: grpc.Metadata | undefined): Promise<any>;
+}
+export declare class GrpcWebImpl {
+    private host;
+    private options;
+    constructor(host: string, options: {
+        transport?: grpc.TransportFactory;
+        debug?: boolean;
+        metadata?: grpc.Metadata;
+        upStreamRetryCodes?: number[];
+    });
+    unary<T extends UnaryMethodDefinitionish>(methodDesc: T, _request: any, metadata: grpc.Metadata | undefined): Promise<any>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+    value: unknown;
+} ? {
+    $case: T["$case"];
+    value?: DeepPartial<T["value"]>;
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export declare class GrpcWebError extends globalThis.Error {
+    code: grpc.Code;
+    metadata: grpc.Metadata;
+    constructor(message: string, code: grpc.Code, metadata: grpc.Metadata);
+}
+export {};

package/dist/types/rff/fuel.d.ts

@@ -0,0 +1,4 @@
+import { Universe } from "../proto/definition";
+import { UniverseInput, UniverseOutput } from "../fuelcontracts";
+export declare function protobufUniverseToFuelUniverse(input: Universe): UniverseInput;
+export declare function fuelUniverseToProtobufUniverse(input: UniverseOutput): Universe;

package/dist/types/rff/rff.d.ts

@@ -0,0 +1,12 @@
+import { RequestForFunds } from "../proto/definition";
+import { type EVMRFF } from "../vaultcontracts";
+import { RequestInput as FuelRFF } from "../fuelcontracts/ArcanaVault";
+export declare class OmniversalRFF {
+    readonly protobufRFF: RequestForFunds;
+    private evmRFF;
+    private fuelRFF;
+    constructor(protobufRFF: RequestForFunds);
+    asEVMRFF(): EVMRFF;
+    asFuelRFF(): FuelRFF;
+    asProtobufRFF(): RequestForFunds;
+}

package/dist/types/types/binarytypes.d.ts

@@ -0,0 +1 @@
+export type Bytes = Buffer | Uint8Array;

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

@@ -0,0 +1,2 @@
+export * from './binarytypes';
+export * from './msgpack-axios';

package/dist/types/types/msgpack-axios.d.ts

@@ -0,0 +1 @@
+export declare const msgpackableAxios: import("axios").AxiosInstance;

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

@@ -0,0 +1,22 @@
+export type EVMRFF = {
+    sources: readonly {
+        universe: number;
+        chainID: bigint;
+        contractAddress: `0x${string}`;
+        value: bigint;
+    }[];
+    destinationUniverse: number;
+    destinationChainID: bigint;
+    recipientAddress: `0x${string}`;
+    destinations: readonly {
+        contractAddress: `0x${string}`;
+        value: bigint;
+    }[];
+    nonce: bigint;
+    expiry: bigint;
+    parties: readonly {
+        universe: number;
+        address_: `0x${string}`;
+    }[];
+};
+export * from "./vaultcontracts";

package/dist/types/vaultcontracts/vaultcontracts.d.ts

@@ -0,0 +1,8 @@
+import { ChainIDKeyedMap } from "../data";
+export declare enum Environment {
+    FOLLY = 0,// Dev with test-net tokens
+    CERISE = 1,// Dev with main-net tokens
+    CORAL = 2,// Test-net with main-net tokens
+    JADE = 3
+}
+export declare function getVaultContractMap(environment: Environment): ChainIDKeyedMap<Buffer<ArrayBufferLike>>;

package/dist/types/xcs/autochoice.d.ts

@@ -0,0 +1,57 @@
+import Decimal from "decimal.js";
+import { Aggregator, Quote, QuoteRequestExactInput, QuoteRequestExactOutput } from "./iface";
+import { Currency, CurrencyID, OmniversalChainID } from "../data";
+import { Bytes } from "../types";
+import { FixedFeeTuple } from "../proto/definition";
+type Asset = {
+    tokenAddress: Bytes;
+    amount: bigint;
+};
+export type Holding = {
+    chainID: OmniversalChainID;
+    value: number;
+} & Asset;
+export declare class AutoSelectionError extends Error {
+}
+declare const enum AggregateAggregatorsMode {
+    MaximizeOutput = 0,
+    MinimizeInput = 1
+}
+export declare function aggregateAggregators(requests: (QuoteRequestExactInput | QuoteRequestExactOutput)[], aggregators: Aggregator[], mode: AggregateAggregatorsMode): Promise<{
+    quote: Quote | null;
+    aggregator: Aggregator;
+}[]>;
+export declare function autoSelectSources(userAddress: Bytes, holdings: Holding[], outputRequired: Decimal, aggregators: Aggregator[], collectionFees: FixedFeeTuple[], commonCurrencyID?: CurrencyID): Promise<({
+    req: QuoteRequestExactInput;
+    cfee: bigint;
+    originalHolding: Holding;
+    cur: Currency;
+} & {
+    quote: Quote;
+    agg: Aggregator;
+})[]>;
+export declare function determineDestinationSwaps(userAddress: Bytes, chainID: OmniversalChainID, requirement: Asset, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<{
+    quote: Quote | null;
+    aggregator: Aggregator;
+    inputAmount: Decimal;
+    outputAmount: bigint;
+}>;
+export declare function liquidateInputHoldings(userAddress: Bytes, holdings: Holding[], aggregators: Aggregator[], collectionFees: FixedFeeTuple[], commonCurrencyID?: CurrencyID): Promise<{
+    quotes: {
+        agg: Aggregator;
+        quote: Quote;
+        req: QuoteRequestExactInput;
+        cfee: bigint;
+        originalHolding: Holding;
+        cur: Currency;
+        aggregator: Aggregator;
+    }[];
+    total: Decimal;
+}>;
+export declare function destinationSwapWithExactIn(userAddress: Bytes, chainID: OmniversalChainID, inputAmount: bigint, outputToken: Bytes, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<{
+    inputAmount: Decimal;
+    outputAmount: bigint;
+    quote: Quote | null;
+    aggregator: Aggregator;
+}>;
+export {};

package/dist/types/xcs/bebop-agg.d.ts

@@ -0,0 +1,104 @@
+import { Hex } from "viem";
+import { Aggregator, Quote, QuoteRequestExactInput, QuoteRequestExactOutput } from "./iface";
+export type BebopCommonQuote = {
+    type: string;
+    status: string;
+    quoteId: string;
+    chainId: number;
+    approvalType: string;
+    nativeToken: string;
+    taker: string;
+    receiver: string;
+    expiry: number;
+    slippage: number;
+    gasFee: {
+        native: string;
+        usd: number;
+    };
+    buyTokens: Record<Hex, {
+        amount: string;
+        decimals: number;
+        priceUsd: number;
+        symbol: string;
+        minimumAmount: string;
+        price: number;
+        priceBeforeFee: number;
+        amountBeforeFee: string;
+        deltaFromExpected: number;
+    }>;
+    sellTokens: Record<Hex, {
+        amount: string;
+        decimals: number;
+        priceUsd: number;
+        symbol: string;
+        price: number;
+        priceBeforeFee: number;
+    }>;
+    settlementAddress: string;
+    approvalTarget: string;
+    requiredSignatures: Array<never>;
+    priceImpact: number;
+    warnings: Array<never>;
+    tx: {
+        from: Hex;
+        to: Hex;
+        value: Hex;
+        data: Hex;
+        gas: number;
+    };
+};
+export type BebopPMMv3Quote = {
+    type: "PMMv3";
+    quote: BebopCommonQuote & {
+        makers: Array<string>;
+        toSign: {
+            partner_id: number;
+            expiry: number;
+            taker_address: string;
+            maker_address: string;
+            maker_nonce: string;
+            taker_token: string;
+            maker_token: string;
+            taker_amount: string;
+            maker_amount: string;
+            receiver: string;
+            packed_commands: string;
+        };
+        onchainOrderType: string;
+        tx: BebopCommonQuote["tx"] & {
+            gasPrice: number;
+            chainId: number;
+        };
+    };
+};
+export type BebopJAMv2Quote = {
+    type: "JAMv2";
+    quote: BebopCommonQuote & {
+        hooksHash: string;
+        toSign: {
+            taker: string;
+            receiver: string;
+            expiry: number;
+            exclusivityDeadline: number;
+            nonce: string;
+            executor: string;
+            partnerInfo: string;
+            sellTokens: Array<string>;
+            buyTokens: Array<string>;
+            sellAmounts: Array<string>;
+            buyAmounts: Array<string>;
+            hooksHash: string;
+        };
+        solver: string;
+    };
+};
+export type BebopQuote = Quote & {
+    originalResponse: BebopPMMv3Quote | BebopJAMv2Quote;
+};
+export declare class BebopAggregator implements Aggregator {
+    private static readonly BASE_URL;
+    private static readonly COMMON_OPTIONS;
+    private readonly axios;
+    constructor(apiKey: string);
+    getQuotes(requests: (QuoteRequestExactInput | QuoteRequestExactOutput)[]): Promise<(BebopQuote | null)[]>;
+}