@clober/v2-sdk 0.0.5 → 0.0.6-0.dev

package/dist/types/abis/rebalancer/rebalancer-abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebalancer-abi.d.ts","sourceRoot":"","sources":["../../../../src/abis/rebalancer/rebalancer-abi.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8sCjB,CAAA"}

package/dist/types/abis/rebalancer/strategy-abi.d.ts

@@ -0,0 +1,487 @@
+export declare const STRATEGY_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "contract IOracle";
+        readonly name: "referenceOracle_";
+        readonly type: "address";
+    }, {
+        readonly internalType: "contract IPoolStorage";
+        readonly name: "poolStorage_";
+        readonly type: "address";
+    }, {
+        readonly internalType: "contract IBookManager";
+        readonly name: "bookManager_";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "initialOwner";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ExceedsThreshold";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidConfig";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidPrice";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidTick";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotOperator";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnableInvalidOwner";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "OwnableUnauthorizedAccount";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "bits";
+        readonly type: "uint8";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "SafeCastOverflowedUintDowncast";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "previousOwner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnershipTransferStarted";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "previousOwner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnershipTransferred";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "status";
+        readonly type: "bool";
+    }];
+    readonly name: "SetOperator";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "key";
+        readonly type: "bytes32";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "uint24";
+            readonly name: "referenceThreshold";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "rateA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "rateB";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "minRateA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "minRateB";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "priceThresholdA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "priceThresholdB";
+            readonly type: "uint24";
+        }];
+        readonly indexed: false;
+        readonly internalType: "struct ISimpleOracleStrategy.Config";
+        readonly name: "config";
+        readonly type: "tuple";
+    }];
+    readonly name: "UpdateConfig";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "key";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oraclePrice";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "Tick";
+        readonly name: "tickA";
+        readonly type: "int24";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "Tick";
+        readonly name: "tickB";
+        readonly type: "int24";
+    }];
+    readonly name: "UpdatePrice";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "RATE_PRECISION";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "acceptOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "bookManager";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IBookManager";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "key";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amountA";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amountB";
+        readonly type: "uint256";
+    }];
+    readonly name: "computeOrders";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "Tick";
+            readonly name: "tick";
+            readonly type: "int24";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "rawAmount";
+            readonly type: "uint64";
+        }];
+        readonly internalType: "struct IStrategy.Order[]";
+        readonly name: "ordersA";
+        readonly type: "tuple[]";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "Tick";
+            readonly name: "tick";
+            readonly type: "int24";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "rawAmount";
+            readonly type: "uint64";
+        }];
+        readonly internalType: "struct IStrategy.Order[]";
+        readonly name: "ordersB";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "key";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getConfig";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint24";
+            readonly name: "referenceThreshold";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "rateA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "rateB";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "minRateA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "minRateB";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "priceThresholdA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "priceThresholdB";
+            readonly type: "uint24";
+        }];
+        readonly internalType: "struct ISimpleOracleStrategy.Config";
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "key";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getPrice";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint208";
+            readonly name: "oraclePrice";
+            readonly type: "uint208";
+        }, {
+            readonly internalType: "Tick";
+            readonly name: "tickA";
+            readonly type: "int24";
+        }, {
+            readonly internalType: "Tick";
+            readonly name: "tickB";
+            readonly type: "int24";
+        }];
+        readonly internalType: "struct ISimpleOracleStrategy.Price";
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isOperator";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "key";
+        readonly type: "bytes32";
+    }];
+    readonly name: "isOraclePriceValid";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "owner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "pendingOwner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "poolStorage";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IPoolStorage";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "referenceOracle";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IOracle";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "renounceOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "key";
+        readonly type: "bytes32";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "uint24";
+            readonly name: "referenceThreshold";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "rateA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "rateB";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "minRateA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "minRateB";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "priceThresholdA";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "priceThresholdB";
+            readonly type: "uint24";
+        }];
+        readonly internalType: "struct ISimpleOracleStrategy.Config";
+        readonly name: "config";
+        readonly type: "tuple";
+    }];
+    readonly name: "setConfig";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "status";
+        readonly type: "bool";
+    }];
+    readonly name: "setOperator";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "transferOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "key";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "oraclePrice";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "Tick";
+        readonly name: "tickA";
+        readonly type: "int24";
+    }, {
+        readonly internalType: "Tick";
+        readonly name: "tickB";
+        readonly type: "int24";
+    }];
+    readonly name: "updatePrice";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+//# sourceMappingURL=strategy-abi.d.ts.map

package/dist/types/abis/rebalancer/strategy-abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-abi.d.ts","sourceRoot":"","sources":["../../../../src/abis/rebalancer/strategy-abi.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAonBf,CAAA"}

package/dist/types/apis/chart-logs.d.ts

@@ -0,0 +1,5 @@
+import { CHAIN_IDS } from '../constants/chain';
+import { CHART_LOG_INTERVALS, ChartLog } from '../type';
+export declare function fetchLatestChartLog(chainId: CHAIN_IDS, marketCode: string): Promise<ChartLog>;
+export declare function fetchChartLogs(chainId: CHAIN_IDS, marketCode: string, intervalType: CHART_LOG_INTERVALS, from: number, to: number): Promise<ChartLog[]>;
+//# sourceMappingURL=chart-logs.d.ts.map

package/dist/types/apis/chart-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-logs.d.ts","sourceRoot":"","sources":["../../../src/apis/chart-logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAgFvD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,SAAS,EAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,QAAQ,CAAC,CAwBnB;AAiCD,wBAAsB,cAAc,CAClC,OAAO,EAAE,SAAS,EAClB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,mBAAmB,EACjC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,QAAQ,EAAE,CAAC,CAsHrB"}

package/dist/types/apis/market.d.ts

@@ -1,4 +1,5 @@
+import { PublicClient } from 'viem';
 import { CHAIN_IDS } from '../constants/chain';
 import { Market } from '../model/market';
-export declare function fetchMarket(chainId: CHAIN_IDS, tokenAddresses: `0x${string}`[], n?: number): Promise<Market>;
+export declare function fetchMarket(publicClient: PublicClient, chainId: CHAIN_IDS, tokenAddresses: `0x${string}`[], useSubgraph: boolean, n?: number): Promise<Market>;
 //# sourceMappingURL=market.d.ts.map

package/dist/types/apis/market.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"market.d.ts","sourceRoot":"","sources":["../../../src/apis/market.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAgDxC,wBAAsB,WAAW,CAC/B,OAAO,EAAE,SAAS,EAClB,cAAc,EAAE,KAAK,MAAM,EAAE,EAAE,EAC/B,CAAC,SAAM,GACN,OAAO,CAAC,MAAM,CAAC,CAyBjB"}
+{"version":3,"file":"market.d.ts","sourceRoot":"","sources":["../../../src/apis/market.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AA8FxC,wBAAsB,WAAW,CAC/B,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,cAAc,EAAE,KAAK,MAAM,EAAE,EAAE,EAC/B,WAAW,EAAE,OAAO,EACpB,CAAC,SAAM,GACN,OAAO,CAAC,MAAM,CAAC,CAyBjB"}

package/dist/types/apis/odos.d.ts

@@ -0,0 +1,28 @@
+import { CHAIN_IDS } from '../constants/chain';
+import { Currency } from '../model/currency';
+export declare function fetchOdosApi<T>(path: string, options?: RequestInit): Promise<T>;
+export declare function fetchQuote({ chainId, amountIn, tokenIn, tokenOut, slippageLimitPercent, userAddress, testnetPrice, }: {
+    chainId: CHAIN_IDS;
+    amountIn: bigint;
+    tokenIn: Currency;
+    tokenOut: Currency;
+    slippageLimitPercent: number;
+    userAddress: `0x${string}`;
+    testnetPrice?: number;
+}): Promise<{
+    amountOut: bigint;
+    pathId: string;
+}>;
+export declare function fetchCallData({ chainId, amountIn, tokenIn, tokenOut, slippageLimitPercent, userAddress, testnetPrice, }: {
+    chainId: CHAIN_IDS;
+    amountIn: bigint;
+    tokenIn: Currency;
+    tokenOut: Currency;
+    slippageLimitPercent: number;
+    userAddress: `0x${string}`;
+    testnetPrice?: number;
+}): Promise<{
+    amountOut: bigint;
+    data: `0x${string}`;
+}>;
+//# sourceMappingURL=odos.d.ts.map

package/dist/types/apis/odos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"odos.d.ts","sourceRoot":"","sources":["../../../src/apis/odos.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAkB,MAAM,oBAAoB,CAAA;AAE9D,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAE5C,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,CAAC,CAAC,CAWZ;AAED,wBAAsB,UAAU,CAAC,EAC/B,OAAO,EACP,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,oBAAoB,EACpB,WAAW,EACX,YAAY,GACb,EAAE;IACD,OAAO,EAAE,SAAS,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,QAAQ,CAAA;IACjB,QAAQ,EAAE,QAAQ,CAAA;IAClB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,WAAW,EAAE,KAAK,MAAM,EAAE,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,GAAG,OAAO,CAAC;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;CACf,CAAC,CAkDD;AAED,wBAAsB,aAAa,CAAC,EAClC,OAAO,EACP,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,oBAAoB,EACpB,WAAW,EACX,YAAY,GACb,EAAE;IACD,OAAO,EAAE,SAAS,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,QAAQ,CAAA;IACjB,QAAQ,EAAE,QAAQ,CAAA;IAClB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,WAAW,EAAE,KAAK,MAAM,EAAE,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,GAAG,OAAO,CAAC;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,KAAK,MAAM,EAAE,CAAA;CACpB,CAAC,CAyDD"}

package/dist/types/apis/open-order.d.ts

@@ -1,5 +1,7 @@
+import { PublicClient } from 'viem';
 import { CHAIN_IDS } from '../constants/chain';
 import type { OpenOrder } from '../model/open-order';
-export declare function fetchOpenOrders(chainId: CHAIN_IDS, userAddress: `0x${string}`): Promise<OpenOrder[]>;
-export declare function fetchOpenOrder(chainId: CHAIN_IDS, id: string): Promise<OpenOrder>;
+export declare function fetchOpenOrdersByUserAddress(publicClient: PublicClient, chainId: CHAIN_IDS, userAddress: `0x${string}`): Promise<OpenOrder[]>;
+export declare function fetchOpenOrder(publicClient: PublicClient, chainId: CHAIN_IDS, id: string): Promise<OpenOrder>;
+export declare function fetchOpenOrders(publicClient: PublicClient, chainId: CHAIN_IDS, ids: string[]): Promise<OpenOrder[]>;
 //# sourceMappingURL=open-order.d.ts.map

package/dist/types/apis/open-order.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"open-order.d.ts","sourceRoot":"","sources":["../../../src/apis/open-order.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAM9C,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,qBAAqB,CAAA;AAsClE,wBAAsB,eAAe,CACnC,OAAO,EAAE,SAAS,EAClB,WAAW,EAAE,KAAK,MAAM,EAAE,GACzB,OAAO,CAAC,SAAS,EAAE,CAAC,CAoBtB;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,SAAS,EAClB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,SAAS,CAAC,CAYpB"}
+{"version":3,"file":"open-order.d.ts","sourceRoot":"","sources":["../../../src/apis/open-order.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,YAAY,EAAE,MAAM,MAAM,CAAA;AAE5E,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAM9C,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,qBAAqB,CAAA;AA4DlE,wBAAsB,4BAA4B,CAChD,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,WAAW,EAAE,KAAK,MAAM,EAAE,GACzB,OAAO,CAAC,SAAS,EAAE,CAAC,CAoBtB;AAED,wBAAsB,cAAc,CAClC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,SAAS,CAAC,CAYpB;AAED,wBAAsB,eAAe,CACnC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,GAAG,EAAE,MAAM,EAAE,GACZ,OAAO,CAAC,SAAS,EAAE,CAAC,CAoBtB"}

package/dist/types/apis/pool.d.ts

@@ -0,0 +1,5 @@
+import { PublicClient } from 'viem';
+import { CHAIN_IDS } from '../constants/chain';
+import { Pool } from '../model/pool';
+export declare function fetchPool(publicClient: PublicClient, chainId: CHAIN_IDS, tokenAddresses: `0x${string}`[], salt: `0x${string}`, useSubgraph: boolean): Promise<Pool>;
+//# sourceMappingURL=pool.d.ts.map

package/dist/types/apis/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../../src/apis/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AAQpC,wBAAsB,SAAS,CAC7B,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,cAAc,EAAE,KAAK,MAAM,EAAE,EAAE,EAC/B,IAAI,EAAE,KAAK,MAAM,EAAE,EACnB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,IAAI,CAAC,CAgEf"}

package/dist/types/apis/strategy.d.ts

@@ -0,0 +1,5 @@
+import { PublicClient } from 'viem';
+import { CHAIN_IDS } from '../constants/chain';
+import { StrategyPrice } from '../model/strategy';
+export declare function fetchStrategyPrice(publicClient: PublicClient, chainId: CHAIN_IDS, tokenAddresses: `0x${string}`[], salt: `0x${string}`, useSubgraph: boolean): Promise<StrategyPrice>;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/types/apis/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/apis/strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAMjD,wBAAsB,kBAAkB,CACtC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,cAAc,EAAE,KAAK,MAAM,EAAE,EAAE,EAC/B,IAAI,EAAE,KAAK,MAAM,EAAE,EACnB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,aAAa,CAAC,CAuBxB"}

package/dist/types/approval.d.ts

@@ -1,35 +1,67 @@
-import { type HDAccount, type PrivateKeyAccount } from 'viem';
+import { WalletClient } from 'viem';
 import { CHAIN_IDS } from './constants/chain';
 import type { DefaultOptions } from './type';
 /**
+ * @dev This function relates with `viem` dependency
  * Sets approval of all open orders for the specified account on the given chain.
  *
  * @param {CHAIN_IDS} chainId The chain ID.
- * @param {HDAccount | PrivateKeyAccount} account The Ethereum account for which approval is to be set.
+ * @param {WalletClient} walletClient The wallet client.
  * @param {Object} [options] Optional parameters for setting approval.
  * @param {string} options.rpcUrl The RPC URL to use for executing the transaction.
  * @returns {Promise<`0x${string}` | undefined>} Promise resolving to the transaction hash. If the account is already approved for all, the promise resolves to `undefined`.
  * @example
  * import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
- * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mnemonicToAccount } from 'viem/accounts'
  *
- * const hash = await setApprovalOfOpenOrdersForAll(
- *   421614,
- *   privateKeyToAccount('0x...')
- * )
+ * const walletClient = createWalletClient({
+ *   chain: arbitrumSepolia,
+ *   account: mnemonicToAccount('legal ...'),
+ *   transport: http(),
+ * })
  *
+ * const hash = await setApprovalOfOpenOrdersForAll({
+ *   chainId: 421614,
+ *   walletClient
+ * })
+ */
+export declare const setApprovalOfOpenOrdersForAll: ({ chainId, walletClient, options, }: {
+    chainId: CHAIN_IDS;
+    walletClient: WalletClient;
+    options?: DefaultOptions;
+}) => Promise<`0x${string}` | undefined>;
+/**
+ * @dev This function relates with `viem` dependency
+ * Approves the specified amount of tokens for the given account on the specified chain.
+ *
+ * @param {CHAIN_IDS} chainId The chain ID.
+ * @param {WalletClient} walletClient The wallet client.
+ * @param {`0x${string}`} token The ERC20 token address.
+ * @param {string | undefined} amount The amount to approve. If not provided, the maximum amount is approved.
+ * @param options
+ * @param options.rpcUrl The RPC URL of the blockchain.
+ * @returns {Promise<`0x${string}` | undefined>} Promise resolving to the transaction hash. If the account is already approved, the promise resolves to `undefined`.
  * @example
- * import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
- * import { mnemonicToAccount } from 'viem/accounts'
+ * import { approveERC20 } from '@clober/v2-sdk'
+ *
+ * const walletClient = createWalletClient({
+ *   chain: arbitrumSepolia,
+ *   account: mnemonicToAccount('legal ...'),
+ *   transport: http(),
+ * })
  *
- * const hash = await setApprovalOfOpenOrdersForAll(
- *   421614,
- *   mnemonicToAccount('legal ...')
- * )
+ * const hash = await approveERC20({
+ *   chainId: 421614,
+ *   walletClient
+ *   token: '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+ *   amount: '1000.123', // approve 1000.123 USDC
+ * })
  */
-export declare const setApprovalOfOpenOrdersForAll: (args: {
+export declare const approveERC20: ({ chainId, walletClient, token, amount, options, }: {
     chainId: CHAIN_IDS;
-    account: HDAccount | PrivateKeyAccount;
+    walletClient: WalletClient;
+    token: `0x${string}`;
+    amount?: string;
     options?: DefaultOptions;
 }) => Promise<`0x${string}` | undefined>;
 //# sourceMappingURL=approval.d.ts.map