@sentio/sdk 0.6.5 → 1.0.0-rc.2

package/lib/builtin/internal/eacaggregatorproxy_processor.js

@@ -0,0 +1,761 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEACAggregatorProxyContract = exports.EACAggregatorProxyProcessor = exports.EACAggregatorProxyProcessorTemplate = exports.EACAggregatorProxyBoundContractView = exports.EACAggregatorProxyContractView = void 0;
+const sdk_1 = require("@sentio/sdk");
+const index_1 = require("./index");
+const templateContract = index_1.EACAggregatorProxy__factory.connect("", sdk_1.DummyProvider);
+class EACAggregatorProxyContractView extends sdk_1.ContractView {
+    constructor(contract) {
+        super(contract);
+    }
+    async accessController(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.accessController(overrides);
+            }
+            else {
+                return await this.contract.accessController();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async aggregator(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.aggregator(overrides);
+            }
+            else {
+                return await this.contract.aggregator();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async decimals(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.decimals(overrides);
+            }
+            else {
+                return await this.contract.decimals();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async description(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.description(overrides);
+            }
+            else {
+                return await this.contract.description();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async getAnswer(_roundId, overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.getAnswer(_roundId, overrides);
+            }
+            else {
+                return await this.contract.getAnswer(_roundId);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async getRoundData(_roundId, overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.getRoundData(_roundId, overrides);
+            }
+            else {
+                return await this.contract.getRoundData(_roundId);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async getTimestamp(_roundId, overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.getTimestamp(_roundId, overrides);
+            }
+            else {
+                return await this.contract.getTimestamp(_roundId);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async latestAnswer(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.latestAnswer(overrides);
+            }
+            else {
+                return await this.contract.latestAnswer();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async latestRound(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.latestRound(overrides);
+            }
+            else {
+                return await this.contract.latestRound();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async latestRoundData(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.latestRoundData(overrides);
+            }
+            else {
+                return await this.contract.latestRoundData();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async latestTimestamp(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.latestTimestamp(overrides);
+            }
+            else {
+                return await this.contract.latestTimestamp();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async owner(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.owner(overrides);
+            }
+            else {
+                return await this.contract.owner();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async phaseAggregators(arg0, overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.phaseAggregators(arg0, overrides);
+            }
+            else {
+                return await this.contract.phaseAggregators(arg0);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async phaseId(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.phaseId(overrides);
+            }
+            else {
+                return await this.contract.phaseId();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async proposedAggregator(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.proposedAggregator(overrides);
+            }
+            else {
+                return await this.contract.proposedAggregator();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async proposedGetRoundData(_roundId, overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.proposedGetRoundData(_roundId, overrides);
+            }
+            else {
+                return await this.contract.proposedGetRoundData(_roundId);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async proposedLatestRoundData(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.proposedLatestRoundData(overrides);
+            }
+            else {
+                return await this.contract.proposedLatestRoundData();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+    async version(overrides) {
+        try {
+            if (overrides) {
+                return await this.contract.version(overrides);
+            }
+            else {
+                return await this.contract.version();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, undefined);
+        }
+    }
+}
+exports.EACAggregatorProxyContractView = EACAggregatorProxyContractView;
+class EACAggregatorProxyBoundContractView extends sdk_1.BoundContractView {
+    // constructor (contract: EACAggregatorProxy) {
+    //   super(contract);
+    // }
+    async accessController(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.accessController(overrides);
+            }
+            else {
+                return await this.view.accessController();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async aggregator(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.aggregator(overrides);
+            }
+            else {
+                return await this.view.aggregator();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async decimals(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.decimals(overrides);
+            }
+            else {
+                return await this.view.decimals();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async description(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.description(overrides);
+            }
+            else {
+                return await this.view.description();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async getAnswer(_roundId, overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.getAnswer(_roundId, overrides);
+            }
+            else {
+                return await this.view.getAnswer(_roundId);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async getRoundData(_roundId, overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.getRoundData(_roundId, overrides);
+            }
+            else {
+                return await this.view.getRoundData(_roundId);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async getTimestamp(_roundId, overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.getTimestamp(_roundId, overrides);
+            }
+            else {
+                return await this.view.getTimestamp(_roundId);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async latestAnswer(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.latestAnswer(overrides);
+            }
+            else {
+                return await this.view.latestAnswer();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async latestRound(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.latestRound(overrides);
+            }
+            else {
+                return await this.view.latestRound();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async latestRoundData(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.latestRoundData(overrides);
+            }
+            else {
+                return await this.view.latestRoundData();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async latestTimestamp(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.latestTimestamp(overrides);
+            }
+            else {
+                return await this.view.latestTimestamp();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async owner(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.owner(overrides);
+            }
+            else {
+                return await this.view.owner();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async phaseAggregators(arg0, overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.phaseAggregators(arg0, overrides);
+            }
+            else {
+                return await this.view.phaseAggregators(arg0);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async phaseId(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.phaseId(overrides);
+            }
+            else {
+                return await this.view.phaseId();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async proposedAggregator(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.proposedAggregator(overrides);
+            }
+            else {
+                return await this.view.proposedAggregator();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async proposedGetRoundData(_roundId, overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.proposedGetRoundData(_roundId, overrides);
+            }
+            else {
+                return await this.view.proposedGetRoundData(_roundId);
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async proposedLatestRoundData(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.proposedLatestRoundData(overrides);
+            }
+            else {
+                return await this.view.proposedLatestRoundData();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+    async version(overrides) {
+        try {
+            if (!overrides && this.context) {
+                overrides = {
+                    blockTag: this.context.blockNumber.toNumber(),
+                };
+            }
+            if (overrides) {
+                return await this.view.version(overrides);
+            }
+            else {
+                return await this.view.version();
+            }
+        }
+        catch (e) {
+            throw (0, sdk_1.transformEtherError)(e, this.context);
+        }
+    }
+}
+exports.EACAggregatorProxyBoundContractView = EACAggregatorProxyBoundContractView;
+class EACAggregatorProxyProcessorTemplate extends sdk_1.BaseProcessorTemplate {
+    bindInternal(options) {
+        if (!options.name) {
+            options.name = "EACAggregatorProxy";
+        }
+        let processor = (0, sdk_1.getProcessor)(options);
+        if (!processor) {
+            processor = new EACAggregatorProxyProcessor(options);
+            (0, sdk_1.addProcessor)(options, processor);
+        }
+        return processor;
+    }
+    onEventAnswerUpdated(handler, filter) {
+        if (!filter) {
+            // @ts-ignore
+            filter = EACAggregatorProxyProcessor.filters[
+            // @ts-ignore
+            "AnswerUpdated(int256,uint256,uint256)"](null, null, null);
+        }
+        return super.onEvent(handler, filter);
+    }
+    onEventNewRound(handler, filter) {
+        if (!filter) {
+            // @ts-ignore
+            filter = EACAggregatorProxyProcessor.filters[
+            // @ts-ignore
+            "NewRound(uint256,address,uint256)"](null, null, null);
+        }
+        return super.onEvent(handler, filter);
+    }
+    onEventOwnershipTransferRequested(handler, filter) {
+        if (!filter) {
+            // @ts-ignore
+            filter = EACAggregatorProxyProcessor.filters[
+            // @ts-ignore
+            "OwnershipTransferRequested(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter);
+    }
+    onEventOwnershipTransferred(handler, filter) {
+        if (!filter) {
+            // @ts-ignore
+            filter = EACAggregatorProxyProcessor.filters[
+            // @ts-ignore
+            "OwnershipTransferred(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter);
+    }
+}
+exports.EACAggregatorProxyProcessorTemplate = EACAggregatorProxyProcessorTemplate;
+class EACAggregatorProxyProcessor extends sdk_1.BaseProcessor {
+    onEventAnswerUpdated(handler, filter) {
+        if (!filter) {
+            // @ts-ignore
+            filter = EACAggregatorProxyProcessor.filters[
+            // @ts-ignore
+            "AnswerUpdated(int256,uint256,uint256)"](null, null, null);
+        }
+        return super.onEvent(handler, filter);
+    }
+    onEventNewRound(handler, filter) {
+        if (!filter) {
+            // @ts-ignore
+            filter = EACAggregatorProxyProcessor.filters[
+            // @ts-ignore
+            "NewRound(uint256,address,uint256)"](null, null, null);
+        }
+        return super.onEvent(handler, filter);
+    }
+    onEventOwnershipTransferRequested(handler, filter) {
+        if (!filter) {
+            // @ts-ignore
+            filter = EACAggregatorProxyProcessor.filters[
+            // @ts-ignore
+            "OwnershipTransferRequested(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter);
+    }
+    onEventOwnershipTransferred(handler, filter) {
+        if (!filter) {
+            // @ts-ignore
+            filter = EACAggregatorProxyProcessor.filters[
+            // @ts-ignore
+            "OwnershipTransferred(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter);
+    }
+    onCallAcceptOwnership(handler) {
+        return super.onTrace("0x79ba5097", handler);
+    }
+    onCallAccessController(handler) {
+        return super.onTrace("0xbc43cbaf", handler);
+    }
+    onCallAggregator(handler) {
+        return super.onTrace("0x245a7bfc", handler);
+    }
+    onCallConfirmAggregator(handler) {
+        return super.onTrace("0xa928c096", handler);
+    }
+    onCallDecimals(handler) {
+        return super.onTrace("0x313ce567", handler);
+    }
+    onCallDescription(handler) {
+        return super.onTrace("0x7284e416", handler);
+    }
+    onCallGetAnswer(handler) {
+        return super.onTrace("0xb5ab58dc", handler);
+    }
+    onCallGetRoundData(handler) {
+        return super.onTrace("0x9a6fc8f5", handler);
+    }
+    onCallGetTimestamp(handler) {
+        return super.onTrace("0xb633620c", handler);
+    }
+    onCallLatestAnswer(handler) {
+        return super.onTrace("0x50d25bcd", handler);
+    }
+    onCallLatestRound(handler) {
+        return super.onTrace("0x668a0f02", handler);
+    }
+    onCallLatestRoundData(handler) {
+        return super.onTrace("0xfeaf968c", handler);
+    }
+    onCallLatestTimestamp(handler) {
+        return super.onTrace("0x8205bf6a", handler);
+    }
+    onCallOwner(handler) {
+        return super.onTrace("0x8da5cb5b", handler);
+    }
+    onCallPhaseAggregators(handler) {
+        return super.onTrace("0xc1597304", handler);
+    }
+    onCallPhaseId(handler) {
+        return super.onTrace("0x58303b10", handler);
+    }
+    onCallProposeAggregator(handler) {
+        return super.onTrace("0xf8a2abd3", handler);
+    }
+    onCallProposedAggregator(handler) {
+        return super.onTrace("0xe8c4be30", handler);
+    }
+    onCallProposedGetRoundData(handler) {
+        return super.onTrace("0x6001ac53", handler);
+    }
+    onCallProposedLatestRoundData(handler) {
+        return super.onTrace("0x8f6b4d91", handler);
+    }
+    onCallSetController(handler) {
+        return super.onTrace("0x92eefe9b", handler);
+    }
+    onCallTransferOwnership(handler) {
+        return super.onTrace("0xf2fde38b", handler);
+    }
+    onCallVersion(handler) {
+        return super.onTrace("0x54fd4d50", handler);
+    }
+    static filters = templateContract.filters;
+    CreateBoundContractView() {
+        const view = getEACAggregatorProxyContract(this.config.address, this.config.network);
+        return new EACAggregatorProxyBoundContractView(view);
+    }
+    static bind(options) {
+        if (!options.name) {
+            options.name = "EACAggregatorProxy";
+        }
+        let processor = (0, sdk_1.getProcessor)(options);
+        if (!processor) {
+            processor = new EACAggregatorProxyProcessor(options);
+            (0, sdk_1.addProcessor)(options, processor);
+        }
+        return processor;
+    }
+}
+exports.EACAggregatorProxyProcessor = EACAggregatorProxyProcessor;
+function getEACAggregatorProxyContract(address, network = 1) {
+    let contract = (0, sdk_1.getContractByABI)("EACAggregatorProxy", address, network);
+    if (!contract) {
+        const rawContract = index_1.EACAggregatorProxy__factory.connect(address, (0, sdk_1.getProvider)(network));
+        contract = new EACAggregatorProxyContractView(rawContract);
+        (0, sdk_1.addContractByABI)("EACAggregatorProxy", address, network, contract);
+    }
+    return contract;
+}
+exports.getEACAggregatorProxyContract = getEACAggregatorProxyContract;
+//# sourceMappingURL=eacaggregatorproxy_processor.js.map