@orbs-network/twap 1.4.0

package/dist/src/lib.d.ts

@@ -0,0 +1,130 @@
+import { Config, TokenData } from "./configs";
+import BN from "bignumber.js";
+import type { TWAP } from "../typechain-hardhat/contracts";
+import type { Lens } from "../typechain-hardhat/contracts/periphery";
+export declare class TWAPLib {
+    config: Config;
+    provider: any;
+    maker: string;
+    twap: TWAP;
+    lens: Lens;
+    constructor(config: Config, provider: any, maker: string);
+    dstAmount: (srcAmount: BN.Value, srcUsd: BN.Value, dstUsd: BN.Value) => BN;
+    isNativeToken: (token: TokenData) => boolean;
+    isValidNetwork: (chainId: number) => boolean;
+    maxPossibleChunks: (srcToken: TokenData, srcAmount: BN.Value, srcUsd: BN.Value) => number;
+    srcChunkAmount: (srcAmount: BN.Value, totalChunks: BN.Value) => BN;
+    totalChunks: (srcAmount: BN.Value, srcChunkAmount: BN.Value) => BN;
+    fillDelayMillis: (totalChunks: BN.Value, maxDurationMillis: BN.Value) => BN;
+    dstMinAmountOut: (srcToken: TokenData, dstToken: TokenData, srcChunkAmount: BN.Value, limitDstPriceFor1Src: BN.Value, isMarketOrder: boolean) => BN;
+    isMarketOrder: (order: Order) => boolean;
+    orderProgress: (order: Order) => BN;
+    status: (order: Order) => Status;
+    makerBalance(token: TokenData): Promise<BN>;
+    wrapNativeToken(amount: BN.Value): Promise<any>;
+    waitForConfirmation<T>(fn: () => Promise<T>): Promise<T>;
+    hasAllowance(srcToken: TokenData, amount: BN.Value): Promise<boolean>;
+    approve(srcToken: TokenData, amount: BN.Value): Promise<void>;
+    validateOrderInputs(srcToken: TokenData, dstToken: TokenData, srcAmount: BN.Value, srcChunkAmount: BN.Value, dstMinChunkAmountOut: BN.Value, deadline: BN.Value, fillDelaySeconds: BN.Value, srcUsd: BN.Value): OrderInputValidation;
+    submitOrder(srcToken: TokenData, dstToken: TokenData, srcAmount: BN.Value, srcChunkAmount: BN.Value, dstMinChunkAmountOut: BN.Value, deadline: number, fillDelaySeconds: number, srcUsd: BN.Value): Promise<number>;
+    getOrder(id: number): Promise<Order>;
+    cancelOrder(id: number): Promise<void>;
+    getAllOrders(): Promise<{
+        id: number;
+        status: number;
+        filledTime: number;
+        srcFilledAmount: BN;
+        ask: {
+            time: number;
+            deadline: number;
+            bidDelay: number;
+            fillDelay: number;
+            maker: any;
+            exchange: any;
+            srcToken: any;
+            dstToken: any;
+            srcAmount: BN;
+            srcBidAmount: BN;
+            dstMinAmount: BN;
+        };
+        bid: {
+            time: number;
+            taker: any;
+            exchange: any;
+            dstAmount: BN;
+            dstFee: BN;
+            data: any;
+        };
+    }[]>;
+    parseOrder(r: any): {
+        id: number;
+        status: number;
+        filledTime: number;
+        srcFilledAmount: BN;
+        ask: {
+            time: number;
+            deadline: number;
+            bidDelay: number;
+            fillDelay: number;
+            maker: any;
+            exchange: any;
+            srcToken: any;
+            dstToken: any;
+            srcAmount: BN;
+            srcBidAmount: BN;
+            dstMinAmount: BN;
+        };
+        bid: {
+            time: number;
+            taker: any;
+            exchange: any;
+            dstAmount: BN;
+            dstFee: BN;
+            data: any;
+        };
+    };
+}
+export interface Order {
+    id: number;
+    status: number;
+    filledTime: number;
+    srcFilledAmount: BN;
+    ask: {
+        time: number;
+        deadline: number;
+        bidDelay: number;
+        fillDelay: number;
+        maker: string;
+        exchange: string;
+        srcToken: string;
+        dstToken: string;
+        srcAmount: BN;
+        srcBidAmount: BN;
+        dstMinAmount: BN;
+    };
+    bid: {
+        time: number;
+        taker: string;
+        exchange: string;
+        dstAmount: BN;
+        dstFee: BN;
+        data: string;
+    };
+}
+export declare enum Status {
+    Open = "Open",
+    Canceled = "Canceled",
+    Completed = "Completed",
+    Expired = "Expired"
+}
+export declare enum OrderInputValidation {
+    valid = "valid",
+    equalTokens = "equalTokens",
+    invalidSrcAmount = "invalidSrcAmount",
+    invalidSrcChunkAmount = "invalidSrcChunkAmount",
+    invalidDstMinChunkAmountOut = "invalidDstMinChunkAmountOut",
+    invalidDeadline = "invalidDeadline",
+    invalidFillDelaySeconds = "invalidFillDelaySeconds",
+    invalidSrcUsd = "invalidSrcUsd",
+    invalidSmallestSrcChunkUsd = "invalidSmallestSrcChunkUsd"
+}

package/dist/src/lib.js

@@ -0,0 +1,194 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderInputValidation = exports.Status = exports.TWAPLib = void 0;
+const configs_1 = require("./configs");
+const web3_1 = __importDefault(require("web3"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const web3_candies_1 = require("@defi.org/web3-candies");
+const TWAP_json_1 = __importDefault(require("../artifacts/contracts/TWAP.sol/TWAP.json"));
+const Lens_json_1 = __importDefault(require("../artifacts/contracts/periphery/Lens.sol/Lens.json"));
+const lodash_1 = __importDefault(require("lodash"));
+class TWAPLib {
+    constructor(config, provider, maker) {
+        this.config = config;
+        this.provider = provider;
+        this.maker = maker;
+        this.dstAmount = (srcAmount, srcUsd, dstUsd) => (0, bignumber_js_1.default)(srcAmount).times(srcUsd).idiv(dstUsd);
+        this.isNativeToken = (token) => !!lodash_1.default.find(configs_1.nativeTokenAddresses, (a) => (0, web3_candies_1.eqIgnoreCase)(a, token.address));
+        this.isValidNetwork = (chainId) => chainId === this.config.chainId;
+        this.maxPossibleChunks = (srcToken, srcAmount, srcUsd) => bignumber_js_1.default.max(1, (0, bignumber_js_1.default)(srcAmount).div((0, bignumber_js_1.default)(10).pow(srcToken.decimals).div(srcUsd).times(this.config.minChunkSizeUsd)))
+            .integerValue(bignumber_js_1.default.ROUND_FLOOR)
+            .toNumber();
+        this.srcChunkAmount = (srcAmount, totalChunks) => (0, bignumber_js_1.default)(srcAmount).div(totalChunks).integerValue(bignumber_js_1.default.ROUND_FLOOR);
+        this.totalChunks = (srcAmount, srcChunkAmount) => (0, bignumber_js_1.default)(srcAmount).div(srcChunkAmount).integerValue(bignumber_js_1.default.ROUND_CEIL);
+        this.fillDelayMillis = (totalChunks, maxDurationMillis) => (0, bignumber_js_1.default)(totalChunks).lte(0) || (0, bignumber_js_1.default)(maxDurationMillis).lte(0)
+            ? web3_candies_1.zero
+            : bignumber_js_1.default.max((0, bignumber_js_1.default)(maxDurationMillis)
+                .div(totalChunks)
+                .minus((0, bignumber_js_1.default)(this.config.bidDelaySeconds * 1000)), 0);
+        this.dstMinAmountOut = (srcToken, dstToken, srcChunkAmount, limitDstPriceFor1Src, isMarketOrder) => isMarketOrder
+            ? (0, bignumber_js_1.default)(1)
+            : (0, web3_candies_1.convertDecimals)((0, bignumber_js_1.default)(srcChunkAmount).times(limitDstPriceFor1Src), srcToken.decimals, dstToken.decimals).integerValue(bignumber_js_1.default.ROUND_FLOOR);
+        this.isMarketOrder = (order) => order.ask.dstMinAmount.lte(1);
+        this.orderProgress = (order) => order.srcFilledAmount.div(order.ask.srcAmount);
+        this.status = (order) => order.status > Date.now() / 1000
+            ? Status.Open
+            : order.status === 1
+                ? Status.Canceled
+                : order.status === 2
+                    ? Status.Completed
+                    : Status.Expired;
+        (0, web3_candies_1.setWeb3Instance)(new web3_1.default(provider));
+        this.twap = (0, web3_candies_1.contract)(TWAP_json_1.default.abi, this.config.twapAddress);
+        this.lens = (0, web3_candies_1.contract)(Lens_json_1.default.abi, this.config.lensAddress);
+    }
+    makerBalance(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isNativeToken(token))
+                return (0, web3_candies_1.web3)().eth.getBalance(this.maker).then(bignumber_js_1.default);
+            else
+                return (0, web3_candies_1.erc20)(token.symbol, token.address, token.decimals).methods.balanceOf(this.maker).call().then(bignumber_js_1.default);
+        });
+    }
+    wrapNativeToken(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, web3_candies_1.erc20)(this.config.wToken.symbol, this.config.wToken.address, this.config.wToken.decimals, web3_candies_1.iwethabi)
+                .methods.deposit()
+                .send({ from: this.maker, value: (0, bignumber_js_1.default)(amount).toFixed(0) });
+        });
+    }
+    waitForConfirmation(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonceBefore = yield (0, web3_candies_1.web3)().eth.getTransactionCount(this.maker);
+            const result = yield fn();
+            while ((yield (0, web3_candies_1.web3)().eth.getTransactionCount(this.maker)) === nonceBefore) {
+                yield new Promise((r) => setTimeout(r, 1000));
+            }
+            return result;
+        });
+    }
+    hasAllowance(srcToken, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = (0, web3_candies_1.erc20)(srcToken.symbol, srcToken.address, srcToken.decimals);
+            const allowance = (0, bignumber_js_1.default)(yield token.methods.allowance(this.maker, this.config.twapAddress).call());
+            return allowance.gte(amount);
+        });
+    }
+    approve(srcToken, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = (0, web3_candies_1.erc20)(srcToken.symbol, srcToken.address, srcToken.decimals);
+            yield token.methods.approve(this.config.twapAddress, amount.toString()).send({ from: this.maker });
+        });
+    }
+    validateOrderInputs(srcToken, dstToken, srcAmount, srcChunkAmount, dstMinChunkAmountOut, deadline, fillDelaySeconds, srcUsd) {
+        if (lodash_1.default.isEqual(srcToken, dstToken))
+            return OrderInputValidation.equalTokens;
+        if ((0, bignumber_js_1.default)(srcAmount).lte(0))
+            return OrderInputValidation.invalidSrcAmount;
+        if ((0, bignumber_js_1.default)(srcChunkAmount).lte(0) || (0, bignumber_js_1.default)(srcChunkAmount).gt(srcAmount))
+            return OrderInputValidation.invalidSrcChunkAmount;
+        if ((0, bignumber_js_1.default)(dstMinChunkAmountOut).lte(0))
+            return OrderInputValidation.invalidDstMinChunkAmountOut;
+        if ((0, bignumber_js_1.default)(deadline).integerValue(bignumber_js_1.default.ROUND_FLOOR).lte(Date.now()))
+            return OrderInputValidation.invalidDeadline;
+        if ((0, bignumber_js_1.default)(fillDelaySeconds).integerValue(bignumber_js_1.default.ROUND_FLOOR).lt(0))
+            return OrderInputValidation.invalidFillDelaySeconds;
+        if ((0, bignumber_js_1.default)(srcUsd).lte(0))
+            return OrderInputValidation.invalidSrcUsd;
+        const smallestChunkSize = (0, bignumber_js_1.default)(srcAmount).mod(srcChunkAmount).gt(0)
+            ? (0, bignumber_js_1.default)(srcAmount).mod(srcChunkAmount)
+            : (0, bignumber_js_1.default)(srcChunkAmount);
+        if (smallestChunkSize.times(srcUsd).lt(this.config.minChunkSizeUsd))
+            return OrderInputValidation.invalidSmallestSrcChunkUsd;
+        return OrderInputValidation.valid;
+    }
+    submitOrder(srcToken, dstToken, srcAmount, srcChunkAmount, dstMinChunkAmountOut, deadline, fillDelaySeconds, srcUsd) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let validation = this.validateOrderInputs(srcToken, dstToken, srcAmount, srcChunkAmount, dstMinChunkAmountOut, deadline, fillDelaySeconds, srcUsd);
+            if (validation !== OrderInputValidation.valid)
+                throw new Error(`invalid inputs: ${validation}`);
+            const tx = yield this.twap.methods
+                .ask(this.config.exchangeAddress, srcToken.address, dstToken.address, (0, bignumber_js_1.default)(srcAmount).toFixed(0), (0, bignumber_js_1.default)(srcChunkAmount).toFixed(0), (0, bignumber_js_1.default)(dstMinChunkAmountOut).toFixed(0), (0, bignumber_js_1.default)(deadline).div(1000).toFixed(0), (0, bignumber_js_1.default)(this.config.bidDelaySeconds).toFixed(0), (0, bignumber_js_1.default)(fillDelaySeconds).toFixed(0))
+                .send({ from: this.maker });
+            const events = (0, web3_candies_1.parseEvents)(tx, this.twap.options.jsonInterface);
+            return Number(events[0].returnValues.id);
+        });
+    }
+    getOrder(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.parseOrder(yield this.twap.methods.order(id).call());
+        });
+    }
+    cancelOrder(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.twap.methods.cancel(id).send({ from: this.maker });
+        });
+    }
+    getAllOrders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return lodash_1.default.map(yield this.lens.methods.makerOrders(this.maker).call(), (o) => this.parseOrder(o));
+        });
+    }
+    parseOrder(r) {
+        var _a, _b, _c, _d, _e, _f;
+        return {
+            id: Number(r.id),
+            status: Number(r.status),
+            filledTime: Number(r.filledTime),
+            srcFilledAmount: (0, bignumber_js_1.default)(r.srcFilledAmount),
+            ask: {
+                time: Number(r.ask.time),
+                deadline: Number(r.ask.deadline),
+                bidDelay: Number(r.ask.bidDelay),
+                fillDelay: Number(r.ask.fillDelay),
+                maker: r.ask.maker,
+                exchange: r.ask.exchange,
+                srcToken: r.ask.srcToken,
+                dstToken: r.ask.dstToken,
+                srcAmount: (0, bignumber_js_1.default)(r.ask.srcAmount),
+                srcBidAmount: (0, bignumber_js_1.default)(r.ask.srcBidAmount),
+                dstMinAmount: (0, bignumber_js_1.default)(r.ask.dstMinAmount),
+            },
+            bid: {
+                time: Number(((_a = r.bid) === null || _a === void 0 ? void 0 : _a.time) || 0),
+                taker: ((_b = r.bid) === null || _b === void 0 ? void 0 : _b.taker) || "",
+                exchange: ((_c = r.bid) === null || _c === void 0 ? void 0 : _c.exchange) || "",
+                dstAmount: (0, bignumber_js_1.default)(((_d = r.bid) === null || _d === void 0 ? void 0 : _d.dstAmount) || web3_candies_1.zero),
+                dstFee: (0, bignumber_js_1.default)(((_e = r.bid) === null || _e === void 0 ? void 0 : _e.dstFee) || web3_candies_1.zero),
+                data: ((_f = r.bid) === null || _f === void 0 ? void 0 : _f.data) || "",
+            },
+        };
+    }
+}
+exports.TWAPLib = TWAPLib;
+var Status;
+(function (Status) {
+    Status["Open"] = "Open";
+    Status["Canceled"] = "Canceled";
+    Status["Completed"] = "Completed";
+    Status["Expired"] = "Expired";
+})(Status = exports.Status || (exports.Status = {}));
+var OrderInputValidation;
+(function (OrderInputValidation) {
+    OrderInputValidation["valid"] = "valid";
+    OrderInputValidation["equalTokens"] = "equalTokens";
+    OrderInputValidation["invalidSrcAmount"] = "invalidSrcAmount";
+    OrderInputValidation["invalidSrcChunkAmount"] = "invalidSrcChunkAmount";
+    OrderInputValidation["invalidDstMinChunkAmountOut"] = "invalidDstMinChunkAmountOut";
+    OrderInputValidation["invalidDeadline"] = "invalidDeadline";
+    OrderInputValidation["invalidFillDelaySeconds"] = "invalidFillDelaySeconds";
+    OrderInputValidation["invalidSrcUsd"] = "invalidSrcUsd";
+    OrderInputValidation["invalidSmallestSrcChunkUsd"] = "invalidSmallestSrcChunkUsd";
+})(OrderInputValidation = exports.OrderInputValidation || (exports.OrderInputValidation = {}));

package/dist/src/paraswap.d.ts

@@ -0,0 +1,33 @@
+import BN from "bignumber.js";
+import { TokenData } from "./configs";
+export declare namespace Paraswap {
+    enum OnlyDex {
+        SpiritSwap = "SpiritSwap,SpiritSwapV2",
+        SpookySwap = "SpookySwap"
+    }
+    interface ParaswapRoute {
+        blockNumber: number;
+        network: number;
+        srcToken: string;
+        destToken: string;
+        srcDecimals: number;
+        destDecimals: number;
+        srcAmount: string;
+        destAmount: string;
+        bestRoute: any[];
+        gasCostUSD: string;
+        gasCost: string;
+        side: string;
+        tokenTransferProxy: string;
+        contractAddress: string;
+        contractMethod: string;
+        partnerFee: number;
+        srcUSD: string;
+        destUSD: string;
+        partner: string;
+        maxImpactReached: boolean;
+    }
+    function priceUsd(chainId: number, token: TokenData): Promise<BN>;
+    function findRoute(chainId: number, src: TokenData, dst: TokenData, amountIn: BN.Value, onlyDex?: OnlyDex): Promise<ParaswapRoute>;
+    function buildSwapData(dstMinOut: BN.Value, paraswapRoute: ParaswapRoute, exchangeAdapter: string): Promise<string>;
+}

package/dist/src/paraswap.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Paraswap = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const axios_1 = __importDefault(require("axios"));
+const web3_candies_1 = require("@defi.org/web3-candies");
+var Paraswap;
+(function (Paraswap) {
+    const URL = "https://apiv5.paraswap.io";
+    let OnlyDex;
+    (function (OnlyDex) {
+        OnlyDex["SpiritSwap"] = "SpiritSwap,SpiritSwapV2";
+        OnlyDex["SpookySwap"] = "SpookySwap";
+    })(OnlyDex = Paraswap.OnlyDex || (Paraswap.OnlyDex = {}));
+    function priceUsd(chainId, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = yield findRoute(chainId, token, token, (0, bignumber_js_1.default)(10).pow(token.decimals));
+            return (0, bignumber_js_1.default)(r.srcUSD);
+        });
+    }
+    Paraswap.priceUsd = priceUsd;
+    function findRoute(chainId, src, dst, amountIn, onlyDex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = new URLSearchParams({
+                srcToken: src.address,
+                destToken: dst.address,
+                srcDecimals: src.decimals.toString(),
+                destDecimals: dst.decimals.toString(),
+                amount: amountIn.toString(),
+                network: chainId.toString(),
+                side: "SELL",
+                includeDEXS: onlyDex || "",
+                partner: "chucknorris",
+                // otherExchangePrices: "true",
+            });
+            const response = yield axios_1.default.get(`${URL}/prices/?${params}`);
+            if (response.status < 200 || response.status >= 400)
+                throw new Error(`${response.statusText}`);
+            return response.data.priceRoute;
+        });
+    }
+    Paraswap.findRoute = findRoute;
+    function buildSwapData(dstMinOut, paraswapRoute, exchangeAdapter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(`${URL}/transactions/${paraswapRoute.network}?ignoreChecks=true`, {
+                priceRoute: paraswapRoute,
+                srcToken: paraswapRoute.srcToken,
+                destToken: paraswapRoute.destToken,
+                srcDecimals: paraswapRoute.srcDecimals,
+                destDecimals: paraswapRoute.destDecimals,
+                srcAmount: paraswapRoute.srcAmount,
+                destAmount: (0, bignumber_js_1.default)(dstMinOut).toFixed(0),
+                userAddress: exchangeAdapter,
+            });
+            if (response.status < 200 || response.status >= 400)
+                throw new Error(`${response.statusText}`);
+            return (0, web3_candies_1.web3)().eth.abi.encodeParameters(["uint256", "bytes"], [paraswapRoute.destAmount, response.data.data]);
+        });
+    }
+    Paraswap.buildSwapData = buildSwapData;
+})(Paraswap = exports.Paraswap || (exports.Paraswap = {}));

package/dist/typechain-hardhat/contracts/IExchange.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import type BN from "bn.js";
+import type BigNumber from "bignumber.js";
+import type { ContractOptions } from "web3-eth-contract";
+import type { EventLog } from "web3-core";
+import type { EventEmitter } from "events";
+import type { Callback, NonPayableTransactionObject, BlockType, BaseContract } from "../types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export interface IExchange extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): IExchange;
+    clone(): IExchange;
+    methods: {
+        getAmountOut(srcToken: string, dstToken: string, amountIn: number | string | BN | BigNumber, data: string | number[]): NonPayableTransactionObject<string>;
+        swap(srcToken: string, dstToken: string, amountIn: number | string | BN | BigNumber, amountOutMin: number | string | BN | BigNumber, data: string | number[]): NonPayableTransactionObject<void>;
+    };
+    events: {
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+}

package/dist/typechain-hardhat/contracts/IExchange.js

@@ -0,0 +1,5 @@
+"use strict";
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/typechain-hardhat/contracts/TWAP.d.ts

@@ -0,0 +1,204 @@
+/// <reference types="node" />
+import type BN from "bn.js";
+import type BigNumber from "bignumber.js";
+import type { ContractOptions } from "web3-eth-contract";
+import type { EventLog } from "web3-core";
+import type { EventEmitter } from "events";
+import type { Callback, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "../types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export declare type OrderBid = ContractEventLog<{
+    id: string;
+    maker: string;
+    exchange: string;
+    slippagePercent: string;
+    bid: [string, string, string, string, string, string];
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: [string, string, string, string, string, string];
+}>;
+export declare type OrderCanceled = ContractEventLog<{
+    id: string;
+    maker: string;
+    sender: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type OrderCompleted = ContractEventLog<{
+    id: string;
+    maker: string;
+    exchange: string;
+    taker: string;
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+}>;
+export declare type OrderCreated = ContractEventLog<{
+    id: string;
+    maker: string;
+    exchange: string;
+    ask: [
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+    0: string;
+    1: string;
+    2: string;
+    3: [
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+}>;
+export declare type OrderFilled = ContractEventLog<{
+    id: string;
+    maker: string;
+    exchange: string;
+    taker: string;
+    srcAmountIn: string;
+    dstAmountOut: string;
+    dstFee: string;
+    srcFilledAmount: string;
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+}>;
+export interface TWAP extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): TWAP;
+    clone(): TWAP;
+    methods: {
+        MIN_BID_DELAY_SECONDS(): NonPayableTransactionObject<string>;
+        MIN_OUTBID_PERCENT(): NonPayableTransactionObject<string>;
+        PERCENT_BASE(): NonPayableTransactionObject<string>;
+        STALE_BID_DELAY_MUL(): NonPayableTransactionObject<string>;
+        STATUS_CANCELED(): NonPayableTransactionObject<string>;
+        STATUS_COMPLETED(): NonPayableTransactionObject<string>;
+        VERSION(): NonPayableTransactionObject<string>;
+        ask(exchange: string, srcToken: string, dstToken: string, srcAmount: number | string | BN | BigNumber, srcBidAmount: number | string | BN | BigNumber, dstMinAmount: number | string | BN | BigNumber, deadline: number | string | BN | BigNumber, bidDelay: number | string | BN | BigNumber, fillDelay: number | string | BN | BigNumber): NonPayableTransactionObject<string>;
+        bid(id: number | string | BN | BigNumber, exchange: string, dstFee: number | string | BN | BigNumber, slippagePercent: number | string | BN | BigNumber, data: string | number[]): NonPayableTransactionObject<void>;
+        book(arg0: number | string | BN | BigNumber): NonPayableTransactionObject<{
+            id: string;
+            status: string;
+            filledTime: string;
+            srcFilledAmount: string;
+            ask: [
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string
+            ];
+            bid: [string, string, string, string, string, string];
+            0: string;
+            1: string;
+            2: string;
+            3: string;
+            4: [
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string
+            ];
+            5: [string, string, string, string, string, string];
+        }>;
+        cancel(id: number | string | BN | BigNumber): NonPayableTransactionObject<void>;
+        fill(id: number | string | BN | BigNumber): NonPayableTransactionObject<void>;
+        length(): NonPayableTransactionObject<string>;
+        makerOrders(arg0: string, arg1: number | string | BN | BigNumber): NonPayableTransactionObject<string>;
+        order(id: number | string | BN | BigNumber): NonPayableTransactionObject<[
+            string,
+            string,
+            string,
+            string,
+            [
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string
+            ],
+            [
+                string,
+                string,
+                string,
+                string,
+                string,
+                string
+            ]
+        ]>;
+        orderIdsByMaker(maker: string): NonPayableTransactionObject<string[]>;
+        prune(id: number | string | BN | BigNumber): NonPayableTransactionObject<void>;
+        status(arg0: number | string | BN | BigNumber): NonPayableTransactionObject<string>;
+    };
+    events: {
+        OrderBid(cb?: Callback<OrderBid>): EventEmitter;
+        OrderBid(options?: EventOptions, cb?: Callback<OrderBid>): EventEmitter;
+        OrderCanceled(cb?: Callback<OrderCanceled>): EventEmitter;
+        OrderCanceled(options?: EventOptions, cb?: Callback<OrderCanceled>): EventEmitter;
+        OrderCompleted(cb?: Callback<OrderCompleted>): EventEmitter;
+        OrderCompleted(options?: EventOptions, cb?: Callback<OrderCompleted>): EventEmitter;
+        OrderCreated(cb?: Callback<OrderCreated>): EventEmitter;
+        OrderCreated(options?: EventOptions, cb?: Callback<OrderCreated>): EventEmitter;
+        OrderFilled(cb?: Callback<OrderFilled>): EventEmitter;
+        OrderFilled(options?: EventOptions, cb?: Callback<OrderFilled>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "OrderBid", cb: Callback<OrderBid>): void;
+    once(event: "OrderBid", options: EventOptions, cb: Callback<OrderBid>): void;
+    once(event: "OrderCanceled", cb: Callback<OrderCanceled>): void;
+    once(event: "OrderCanceled", options: EventOptions, cb: Callback<OrderCanceled>): void;
+    once(event: "OrderCompleted", cb: Callback<OrderCompleted>): void;
+    once(event: "OrderCompleted", options: EventOptions, cb: Callback<OrderCompleted>): void;
+    once(event: "OrderCreated", cb: Callback<OrderCreated>): void;
+    once(event: "OrderCreated", options: EventOptions, cb: Callback<OrderCreated>): void;
+    once(event: "OrderFilled", cb: Callback<OrderFilled>): void;
+    once(event: "OrderFilled", options: EventOptions, cb: Callback<OrderFilled>): void;
+}

package/dist/typechain-hardhat/contracts/TWAP.js

@@ -0,0 +1,5 @@
+"use strict";
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });