dequanto 0.0.1

package/dist/src/loggers/TxLoggerService.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxLoggerService = void 0;
+const TokenTransferService_1 = require("@dequanto/tokens/TokenTransferService");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _logger_1 = require("@dequanto/utils/$logger");
+const a_di_1 = __importDefault(require("a-di"));
+const everlog_1 = require("everlog");
+class TxLoggerService {
+    constructor(name) {
+        this.name = name;
+        this.logs = everlog_1.Everlog.createChannel(this.name, {
+            columns: [
+                {
+                    type: 'date',
+                    name: 'Date'
+                },
+                {
+                    type: 'string',
+                    name: 'Action'
+                },
+                {
+                    type: 'string',
+                    name: 'From'
+                },
+                {
+                    type: 'string',
+                    name: 'To'
+                },
+                {
+                    type: 'string',
+                    name: 'Tx',
+                },
+                {
+                    type: 'boolean',
+                    name: 'Status'
+                },
+                {
+                    type: 'number',
+                    name: 'Time'
+                },
+                {
+                    type: 'number',
+                    name: 'Gas Used',
+                },
+                {
+                    type: 'number',
+                    name: 'Gas Price',
+                }
+            ]
+        });
+    }
+    async logSwapTransaction(tx, swap) {
+        let service = a_di_1.default.resolve(TokenTransferService_1.TokenTransferService, tx.client);
+        let fromAmount = swap.amount ?? await service.getBalance(swap.account.address, swap.fromToken);
+        let [fromToken, toToken] = await Promise.all([
+            service.getToken(swap.fromToken),
+            service.getToken(swap.toToken),
+        ]);
+        let fromSymbol = fromToken.symbol;
+        let toSymbol = toToken.symbol;
+        return await this.logTransaction(`Swap`, tx, async (receipt) => {
+            let toAmount = await service.getReceived(receipt);
+            let fromAmountEth = _bigint_1.$bigint.toEther(fromAmount, fromToken.decimals);
+            let toAmountEth = _bigint_1.$bigint.toEther(toAmount, toToken.decimals);
+            _logger_1.$logger.log(`Swapped ${fromAmountEth}${fromSymbol} → ${toAmountEth}${toSymbol}`);
+            return [
+                { name: 'Tokens-Out', value: `${fromAmountEth}${fromSymbol}` },
+                { name: 'Tokens-In', value: `${toAmountEth}${toSymbol}` },
+            ];
+        });
+    }
+    async logTransaction(action, tx, onReceipt) {
+        if (tx == null) {
+            _logger_1.$logger.log(`TxLogger - Tx is undefined, possible reason: was not sent`);
+            this.logs.writeRow([
+                new Date(),
+                action
+            ]);
+            return;
+        }
+        let txData = tx.builder.data;
+        let gasPrice = 0n; //BigInt((txData.gasPrice) as string);
+        _logger_1.$logger.log(`TxLogger - Tx for action: ${action}; GasPrice: ${gasPrice}`);
+        tx.on('log', message => {
+            _logger_1.$logger.log(`Tx ${tx.client.platform}:`, message);
+        });
+        this.logs.writeRow([
+            new Date(),
+            action,
+            tx.account.name ?? tx.account.address,
+            '',
+            '',
+            '',
+            '',
+            '',
+            gasPrice
+        ]);
+        let started = Date.now();
+        let receipt = await tx.onCompleted;
+        let params = onReceipt ? await onReceipt(receipt) : [];
+        this.logs.writeRow([
+            new Date(),
+            action,
+            tx.account.address,
+            tx.builder.data.to,
+            receipt.transactionHash,
+            receipt.status,
+            Math.round((Date.now() - started) / 1000) + 's',
+            receipt.gasUsed,
+        ], params);
+        return receipt;
+    }
+    static async log(tx) {
+        let logger = a_di_1.default.resolve(TxLoggerService, 'transactions');
+        return logger.logTransaction('tx', tx);
+    }
+}
+exports.TxLoggerService = TxLoggerService;

package/dist/src/models/IContractDetails.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/IToken.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/ITokenGlob.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITokenGlob = void 0;
+class ITokenGlob {
+}
+exports.ITokenGlob = ITokenGlob;

package/dist/src/models/ITransactionDetails.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/TAddress.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/TBufferLike.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/THex.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/TPlatform.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/TResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/ns/NameService.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameService = void 0;
+const _require_1 = require("@dequanto/utils/$require");
+const EnsProvider_1 = require("./providers/EnsProvider");
+class NameService {
+    constructor(client) {
+        this.client = client;
+        this.providers = [
+            new EnsProvider_1.EnsProvider(this.client)
+        ];
+    }
+    getAddress(domain) {
+        let provider = this.providers.find(x => x.supports(domain));
+        _require_1.$require.notNull(provider, `NS Provider for ${domain} not found`);
+        return provider.getAddress(domain);
+    }
+}
+exports.NameService = NameService;

package/dist/src/ns/providers/EnsProvider.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnsProvider = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const ContractReader_1 = require("@dequanto/contracts/ContractReader");
+const _config_1 = require("@dequanto/utils/$config");
+const _require_1 = require("@dequanto/utils/$require");
+const _ns_1 = require("../utils/$ns");
+class EnsProvider {
+    constructor(client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
+        this.client = client;
+    }
+    supports(domain) {
+        return /\.eth$/.test(domain);
+    }
+    async getAddress(domain) {
+        let hash = _ns_1.$ns.namehash(domain);
+        let resolverAddr = await this.getResolverAddress(hash);
+        let address = await this.resolveAddress(hash, resolverAddr);
+        return address;
+    }
+    async resolveAddress(hash, resolverAddr) {
+        let registryAddr = _config_1.$config.get('ns.ens.registry');
+        _require_1.$require.Address(registryAddr);
+        let reader = new ContractReader_1.ContractReader(this.client);
+        let address = await reader.readAsync(resolverAddr, `addr(bytes32):address`, hash);
+        return address;
+    }
+    async getResolverAddress(hash) {
+        let registryAddr = _config_1.$config.get('ns.ens.registry');
+        _require_1.$require.Address(registryAddr);
+        let reader = new ContractReader_1.ContractReader(this.client);
+        let address = await reader.readAsync(registryAddr, `resolver(bytes32):address`, hash);
+        return address;
+    }
+}
+exports.EnsProvider = EnsProvider;

package/dist/src/ns/providers/INsProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/ns/providers/UDProvider.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UDProvider = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const ContractReader_1 = require("@dequanto/contracts/ContractReader");
+const _config_1 = require("@dequanto/utils/$config");
+const _require_1 = require("@dequanto/utils/$require");
+const _ns_1 = require("../utils/$ns");
+class UDProvider {
+    constructor(client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
+        this.client = client;
+    }
+    supports(domain) {
+        return /\.(x|crypto|coin|wallet|bitcoin|888|nft|dao|zil|blockchain)$/.test(domain);
+    }
+    async getAddress(domain) {
+        let hash = _ns_1.$ns.namehash(domain);
+        let resolverAddr = await this.getResolverAddress(hash);
+        let address = await this.resolveAddress(hash, resolverAddr);
+        return address;
+    }
+    async resolveAddress(hash, resolverAddr) {
+        let reader = new ContractReader_1.ContractReader(this.client);
+        let data = await reader.readAsync(resolverAddr, `getData(string[] keys, uint256 tokenId):(address,address,string[])`, ['crypto.ETH.address'], hash);
+        let info = data[2];
+        return info[0];
+    }
+    async getResolverAddress(hash) {
+        let platform = this.client.platform;
+        let registryAddr = _config_1.$config.get(`ns.ud.${platform}.registry`);
+        _require_1.$require.Address(registryAddr);
+        return registryAddr;
+    }
+}
+exports.UDProvider = UDProvider;

package/dist/src/ns/utils/$ns.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$ns = void 0;
+const web3_utils_1 = require("web3-utils");
+var $ns;
+(function ($ns) {
+    function namehash(domain) {
+        let labels = domain.toLowerCase().split('.');
+        let node = '0x' + ''.padStart(64, '0');
+        for (let i = labels.length - 1; i >= 0; i--) {
+            let labelSha = (0, web3_utils_1.keccak256)(labels[i]).substring(2);
+            node = (0, web3_utils_1.keccak256)(`${node}${labelSha}`);
+        }
+        return node;
+    }
+    $ns.namehash = namehash;
+})($ns = exports.$ns || (exports.$ns = {}));

package/dist/src/structs/PackedRanges.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackedRanges = void 0;
+const alot_1 = __importDefault(require("alot"));
+/**
+ *  Allows in a compact way to add/remove a number to the range; check if number was added.
+ */
+class PackedRanges {
+    constructor(opts) {
+        this.ranges = [];
+        this.from = 0;
+        if (opts != null) {
+            this.to = opts.to;
+            this.from = opts.from ?? opts.ranges?.[0]?.[0] ?? this.from;
+            this.ranges = opts.ranges ?? [];
+        }
+    }
+    total() {
+        let min = this.from;
+        let max = this.to ?? this.getMax();
+        if (min == null || max == null) {
+            return Infinity;
+        }
+        return max - min;
+    }
+    totalAdded() {
+        let count = 0;
+        for (let i = 0; i < this.ranges.length; i++) {
+            let [min, max] = this.ranges[i];
+            count += max - min + 1;
+        }
+        return count;
+    }
+    totalLeft() {
+        return this.total() - this.totalAdded();
+    }
+    next() {
+        let min = this.from;
+        if (this.ranges.length === 0) {
+            let x = min;
+            this.ranges.push([x, x]);
+            return x;
+        }
+        let [r0Min, r0Max] = this.ranges[0];
+        if (min < r0Min) {
+            this.add(min);
+            return min;
+        }
+        while (this.ranges.length > 1) {
+            let [r1Min, r1Max] = this.ranges[1];
+            let next = r0Max + 1;
+            if (next < r1Min) {
+                this.ranges[0][1] = next;
+                return next;
+            }
+            if (next === r1Min) {
+                this.ranges[0][1] = r1Max;
+                this.ranges.splice(1, 1);
+                continue;
+            }
+            throw new Error(`Unsorted ranges r0Max: ${r0Max}, r1Min: ${r1Min}`);
+        }
+        r0Max = this.ranges[0][1] + 1;
+        if (this.to != null && r0Max >= this.to) {
+            return null;
+        }
+        this.ranges[0][1] = r0Max;
+        return r0Max;
+    }
+    getMax() {
+        if (this.ranges.length === 0) {
+            return null;
+        }
+        let r = this.ranges[this.ranges.length - 1];
+        return r[1];
+    }
+    includes(nr) {
+        for (let i = 0; i < this.ranges.length; i++) {
+            let [a, b] = this.ranges[i];
+            if (a <= nr && nr <= b) {
+                return true;
+            }
+        }
+        return false;
+    }
+    add(nr) {
+        let modified = false;
+        for (let i = 0; i < this.ranges.length; i++) {
+            let [a, b] = this.ranges[i];
+            if (a <= nr && nr <= b) {
+                return false;
+            }
+            if (a - 1 === nr) {
+                this.ranges[i][0] = nr;
+                modified = true;
+                break;
+            }
+            if (b + 1 === nr) {
+                this.ranges[i][1] = nr;
+                modified = true;
+                break;
+            }
+        }
+        if (modified === false) {
+            // insert
+            let arr = [nr, nr];
+            let inserted = false;
+            for (let i = 0; i < this.ranges.length; i++) {
+                let [a] = this.ranges[i];
+                if (nr < a) {
+                    this.ranges.splice(i, 0, arr);
+                    inserted = true;
+                    break;
+                }
+            }
+            if (inserted === false) {
+                this.ranges.push(arr);
+            }
+        }
+        return true;
+    }
+    remove(nr) {
+        for (let i = 0; i < this.ranges.length; i++) {
+            let [min, max] = this.ranges[i];
+            if (min <= nr && nr <= max) {
+                if (min === max) {
+                    this.ranges.splice(i, 1);
+                    return true;
+                }
+                if (min === nr) {
+                    this.ranges[i][0] = min + 1;
+                    return true;
+                }
+                if (max === nr) {
+                    this.ranges[i][1] = max - 1;
+                    return true;
+                }
+                let arr1 = [min, nr - 1];
+                let arr2 = [nr + 1, max];
+                this.ranges.splice(i, 1, arr1, arr2);
+                return true;
+            }
+        }
+        return false;
+    }
+    compact() {
+        for (let i = 0; i < this.ranges.length; i++) {
+            let rangeA = this.ranges[i];
+            for (let j = i + 1; j < this.ranges.length; j++) {
+                let rangeB = this.ranges[j];
+                if (Ranges.overlaps(rangeA, rangeB)) {
+                    let [x1, y1] = rangeA;
+                    let [x2, y2] = rangeB;
+                    this.ranges[i] = [Math.min(x1, x2), Math.max(y1, y2)];
+                    this.ranges.splice(j, 1);
+                    j--;
+                    continue;
+                }
+            }
+        }
+        this.ranges = (0, alot_1.default)(this.ranges)
+            .sortBy(([x]) => x)
+            .toArray();
+    }
+    set(ranges) {
+        this.ranges = ranges;
+        this.compact();
+    }
+    serialize() {
+        return JSON.stringify(this.ranges);
+    }
+}
+exports.PackedRanges = PackedRanges;
+var Ranges;
+(function (Ranges) {
+    function overlaps(r1, r2) {
+        let [x1, y1] = r1;
+        let [x2, y2] = r2;
+        let d = Math.min(y1, y2) - Math.max(x1, x2);
+        return d > -1;
+    }
+    Ranges.overlaps = overlaps;
+})(Ranges || (Ranges = {}));

package/dist/src/structs/PackedRanges.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PackedRanges_1 = require("./PackedRanges");
+UTest({
+    'adding numbers'() {
+        let tracker = new PackedRanges_1.PackedRanges({
+            ranges: [[1, 100]]
+        });
+        tracker.add(101);
+        deepEq_(tracker.ranges, [[1, 101]]);
+        tracker.ranges = [[5, 100]];
+        tracker.add(4);
+        deepEq_(tracker.ranges, [[4, 100]]);
+        tracker.ranges = [[1, 100]];
+        tracker.add(102);
+        deepEq_(tracker.ranges, [[1, 100], [102, 102]]);
+        tracker.add(103);
+        deepEq_(tracker.ranges, [[1, 100], [102, 103]]);
+        tracker.add(101);
+        deepEq_(tracker.ranges, [[1, 101], [102, 103]]);
+        tracker.add(102);
+        deepEq_(tracker.ranges, [[1, 102], [102, 103]]);
+        tracker.compact();
+        deepEq_(tracker.ranges, [[1, 103]]);
+        eq_(tracker.includes(50), true);
+        eq_(tracker.includes(120), false);
+        tracker.remove(89);
+        deepEq_(tracker.ranges, [[1, 88], [90, 103]]);
+    }
+});

package/dist/src/tokens/TokenExchangeService.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenExchangeService = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const BlockChainExplorerProvider_1 = require("@dequanto/BlockchainExplorer/BlockChainExplorerProvider");
+const Web3ClientFactory_1 = require("@dequanto/clients/Web3ClientFactory");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const PancakeswapExchange_1 = require("./TokenExchanges/PancakeswapExchange");
+//import { UniswapExchange } from './TokenExchanges/UniswapExchange';
+const TokensService_1 = require("./TokensService");
+const TokenUtils_1 = require("./utils/TokenUtils");
+const UniswapExchange_1 = require("./TokenExchanges/UniswapExchange");
+const SushiswapPolygonExchange_1 = require("./TokenExchanges/SushiswapPolygonExchange");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _require_1 = require("@dequanto/utils/$require");
+class TokenExchangeService {
+    constructor(platform) {
+        this.platform = platform;
+        this.client = Web3ClientFactory_1.Web3ClientFactory.get(this.platform);
+        this.explorer = BlockChainExplorerProvider_1.BlockChainExplorerProvider.get(this.platform);
+        switch (platform) {
+            case 'bsc':
+                this.exchange = a_di_1.default.resolve(PancakeswapExchange_1.PancakeswapExchange, this.client, this.explorer);
+                this.stables = ['BUSD', 'USDT'];
+                break;
+            case 'eth':
+                this.exchange = a_di_1.default.resolve(UniswapExchange_1.UniswapExchange, this.client, this.explorer);
+                this.stables = ['USDC', 'USDT', 'DAI'];
+                break;
+            case 'polygon':
+                this.exchange = a_di_1.default.resolve(SushiswapPolygonExchange_1.SushiswapPolygonExchange, this.client, this.explorer);
+                this.stables = ['USDC', 'USDT', 'DAI'];
+                break;
+            default:
+                throw new Error(`Unsupported Platform for exchange yet: ${platform}`);
+        }
+    }
+    async calcUSD(from, fromAmount, date) {
+        let tokensService = a_di_1.default.resolve(TokensService_1.TokensService, this.platform, this.explorer);
+        let fromToken = typeof from === 'string'
+            ? await tokensService.getToken(from)
+            : from;
+        let $fromAmount = typeof fromAmount === 'bigint'
+            ? fromAmount
+            : _bigint_1.$bigint.toWei(fromAmount, fromToken.decimals ?? 18);
+        _require_1.$require.Address(fromToken?.address, `Token 404 ${from}`);
+        let converted = TokenUtils_1.TokenUtils.isStable(fromToken.symbol) ? {
+            to: {
+                ...fromToken,
+                amount: fromAmount,
+            },
+            priceImpact: 0
+        } : await (0, alot_1.default)(this.stables)
+            .mapAsync(async (stableSymbol) => {
+            let toToken = await tokensService.getToken(stableSymbol);
+            try {
+                let swapped = await this.exchange.calcSwap(fromToken, toToken, $fromAmount) ?? {
+                    amount: 0n,
+                    priceImpact: 0
+                };
+                return {
+                    to: {
+                        ...toToken,
+                        amount: swapped.amount
+                    },
+                    priceImpact: swapped.priceImpact,
+                };
+            }
+            catch (error) {
+                _logger_1.$logger.log('CalcStable error', error);
+                return null;
+            }
+        })
+            .filterAsync(x => x != null)
+            .firstAsync();
+        if (converted == null) {
+            throw new Error(`Do not know how to convert ${from} Token`);
+        }
+        return {
+            from: {
+                ...fromToken,
+                amount: $fromAmount,
+            },
+            to: converted.to,
+            priceImpact: converted.priceImpact
+        };
+    }
+    async calc(from, to, fromAmount) {
+        let tokensService = a_di_1.default.resolve(TokensService_1.TokensService, this.platform, this.explorer);
+        let fromToken = await tokensService.getToken(from);
+        let toToken = await tokensService.getToken(to);
+        let swapped = await this.exchange.calcSwap(fromToken, toToken, fromAmount);
+        return {
+            from: {
+                ...fromToken,
+                amount: fromAmount,
+            },
+            to: {
+                ...toToken,
+                amount: swapped.amount,
+            },
+            priceImpact: swapped.priceImpact,
+        };
+    }
+}
+exports.TokenExchangeService = TokenExchangeService;

package/dist/src/tokens/TokenExchanges/AmmBase/AmmUtilts.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmmUtils = void 0;
+var AmmUtils;
+(function (AmmUtils) {
+    function toSameBase(a, b, aAmount, bAmount) {
+        return [aAmount, bAmount];
+        let diff = (a.decimals ?? 18) - (b.decimals ?? 18);
+        if (diff === 0) {
+            return [aAmount, bAmount];
+        }
+        let aAmountOut = diff > 0 ? aAmount : (aAmount * 10n ** BigInt(diff * -1));
+        let bAmountOut = diff < 0 ? bAmount : (bAmount * 10n ** BigInt(diff));
+        return [aAmountOut, bAmountOut];
+    }
+    AmmUtils.toSameBase = toSameBase;
+})(AmmUtils = exports.AmmUtils || (exports.AmmUtils = {}));

package/dist/src/tokens/TokenExchanges/AmmBase/V2/AmmFactoryV2Contract.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * dequanto
+ * name: AmmFactoryV2ContractBase
+ * platform: bsc
+ * source.abi: 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73
+ * output: ./contracts/gen/amm/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmmFactoryV2Contract = void 0;
+const AmmFactoryV2ContractBase_1 = require("@dequanto-contracts/gen/amm/AmmFactoryV2ContractBase");
+/* https://docs.pancakeswap.finance/code/smart-contracts/pancakeswap-exchange/factory-v2 */
+class AmmFactoryV2Contract extends AmmFactoryV2ContractBase_1.AmmFactoryV2ContractBase {
+}
+exports.AmmFactoryV2Contract = AmmFactoryV2Contract;

package/dist/src/tokens/TokenExchanges/AmmBase/V2/AmmMasterChefV2Contract.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * dequanto
+ * name: AmmMasterChefV2ContractBase
+ * platform: bsc
+ * source.abi: 0x73feaa1eE314F8c655E354234017bE2193C9E24E
+ * output: ./contracts/gen/amm/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmmMasterChefV2Contract = void 0;
+const AmmMasterChefV2ContractBase_1 = require("@dequanto-contracts/gen/amm/AmmMasterChefV2ContractBase");
+/* https://docs.pancakeswap.finance/code/smart-contracts/main-staking-masterchef-contract */
+class AmmMasterChefV2Contract extends AmmMasterChefV2ContractBase_1.AmmMasterChefV2ContractBase {
+}
+exports.AmmMasterChefV2Contract = AmmMasterChefV2Contract;