@1inch/fusion-sdk 2.2.3 → 2.2.4-rc.0

package/dist/esm/utils/amounts.d.ts

@@ -0,0 +1,2 @@
+export declare function calcTakingAmount(swapMakerAmount: bigint, orderMakerAmount: bigint, orderTakerAmount: bigint): bigint;
+export declare function calcMakingAmount(swapTakerAmount: bigint, orderMakerAmount: bigint, orderTakerAmount: bigint): bigint;

package/dist/esm/utils/time.d.ts

@@ -0,0 +1 @@
+export declare function now(): bigint;

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

@@ -0,0 +1,3 @@
+export type PublicOf<T> = {
+    [K in keyof T]: T[K];
+};

package/dist/esm/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function trim0x(data: string): string;
+export declare function add0x(data: string): string;

package/dist/esm/validations.d.ts

@@ -0,0 +1,4 @@
+export declare function isValidAddress(address: string): boolean;
+export declare function isValidAmount(value: string | bigint): boolean;
+export declare function isHexString(val: string): boolean;
+export declare function isHexBytes(val: string): boolean;

package/dist/esm/ws-api/active-websocket-orders-api.d.ts

@@ -0,0 +1,13 @@
+import { OnOrderCancelledCb, OnOrderCb, OnOrderCreatedCb, OnOrderFilledCb, OnOrderFilledPartiallyCb, OnOrderInvalidCb, OnOrderNotEnoughBalanceOrAllowanceCb } from './types';
+import { WsProviderConnector } from '../connector/ws';
+export declare class ActiveOrdersWebSocketApi {
+    readonly provider: WsProviderConnector;
+    constructor(provider: WsProviderConnector);
+    onOrder(cb: OnOrderCb): void;
+    onOrderCreated(cb: OnOrderCreatedCb): void;
+    onOrderInvalid(cb: OnOrderInvalidCb): void;
+    onOrderBalanceOrAllowanceChange(cb: OnOrderNotEnoughBalanceOrAllowanceCb): void;
+    onOrderFilled(cb: OnOrderFilledCb): void;
+    onOrderCancelled(cb: OnOrderCancelledCb): void;
+    onOrderFilledPartially(cb: OnOrderFilledPartiallyCb): void;
+}

package/dist/esm/ws-api/active-websocket-orders-api.js

@@ -1,4 +1,4 @@
-import { orderEvents } from './constants';
+import { orderEvents } from './constants.js';
 export class ActiveOrdersWebSocketApi {
     constructor(provider) {
         this.provider = provider;

package/dist/esm/ws-api/constants.d.ts

@@ -0,0 +1,2 @@
+import { OrderEventType } from './types';
+export declare const orderEvents: OrderEventType['event'][];

package/dist/esm/ws-api/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ws-api';
+export * from './types';
+export * from './active-websocket-orders-api';
+export * from './rpc-websocket-api';
+export * from './constants';

package/dist/esm/ws-api/index.js

@@ -1,6 +1,6 @@
-export * from './ws-api';
-export * from './types';
-export * from './active-websocket-orders-api';
-export * from './rpc-websocket-api';
-export * from './constants';
+export * from './ws-api.js';
+export * from './types.js';
+export * from './active-websocket-orders-api.js';
+export * from './rpc-websocket-api.js';
+export * from './constants.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/ws-api/rpc-websocket-api.d.ts

@@ -0,0 +1,13 @@
+import { OnGetActiveOrdersCb, OnGetAllowedMethodsCb, OnPongCb } from './types';
+import { PaginationParams } from '../api/pagination';
+import { WsProviderConnector } from '../connector/ws';
+export declare class RpcWebsocketApi {
+    readonly provider: WsProviderConnector;
+    constructor(provider: WsProviderConnector);
+    onPong(cb: OnPongCb): void;
+    ping(): void;
+    getActiveOrders({ limit, page }?: PaginationParams): void;
+    onGetActiveOrders(cb: OnGetActiveOrdersCb): void;
+    getAllowedMethods(): void;
+    onGetAllowedMethods(cb: OnGetAllowedMethodsCb): void;
+}

package/dist/esm/ws-api/rpc-websocket-api.js

@@ -1,4 +1,4 @@
-import { PaginationRequest } from '../api/pagination';
+import { PaginationRequest } from '../api/pagination.js';
 export class RpcWebsocketApi {
     constructor(provider) {
         this.provider = provider;

package/dist/esm/ws-api/types.d.ts

@@ -0,0 +1,62 @@
+import { LimitOrderV4Struct } from '@1inch/limit-order-sdk';
+import { NetworkEnum } from '../constants';
+import { WsApiConfig } from '../connector/ws';
+import { PaginationOutput } from '../api/types';
+import { ActiveOrder } from '../api/orders';
+export type Event<K extends string, T> = {
+    event: K;
+    result: T;
+};
+export type OrderEventType = OrderCreatedEvent | OrderInvalidEvent | OrderBalanceOrAllowanceChangeEvent | OrderFilledEvent | OrderFilledPartiallyEvent | OrderCancelledEvent;
+export type OrderCreatedEvent = Event<'order_created', {
+    quoteId: string;
+    orderHash: string;
+    signature: string;
+    order: LimitOrderV4Struct;
+    deadline: string;
+    auctionStartDate: string;
+    auctionEndDate: string;
+    remainingMakerAmount: string;
+    extension: string;
+}>;
+export type OrderBalanceOrAllowanceChangeEvent = Event<'order_balance_or_allowance_change', {
+    orderHash: string;
+    remainingMakerAmount: string;
+    balance: string;
+    allowance: string;
+}>;
+export type OrderInvalidEvent = Event<'order_invalid', {
+    orderHash: string;
+}>;
+export type OrderCancelledEvent = Event<'order_cancelled', {
+    orderHash: string;
+}>;
+export type OrderFilledEvent = Event<'order_filled', {
+    orderHash: string;
+}>;
+export type OrderFilledPartiallyEvent = Event<'order_filled_partially', {
+    orderHash: string;
+    remainingMakerAmount: string;
+}>;
+export type OnOrderCb = (data: OrderEventType) => any;
+export type OnOrderCreatedCb = (data: OrderCreatedEvent) => any;
+export type OnOrderInvalidCb = (data: OrderInvalidEvent) => any;
+export type OnOrderCancelledCb = (data: OrderCancelledEvent) => any;
+export type OnOrderNotEnoughBalanceOrAllowanceCb = (data: OrderBalanceOrAllowanceChangeEvent) => any;
+export type OnOrderFilledCb = (data: OrderFilledEvent) => any;
+export type OnOrderFilledPartiallyCb = (data: OrderFilledPartiallyEvent) => any;
+export type WsApiConfigWithNetwork = WsApiConfig & {
+    network: NetworkEnum;
+};
+export type RpcEvent<T extends RpcMethod, K> = {
+    method: T;
+    result: K;
+};
+export type GetAllowMethodsRpcEvent = RpcEvent<'getAllowedMethods', RpcMethod[]>;
+export type RpcMethod = 'getAllowedMethods' | 'ping' | 'getActiveOrders';
+export type RpcEventType = PingRpcEvent | GetAllowMethodsRpcEvent | GetActiveOrdersRpcEvent;
+export type PingRpcEvent = RpcEvent<'ping', string>;
+export type GetActiveOrdersRpcEvent = RpcEvent<'getActiveOrders', PaginationOutput<ActiveOrder>>;
+export type OnPongCb = (data: PingRpcEvent['result']) => any;
+export type OnGetAllowedMethodsCb = (data: GetAllowMethodsRpcEvent['result']) => any;
+export type OnGetActiveOrdersCb = (data: GetActiveOrdersRpcEvent['result']) => any;

package/dist/esm/ws-api/url.d.ts

@@ -0,0 +1 @@
+export declare function castUrl(url: string): string;

package/dist/esm/ws-api/ws-api.d.ts

@@ -0,0 +1,21 @@
+import { ActiveOrdersWebSocketApi } from './active-websocket-orders-api';
+import { RpcWebsocketApi } from './rpc-websocket-api';
+import { WsApiConfigWithNetwork } from './types';
+import { AnyFunction, AnyFunctionWithThis, OnMessageCb, WsProviderConnector } from '../connector/ws';
+export declare class WebSocketApi {
+    private static Version;
+    readonly rpc: RpcWebsocketApi;
+    readonly order: ActiveOrdersWebSocketApi;
+    readonly provider: WsProviderConnector;
+    constructor(configOrProvider: WsApiConfigWithNetwork | WsProviderConnector);
+    static new(configOrProvider: WsApiConfigWithNetwork | WsProviderConnector): WebSocketApi;
+    init(): void;
+    on(event: string, cb: AnyFunctionWithThis): void;
+    off(event: string, cb: AnyFunctionWithThis): void;
+    onOpen(cb: AnyFunctionWithThis): void;
+    send<T>(message: T): void;
+    close(): void;
+    onMessage(cb: OnMessageCb): void;
+    onClose(cb: AnyFunction): void;
+    onError(cb: AnyFunction): void;
+}

package/dist/esm/ws-api/ws-api.js

@@ -1,7 +1,7 @@
-import { ActiveOrdersWebSocketApi } from './active-websocket-orders-api';
-import { RpcWebsocketApi } from './rpc-websocket-api';
-import { castUrl } from './url';
-import { WebsocketClient } from '../connector/ws';
+import { ActiveOrdersWebSocketApi } from './active-websocket-orders-api.js';
+import { RpcWebsocketApi } from './rpc-websocket-api.js';
+import { castUrl } from './url.js';
+import { WebsocketClient } from '../connector/ws/index.js';
 export class WebSocketApi {
     constructor(configOrProvider) {
         if (instanceOfWsApiConfigWithNetwork(configOrProvider)) {

package/dist/types/src/connector/ws/types.d.ts

@@ -7,3 +7,4 @@ export type WsApiConfig = {
     authKey?: string;
 };
 export type OnMessageCb = (data: any) => void;
+export type OnMessageInputVoidCb = () => void;

package/dist/types/src/connector/ws/websocket-client.connector.d.ts

@@ -1,5 +1,5 @@
 import WebSocket from 'ws';
-import { AnyFunction, AnyFunctionWithThis, OnMessageCb, WsApiConfig } from './types';
+import { AnyFunction, AnyFunctionWithThis, OnMessageCb, OnMessageInputVoidCb, WsApiConfig } from './types';
 import { WsProviderConnector } from './websocket-provider.connector';
 export declare class WebsocketClient implements WsProviderConnector {
     readonly ws: WebSocket;
@@ -13,6 +13,8 @@ export declare class WebsocketClient implements WsProviderConnector {
     onOpen(cb: AnyFunctionWithThis): void;
     send<T>(message: T): void;
     onMessage(cb: OnMessageCb): void;
+    ping(): void;
+    onPong(cb: OnMessageInputVoidCb): void;
     onClose(cb: AnyFunction): void;
     onError(cb: AnyFunction): void;
     close(): void;

package/dist/types/src/connector/ws/websocket-provider.connector.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunctionWithThis, AnyFunction, OnMessageCb } from './types';
+import { AnyFunctionWithThis, AnyFunction, OnMessageCb, OnMessageInputVoidCb } from './types';
 export interface WsProviderConnector {
     init(): void;
     on(event: string, cb: AnyFunctionWithThis): void;
@@ -6,6 +6,8 @@ export interface WsProviderConnector {
     onOpen(cb: AnyFunctionWithThis): void;
     send<T>(message: T): void;
     close(): void;
+    ping(): void;
+    onPong(cb: OnMessageInputVoidCb): void;
     onMessage(cb: OnMessageCb): void;
     onClose(cb: AnyFunction): void;
     onError(cb: AnyFunction): void;