@aurigami/sdk 1.23.1 → 1.24.1

package/dist/helpers/historicalPriceFetcher.d.ts

@@ -1,15 +1,15 @@
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN, providers } from 'ethers';
-import { Address } from '../types';
-export declare function fetchHistoricalLPPositions(LPAddress: Address, provider: providers.Provider, block: number): Promise<{
-    token0: Address;
-    token1: Address;
-    reserve0: BN;
-    reserve1: BN;
-    totalSupply: BN;
-}>;
-export declare function fetchHistoricalLPPrice(address: Address, provider: providers.Provider, block: number): Promise<BigNumber>;
-export declare function fetchHistoricalPriceFromOracle(auTokenAddress: Address, underlyingDecimal: number, provider: providers.Provider, block: number): Promise<BigNumber>;
-export declare function fetchHistoricalPrice(address: Address, provider: providers.Provider, block: number): Promise<BigNumber>;
-export declare function fetchHistoricalPULPPrice(provider: providers.Provider): Promise<BigNumber>;
-export declare function fetchHistoricalPriceByLP(LP: Address, provider: providers.Provider, block: number, tokenNumber?: 0 | 1): Promise<BigNumber>;
+import BigNumber from 'bignumber.js';
+import { BigNumber as BN, providers } from 'ethers';
+import { Address } from '../types';
+export declare function fetchHistoricalLPPositions(LPAddress: Address, provider: providers.Provider, block: number): Promise<{
+    token0: Address;
+    token1: Address;
+    reserve0: BN;
+    reserve1: BN;
+    totalSupply: BN;
+}>;
+export declare function fetchHistoricalLPPrice(address: Address, provider: providers.Provider, block: number): Promise<BigNumber>;
+export declare function fetchHistoricalPriceFromOracle(auTokenAddress: Address, underlyingDecimal: number, provider: providers.Provider, block: number): Promise<BigNumber>;
+export declare function fetchHistoricalPrice(address: Address, provider: providers.Provider, block: number): Promise<BigNumber>;
+export declare function fetchHistoricalPULPPrice(provider: providers.Provider): Promise<BigNumber>;
+export declare function fetchHistoricalPriceByLP(LP: Address, provider: providers.Provider, block: number, tokenNumber?: 0 | 1): Promise<BigNumber>;

package/dist/helpers/historicalPriceFetcher.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchHistoricalPriceByLP = exports.fetchHistoricalPULPPrice = exports.fetchHistoricalPrice = exports.fetchHistoricalPriceFromOracle = exports.fetchHistoricalLPPrice = exports.fetchHistoricalLPPositions = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const abis_1 = require("../abis");
+const constants_1 = require("../consts/constants");
+const helpers_1 = require("./helpers");
+const multicall_1 = require("./multicall");
+async function fetchHistoricalLPPositions(LPAddress, provider, block) {
+    const LPContract = (0, multicall_1.createContract)(LPAddress, abis_1.IUniswapV2PairABI.abi, provider);
+    var promises = [];
+    promises.push(LPContract.callStatic.token0());
+    promises.push(LPContract.callStatic.token1());
+    promises.push(LPContract.callStatic.getReserves({ blockTag: block }));
+    promises.push(LPContract.callStatic.totalSupply({ blockTag: block }));
+    const values = await Promise.all(promises);
+    return {
+        token0: values[0],
+        token1: values[1],
+        reserve0: values[2].reserve0,
+        reserve1: values[2].reserve1,
+        totalSupply: values[3],
+    };
+}
+exports.fetchHistoricalLPPositions = fetchHistoricalLPPositions;
+async function fetchHistoricalLPPrice(address, provider, block) {
+    var LPInfo = await fetchHistoricalLPPositions(address, provider, block);
+    const LPDecimal = (0, helpers_1.getDecimal)(address);
+    async function fetchLPPriceBy(tokenReverse, block) {
+        if (tokenReverse.reserve.isZero())
+            return new bignumber_js_1.default(0);
+        const tokenPrice = await fetchHistoricalPrice(tokenReverse.address, provider, block);
+        const tokenDecimal = (0, helpers_1.getDecimal)(tokenReverse.address);
+        const reserveUSD = tokenPrice
+            .multipliedBy(tokenReverse.reserve.toString())
+            .multipliedBy(2);
+        return reserveUSD
+            .multipliedBy((0, helpers_1.decimalFactor)(LPDecimal))
+            .dividedBy(new bignumber_js_1.default(LPInfo.totalSupply.toString()))
+            .dividedBy((0, helpers_1.decimalFactor)(tokenDecimal));
+    }
+    try {
+        const lpPrice = await fetchLPPriceBy({
+            address: LPInfo.token0,
+            reserve: LPInfo.reserve0,
+        }, block);
+        if (lpPrice.isZero()) {
+            throw Error(`Price is zero`);
+        }
+        return lpPrice;
+    }
+    catch (e) {
+        (0, helpers_1.devLog)(`fetchLPPriceBy ${LPInfo.token0} failed`, e);
+        try {
+            return await fetchLPPriceBy({
+                address: LPInfo.token1,
+                reserve: LPInfo.reserve1,
+            }, block);
+        }
+        catch (e) {
+            (0, helpers_1.devLog)(`fetchLPPriceBy ${LPInfo.token1} failed`, e);
+            throw Error(`Unable to fetch price for both tokens of LP ${address}`);
+        }
+    }
+}
+exports.fetchHistoricalLPPrice = fetchHistoricalLPPrice;
+function processPriceFromOracle(rawPrice, underlyingDecimal) {
+    return new bignumber_js_1.default(rawPrice.toString()).div((0, helpers_1.decimalFactor)(36 - underlyingDecimal));
+}
+async function fetchHistoricalPriceFromOracle(auTokenAddress, underlyingDecimal, provider, block) {
+    const oracleAddress = block < 102438637
+        ? constants_1.networkAddresses.misc.DEPRECATED_OLD_ORACLE
+        : constants_1.networkAddresses.misc.PYTH_ORACLE;
+    const oracleContract = (0, multicall_1.createContract)(oracleAddress, abis_1.AuriOracleABI.abi, provider);
+    const rawPrice = await oracleContract.callStatic
+        .getUnderlyingPrice(auTokenAddress, { blockTag: block })
+        .catch((e) => {
+        console.log(`Unable to fetch price from oracle for ${auTokenAddress}`);
+        return ethers_1.BigNumber.from(0);
+    });
+    return processPriceFromOracle(rawPrice, underlyingDecimal);
+}
+exports.fetchHistoricalPriceFromOracle = fetchHistoricalPriceFromOracle;
+async function fetchHistoricalPrice(address, provider, block) {
+    if (address.toLowerCase() in constants_1.HARDCODE_PRICE_TOKENS) {
+        return new bignumber_js_1.default(constants_1.HARDCODE_PRICE_TOKENS[address.toLowerCase()]);
+    }
+    else if ((0, helpers_1.isSameAddress)(address, constants_1.networkAddresses.tokens.PLY_WNEAR) ||
+        (0, helpers_1.isSameAddress)(address, constants_1.networkAddresses.tokens.WNEAR_TRI) ||
+        (0, helpers_1.isSameAddress)(address, constants_1.networkAddresses.tokens.AURORA_WNEAR)) {
+        return fetchHistoricalLPPrice(address, provider, block);
+    }
+    else if ((0, helpers_1.isSameAddress)(address, constants_1.networkAddresses.tokens.PLY)) {
+        return fetchHistoricalPriceByLP(constants_1.networkAddresses.tokens.PLY_WNEAR, provider, block);
+    }
+    else if ((0, helpers_1.isSameAddress)(address, constants_1.networkAddresses.tokens.TRI)) {
+        return fetchHistoricalPriceByLP(constants_1.networkAddresses.tokens.WNEAR_TRI, provider, block, 1);
+    }
+    else if ((0, helpers_1.isSameAddress)(address, constants_1.networkAddresses.tokens.AURORA)) {
+        return fetchHistoricalPriceByLP(constants_1.networkAddresses.tokens.AURORA_WNEAR, provider, block);
+    }
+    const matchingAuToken = constants_1.networkAddresses.auTokens.find((auToken) => {
+        return (0, helpers_1.isSameAddress)(auToken.underlying, address);
+    });
+    if (matchingAuToken !== undefined) {
+        return fetchHistoricalPriceFromOracle(matchingAuToken.address, (0, helpers_1.getDecimal)(address), provider, block);
+    }
+    else {
+        throw Error(`Unable to fetch price for ${address}`);
+    }
+}
+exports.fetchHistoricalPrice = fetchHistoricalPrice;
+async function fetchHistoricalPULPPrice(provider) {
+    return new bignumber_js_1.default(0);
+}
+exports.fetchHistoricalPULPPrice = fetchHistoricalPULPPrice;
+async function fetchHistoricalPriceByLP(LP, provider, block, tokenNumber = 0) {
+    let LPInfo = await fetchHistoricalLPPositions(LP, provider, block);
+    if (tokenNumber === 1) {
+        LPInfo = {
+            token0: LPInfo.token1,
+            token1: LPInfo.token0,
+            reserve0: LPInfo.reserve1,
+            reserve1: LPInfo.reserve0,
+            totalSupply: LPInfo.totalSupply,
+        };
+    }
+    if (LPInfo.reserve1.isZero()) {
+        return new bignumber_js_1.default(0);
+    }
+    const token0Decimal = (0, helpers_1.getDecimal)(LPInfo.token0);
+    const token1Decimal = (0, helpers_1.getDecimal)(LPInfo.token1);
+    return (await fetchHistoricalPrice(LPInfo.token1, provider, block))
+        .multipliedBy(LPInfo.reserve1.toString())
+        .multipliedBy((0, helpers_1.decimalFactor)(token0Decimal))
+        .dividedBy((0, helpers_1.decimalFactor)(token1Decimal))
+        .dividedBy(LPInfo.reserve0.toString());
+}
+exports.fetchHistoricalPriceByLP = fetchHistoricalPriceByLP;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/helpers/index.d.ts

@@ -1,7 +1,7 @@
-export * from './aurigami-api';
-export * from './aurora-api-helpers';
-export * from './graphql-helpers';
-export * from './helpers';
-export * from './priceFetcher';
-export * from './transfer-event-query';
-export * from './historicalPriceFetcher';
+export * from './aurigami-api';
+export * from './aurora-api-helpers';
+export * from './graphql-helpers';
+export * from './helpers';
+export * from './priceFetcher';
+export * from './transfer-event-query';
+export * from './historicalPriceFetcher';

package/dist/helpers/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./aurigami-api"), exports);
+tslib_1.__exportStar(require("./aurora-api-helpers"), exports);
+tslib_1.__exportStar(require("./graphql-helpers"), exports);
+tslib_1.__exportStar(require("./helpers"), exports);
+tslib_1.__exportStar(require("./priceFetcher"), exports);
+tslib_1.__exportStar(require("./transfer-event-query"), exports);
+tslib_1.__exportStar(require("./historicalPriceFetcher"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5REFBK0I7QUFDL0IsK0RBQXFDO0FBQ3JDLDREQUFrQztBQUNsQyxvREFBMEI7QUFDMUIseURBQStCO0FBQy9CLGlFQUF1QztBQUN2QyxtRUFBeUMifQ==

package/dist/helpers/kyber-aggregator-api.d.ts

@@ -1,5 +1,5 @@
-export declare function getSwapInfo(tokenIn: string, tokenOut: string, amountIn: string, onAurora?: boolean): Promise<KyberApiResponse>;
-export declare type KyberApiResponse = {
-    inputAmount: string;
-    outputAmount: string;
-};
+export declare function getSwapInfo(tokenIn: string, tokenOut: string, amountIn: string, onAurora?: boolean): Promise<KyberApiResponse>;
+export type KyberApiResponse = {
+    inputAmount: string;
+    outputAmount: string;
+};

package/dist/helpers/kyber-aggregator-api.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSwapInfo = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const KYBER_AGGREGATOR_AURORA_API_END_POINT = 'https://aggregator-api.kyberswap.com/aurora/route/encode';
+const KYBER_AGGREGATOR_ETH_API_END_POINT = 'https://aggregator-api.kyberswap.com/ethereum/route/encode';
+async function getSwapInfo(tokenIn, tokenOut, amountIn, onAurora = true) {
+    const params = {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        to: '0x0000000000000000000000000000000000000000',
+        useMeta: '1',
+        saveGas: '1',
+        gasInclude: '1',
+    };
+    const endpoint = onAurora
+        ? KYBER_AGGREGATOR_AURORA_API_END_POINT
+        : KYBER_AGGREGATOR_ETH_API_END_POINT;
+    const resp = await axios_1.default.get(endpoint + '?' + new URLSearchParams(params), {
+        headers: { 'Content-Type': 'application/json' },
+    });
+    return resp.data;
+}
+exports.getSwapInfo = getSwapInfo;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia3liZXItYWdncmVnYXRvci1hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9reWJlci1hZ2dyZWdhdG9yLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsMERBQTBCO0FBRTFCLE1BQU0scUNBQXFDLEdBQ3pDLDBEQUEwRCxDQUFDO0FBRTdELE1BQU0sa0NBQWtDLEdBQ3RDLDREQUE0RCxDQUFDO0FBRXhELEtBQUssVUFBVSxXQUFXLENBQy9CLE9BQWUsRUFDZixRQUFnQixFQUNoQixRQUFnQixFQUNoQixRQUFRLEdBQUcsSUFBSTtJQUVmLE1BQU0sTUFBTSxHQUFHO1FBQ2IsT0FBTztRQUNQLFFBQVE7UUFDUixRQUFRO1FBQ1IsRUFBRSxFQUFFLDRDQUE0QztRQUNoRCxPQUFPLEVBQUUsR0FBRztRQUNaLE9BQU8sRUFBRSxHQUFHO1FBQ1osVUFBVSxFQUFFLEdBQUc7S0FDaEIsQ0FBQztJQUNGLE1BQU0sUUFBUSxHQUFHLFFBQVE7UUFDdkIsQ0FBQyxDQUFDLHFDQUFxQztRQUN2QyxDQUFDLENBQUMsa0NBQWtDLENBQUM7SUFDdkMsTUFBTSxJQUFJLEdBQUcsTUFBTSxlQUFLLENBQUMsR0FBRyxDQUFDLFFBQVEsR0FBRyxHQUFHLEdBQUcsSUFBSSxlQUFlLENBQUMsTUFBTSxDQUFDLEVBQUU7UUFDekUsT0FBTyxFQUFFLEVBQUUsY0FBYyxFQUFFLGtCQUFrQixFQUFFO0tBQ2hELENBQUMsQ0FBQztJQUVILE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztBQUNuQixDQUFDO0FBdkJELGtDQXVCQyJ9

package/dist/helpers/multicall.d.ts

@@ -0,0 +1,40 @@
+import type { BlockTag } from '@ethersproject/abstract-provider';
+import type { Provider } from '@ethersproject/providers';
+import { CallOverrides, Contract, ContractInterface, Signer } from 'ethers';
+import { FunctionFragment } from 'ethers/lib/utils';
+import { MulticallOverrides, MulticallStatic } from '../types';
+export declare const DEFAULT_CALL_LIMIT = 32;
+declare class ContractCall {
+    fragment: FunctionFragment;
+    address: string;
+    params: any[];
+    constructor({ fragment, address, params, }: {
+        fragment: FunctionFragment;
+        address: string;
+        params: any[];
+    });
+}
+export declare class Multicall {
+    static isMulticallOverrides(overrides?: CallOverrides): overrides is MulticallOverrides | undefined;
+    private multicallContract;
+    readonly batchMap: Map<BlockTag, MulticallBatch>;
+    readonly callLimit: number;
+    readonly multicallStaticSymbol: symbol;
+    static wrap<T extends Contract>(contract: T, multicall: Multicall | undefined): MulticallStatic<T>;
+    constructor({ address, provider, callLimit, }: {
+        address: string;
+        provider: Provider | Signer;
+        callLimit?: number;
+    });
+    doAggregateCalls(calls: readonly ContractCall[], blockTag: BlockTag): Promise<any[]>;
+    wrap<T extends Contract>(contract_: T): MulticallStatic<T>;
+}
+declare class MulticallBatch {
+    private readonly multicallInstance;
+    readonly blockTag: BlockTag;
+    readonly pendingContractCalls: ContractCall[];
+    readonly promise: Promise<any[]>;
+    constructor(multicallInstance: Multicall, blockTag?: BlockTag);
+}
+export declare function createContract<T extends Contract>(addressOrName: string, contractInterface: ContractInterface, signerOrProvider: Signer | Provider): MulticallStatic<T>;
+export {};

package/dist/helpers/multicall.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContract = exports.Multicall = exports.DEFAULT_CALL_LIMIT = void 0;
+const ethers_1 = require("ethers");
+const utils_1 = require("ethers/lib/utils");
+const abis_1 = require("../abis");
+const TRANSFORMER = new utils_1.Interface([]);
+exports.DEFAULT_CALL_LIMIT = 32;
+class ContractCall {
+    constructor({ fragment, address, params, }) {
+        Object.defineProperty(this, "fragment", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "address", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "params", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fragment = fragment;
+        this.address = address;
+        this.params = params;
+    }
+}
+class Multicall {
+    static isMulticallOverrides(overrides) {
+        if (overrides === undefined) {
+            return true;
+        }
+        for (const key of Object.keys(overrides)) {
+            if (key !== 'blockTag' && overrides[key] != undefined) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static wrap(contract, multicall) {
+        return multicall ? multicall.wrap(contract) : contract;
+    }
+    constructor({ address, provider, callLimit, }) {
+        Object.defineProperty(this, "multicallContract", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "batchMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "callLimit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "multicallStaticSymbol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: Symbol.for('multicallStatic')
+        });
+        this.multicallContract = new ethers_1.Contract(address, abis_1.Multicall2ABI.abi, provider);
+        this.callLimit = callLimit ?? exports.DEFAULT_CALL_LIMIT;
+    }
+    async doAggregateCalls(calls, blockTag) {
+        const callRequests = calls.map((call) => ({
+            target: call.address,
+            callData: TRANSFORMER.encodeFunctionData(call.fragment, call.params),
+        }));
+        const responses = await this.multicallContract.callStatic.tryAggregate(false, callRequests, {
+            blockTag: blockTag,
+        });
+        const result = calls.map((call, i) => {
+            const [success, returnData] = responses[i];
+            try {
+                const outputs = call.fragment.outputs;
+                const params = TRANSFORMER.decodeFunctionResult(call.fragment, returnData);
+                if (!success) {
+                    const callId = utils_1.FunctionFragment.from(call.fragment).format();
+                    throw new Error(`Call ${call.address}:${callId} failed`);
+                }
+                return outputs.length === 1 ? params[0] : params;
+            }
+            catch (e) {
+                if (e.reason == null) {
+                    e.reason = 'Call failed for unknown reason';
+                }
+                return e;
+            }
+        });
+        return result;
+    }
+    wrap(contract_) {
+        const contract = contract_;
+        if (contract[this.multicallStaticSymbol]) {
+            return contract[this.multicallStaticSymbol];
+        }
+        const functions = contract_.interface.functions;
+        const funcs = {};
+        for (const [_, fn] of Object.entries(functions)) {
+            funcs[fn.name] = async (...params) => {
+                let blockTag = 'latest';
+                if (params.length === fn.inputs.length + 1) {
+                    const overrides = params.pop() ?? {};
+                    if (!Multicall.isMulticallOverrides(overrides)) {
+                        throw new Error('Overrides for multicall should contain only blockTag property');
+                    }
+                    blockTag = (await overrides.blockTag) ?? 'latest';
+                }
+                const contractCall = new ContractCall({
+                    fragment: fn,
+                    address: contract.address,
+                    params,
+                });
+                const res = new Promise((resolve, reject) => {
+                    let currentBatch = this.batchMap.get(blockTag);
+                    if (currentBatch === undefined) {
+                        currentBatch = new MulticallBatch(this, blockTag);
+                        this.batchMap.set(blockTag, currentBatch);
+                    }
+                    const dataPos = currentBatch.pendingContractCalls.length;
+                    currentBatch.pendingContractCalls.push(contractCall);
+                    currentBatch.promise
+                        .then((currentResult) => currentResult[dataPos] instanceof Error
+                        ? reject(currentResult[dataPos])
+                        : resolve(currentResult[dataPos]))
+                        .catch(reject);
+                    if (currentBatch.pendingContractCalls.length >= this.callLimit) {
+                        this.batchMap.delete(blockTag);
+                    }
+                });
+                return res;
+            };
+        }
+        const res = {
+            callStatic: funcs,
+            address: contract.address,
+            raw: contract,
+        };
+        Object.assign(contract, { [this.multicallStaticSymbol]: res });
+        return res;
+    }
+}
+exports.Multicall = Multicall;
+class MulticallBatch {
+    constructor(multicallInstance, blockTag = 'latest') {
+        Object.defineProperty(this, "multicallInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: multicallInstance
+        });
+        Object.defineProperty(this, "blockTag", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: blockTag
+        });
+        Object.defineProperty(this, "pendingContractCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "promise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.promise = Promise.resolve().then(async () => {
+            if (this.multicallInstance.batchMap.get(this.blockTag) === this) {
+                this.multicallInstance.batchMap.delete(this.blockTag);
+            }
+            return this.multicallInstance.doAggregateCalls(this.pendingContractCalls, this.blockTag);
+        });
+    }
+}
+let multicall;
+function createContract(addressOrName, contractInterface, signerOrProvider) {
+    const contract = new ethers_1.Contract(addressOrName, contractInterface, signerOrProvider);
+    if (!multicall) {
+        multicall = new Multicall({
+            address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+            provider: signerOrProvider,
+        });
+    }
+    return Multicall.wrap(contract, multicall);
+}
+exports.createContract = createContract;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/helpers/notification-api.d.ts

@@ -1,2 +1,2 @@
-export declare function getApi(url: string, params?: Record<string, any>): Promise<any>;
-export declare function postApi(url: string, body: Record<string, any>): Promise<any>;
+export declare function getApi(url: string, params?: Record<string, any>): Promise<any>;
+export declare function postApi(url: string, body: Record<string, any>): Promise<any>;

package/dist/helpers/notification-api.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postApi = exports.getApi = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const NOTIFICATION_API_END_POINT = 'https://api.aurigami.finance/notification/';
+async function getApi(url, params = {}) {
+    const resp = await axios_1.default.get(NOTIFICATION_API_END_POINT + url + '?' + new URLSearchParams(params), {
+        headers: { 'Content-Type': 'application/json' },
+    });
+    return resp.data;
+}
+exports.getApi = getApi;
+async function postApi(url, body) {
+    const resp = await axios_1.default.post(NOTIFICATION_API_END_POINT + url, body, {
+        headers: { 'Content-Type': 'application/json' },
+    });
+    return resp.data;
+}
+exports.postApi = postApi;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9oZWxwZXJzL25vdGlmaWNhdGlvbi1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLDBEQUEwQjtBQUUxQixNQUFNLDBCQUEwQixHQUFHLDRDQUE0QyxDQUFDO0FBRXpFLEtBQUssVUFBVSxNQUFNLENBQUMsR0FBVyxFQUFFLFNBQThCLEVBQUU7SUFDeEUsTUFBTSxJQUFJLEdBQUcsTUFBTSxlQUFLLENBQUMsR0FBRyxDQUMxQiwwQkFBMEIsR0FBRyxHQUFHLEdBQUcsR0FBRyxHQUFHLElBQUksZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUNwRTtRQUNFLE9BQU8sRUFBRSxFQUFFLGNBQWMsRUFBRSxrQkFBa0IsRUFBRTtLQUNoRCxDQUNGLENBQUM7SUFFRixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUM7QUFDbkIsQ0FBQztBQVRELHdCQVNDO0FBRU0sS0FBSyxVQUFVLE9BQU8sQ0FBQyxHQUFXLEVBQUUsSUFBeUI7SUFDbEUsTUFBTSxJQUFJLEdBQUcsTUFBTSxlQUFLLENBQUMsSUFBSSxDQUFDLDBCQUEwQixHQUFHLEdBQUcsRUFBRSxJQUFJLEVBQUU7UUFDcEUsT0FBTyxFQUFFLEVBQUUsY0FBYyxFQUFFLGtCQUFrQixFQUFFO0tBQ2hELENBQUMsQ0FBQztJQUVILE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztBQUNuQixDQUFDO0FBTkQsMEJBTUMifQ==

package/dist/helpers/one-inch-aggregator-api.d.ts

@@ -1,21 +1,21 @@
-export declare function getQuoteOneInch(fromTokenAddress: string, toTokenAddress: string, amount: string): Promise<OneInchApiResponse>;
-export declare type OneInchApiResponse = {
-    fromToken: {
-        symbol: string;
-        name: string;
-        decimals: number;
-        address: string;
-        logoURI: string;
-        tags: string[];
-    };
-    toToken: {
-        symbol: string;
-        name: string;
-        decimals: number;
-        address: string;
-        logoURI: string;
-        tags: string[];
-    };
-    toTokenAmount: string;
-    fromTokenAmount: string;
-};
+export declare function getQuoteOneInch(fromTokenAddress: string, toTokenAddress: string, amount: string): Promise<OneInchApiResponse>;
+export type OneInchApiResponse = {
+    fromToken: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string;
+        logoURI: string;
+        tags: string[];
+    };
+    toToken: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        address: string;
+        logoURI: string;
+        tags: string[];
+    };
+    toTokenAmount: string;
+    fromTokenAmount: string;
+};

package/dist/helpers/one-inch-aggregator-api.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuoteOneInch = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const ONEINCH_AGGREGATOR_API_END_POINT = 'https://api.1inch.io/v5.0/1313161554/quote';
+async function getQuoteOneInch(fromTokenAddress, toTokenAddress, amount) {
+    const params = {
+        fromTokenAddress,
+        toTokenAddress,
+        amount,
+    };
+    const resp = await axios_1.default.get(ONEINCH_AGGREGATOR_API_END_POINT + '?' + new URLSearchParams(params), {
+        headers: { 'Content-Type': 'application/json' },
+    });
+    return resp.data;
+}
+exports.getQuoteOneInch = getQuoteOneInch;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLWluY2gtYWdncmVnYXRvci1hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9vbmUtaW5jaC1hZ2dyZWdhdG9yLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsMERBQTBCO0FBRTFCLE1BQU0sZ0NBQWdDLEdBQUcsNENBQTRDLENBQUM7QUFFL0UsS0FBSyxVQUFVLGVBQWUsQ0FDbkMsZ0JBQXdCLEVBQ3hCLGNBQXNCLEVBQ3RCLE1BQWM7SUFFZCxNQUFNLE1BQU0sR0FBRztRQUNiLGdCQUFnQjtRQUNoQixjQUFjO1FBQ2QsTUFBTTtLQUNQLENBQUM7SUFDRixNQUFNLElBQUksR0FBRyxNQUFNLGVBQUssQ0FBQyxHQUFHLENBQzFCLGdDQUFnQyxHQUFHLEdBQUcsR0FBRyxJQUFJLGVBQWUsQ0FBQyxNQUFNLENBQUMsRUFDcEU7UUFDRSxPQUFPLEVBQUUsRUFBRSxjQUFjLEVBQUUsa0JBQWtCLEVBQUU7S0FDaEQsQ0FDRixDQUFDO0lBQ0YsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDO0FBQ25CLENBQUM7QUFqQkQsMENBaUJDIn0=