@sentio/sdk 2.3.5 → 2.4.0-rc.1

package/lib/eth/tests/types/internal/pyth-processor.js

@@ -0,0 +1,890 @@
+import { addContractByABI, getContractByABI, addProcessor, getProcessor, getProvider, transformEtherError, BaseProcessor, BaseProcessorTemplate, BoundContractView, ContractView, DummyProvider, toBlockTag, } from "@sentio/sdk/eth";
+import { Pyth__factory } from "./index.js";
+const templateContract = Pyth__factory.connect("0x0", DummyProvider);
+export class PythContractView extends ContractView {
+    constructor(contract) {
+        super(contract);
+    }
+    async chainId(overrides) {
+        try {
+            return await this.contract.getFunction("chainId()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getEmaPrice(id, overrides) {
+        try {
+            return await this.contract.getFunction("getEmaPrice(bytes32)")(id, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getEmaPriceNoOlderThan(id, age, overrides) {
+        try {
+            return await this.contract.getFunction("getEmaPriceNoOlderThan(bytes32,uint256)")(id, age, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getEmaPriceUnsafe(id, overrides) {
+        try {
+            return await this.contract.getFunction("getEmaPriceUnsafe(bytes32)")(id, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getPrice(id, overrides) {
+        try {
+            return await this.contract.getFunction("getPrice(bytes32)")(id, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getPriceNoOlderThan(id, age, overrides) {
+        try {
+            return await this.contract.getFunction("getPriceNoOlderThan(bytes32,uint256)")(id, age, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getPriceUnsafe(id, overrides) {
+        try {
+            return await this.contract.getFunction("getPriceUnsafe(bytes32)")(id, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getUpdateFee_bytes_array(updateData, overrides) {
+        try {
+            return await this.contract.getFunction("getUpdateFee(bytes[])")(updateData, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getUpdateFee_uint256(updateDataSize, overrides) {
+        try {
+            return await this.contract.getFunction("getUpdateFee(uint256)")(updateDataSize, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getValidTimePeriod(overrides) {
+        try {
+            return await this.contract.getFunction("getValidTimePeriod()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async governanceDataSource(overrides) {
+        try {
+            return await this.contract.getFunction("governanceDataSource()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async governanceDataSourceIndex(overrides) {
+        try {
+            return await this.contract.getFunction("governanceDataSourceIndex()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async hashDataSource(ds, overrides) {
+        try {
+            return await this.contract.getFunction("hashDataSource((uint16,bytes32))")(ds, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async isValidDataSource(dataSourceChainId, dataSourceEmitterAddress, overrides) {
+        try {
+            return await this.contract.getFunction("isValidDataSource(uint16,bytes32)")(dataSourceChainId, dataSourceEmitterAddress, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async isValidGovernanceDataSource(governanceChainId, governanceEmitterAddress, overrides) {
+        try {
+            return await this.contract.getFunction("isValidGovernanceDataSource(uint16,bytes32)")(governanceChainId, governanceEmitterAddress, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async lastExecutedGovernanceSequence(overrides) {
+        try {
+            return await this.contract.getFunction("lastExecutedGovernanceSequence()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async latestPriceInfoPublishTime(priceId, overrides) {
+        try {
+            return await this.contract.getFunction("latestPriceInfoPublishTime(bytes32)")(priceId, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async owner(overrides) {
+        try {
+            return await this.contract.getFunction("owner()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async parseAuthorizeGovernanceDataSourceTransferPayload(encodedPayload, overrides) {
+        try {
+            return await this.contract.getFunction("parseAuthorizeGovernanceDataSourceTransferPayload(bytes)")(encodedPayload, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async parseGovernanceInstruction(encodedInstruction, overrides) {
+        try {
+            return await this.contract.getFunction("parseGovernanceInstruction(bytes)")(encodedInstruction, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async parseRequestGovernanceDataSourceTransferPayload(encodedPayload, overrides) {
+        try {
+            return await this.contract.getFunction("parseRequestGovernanceDataSourceTransferPayload(bytes)")(encodedPayload, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async parseSetDataSourcesPayload(encodedPayload, overrides) {
+        try {
+            return await this.contract.getFunction("parseSetDataSourcesPayload(bytes)")(encodedPayload, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async parseSetFeePayload(encodedPayload, overrides) {
+        try {
+            return await this.contract.getFunction("parseSetFeePayload(bytes)")(encodedPayload, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async parseSetValidPeriodPayload(encodedPayload, overrides) {
+        try {
+            return await this.contract.getFunction("parseSetValidPeriodPayload(bytes)")(encodedPayload, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async parseUpgradeContractPayload(encodedPayload, overrides) {
+        try {
+            return await this.contract.getFunction("parseUpgradeContractPayload(bytes)")(encodedPayload, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async priceFeedExists(id, overrides) {
+        try {
+            return await this.contract.getFunction("priceFeedExists(bytes32)")(id, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async proxiableUUID(overrides) {
+        try {
+            return await this.contract.getFunction("proxiableUUID()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async pythUpgradableMagic(overrides) {
+        try {
+            return await this.contract.getFunction("pythUpgradableMagic()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async queryPriceFeed(id, overrides) {
+        try {
+            return await this.contract.getFunction("queryPriceFeed(bytes32)")(id, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async singleUpdateFeeInWei(overrides) {
+        try {
+            return await this.contract.getFunction("singleUpdateFeeInWei()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async validDataSources(overrides) {
+        try {
+            return await this.contract.getFunction("validDataSources()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async validTimePeriodSeconds(overrides) {
+        try {
+            return await this.contract.getFunction("validTimePeriodSeconds()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async version(overrides) {
+        try {
+            return await this.contract.getFunction("version()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async wormhole(overrides) {
+        try {
+            return await this.contract.getFunction("wormhole()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+}
+export class PythBoundContractView extends BoundContractView {
+    async chainId(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.chainId(overrides || {});
+    }
+    async getEmaPrice(id, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getEmaPrice(id, overrides || {});
+    }
+    async getEmaPriceNoOlderThan(id, age, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getEmaPriceNoOlderThan(id, age, overrides || {});
+    }
+    async getEmaPriceUnsafe(id, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getEmaPriceUnsafe(id, overrides || {});
+    }
+    async getPrice(id, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getPrice(id, overrides || {});
+    }
+    async getPriceNoOlderThan(id, age, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getPriceNoOlderThan(id, age, overrides || {});
+    }
+    async getPriceUnsafe(id, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getPriceUnsafe(id, overrides || {});
+    }
+    async getUpdateFee_bytes_array(updateData, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getUpdateFee_bytes_array(updateData, overrides || {});
+    }
+    async getUpdateFee_uint256(updateDataSize, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getUpdateFee_uint256(updateDataSize, overrides || {});
+    }
+    async getValidTimePeriod(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getValidTimePeriod(overrides || {});
+    }
+    async governanceDataSource(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.governanceDataSource(overrides || {});
+    }
+    async governanceDataSourceIndex(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.governanceDataSourceIndex(overrides || {});
+    }
+    async hashDataSource(ds, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.hashDataSource(ds, overrides || {});
+    }
+    async isValidDataSource(dataSourceChainId, dataSourceEmitterAddress, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.isValidDataSource(dataSourceChainId, dataSourceEmitterAddress, overrides || {});
+    }
+    async isValidGovernanceDataSource(governanceChainId, governanceEmitterAddress, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.isValidGovernanceDataSource(governanceChainId, governanceEmitterAddress, overrides || {});
+    }
+    async lastExecutedGovernanceSequence(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.lastExecutedGovernanceSequence(overrides || {});
+    }
+    async latestPriceInfoPublishTime(priceId, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.latestPriceInfoPublishTime(priceId, overrides || {});
+    }
+    async owner(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.owner(overrides || {});
+    }
+    async parseAuthorizeGovernanceDataSourceTransferPayload(encodedPayload, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.parseAuthorizeGovernanceDataSourceTransferPayload(encodedPayload, overrides || {});
+    }
+    async parseGovernanceInstruction(encodedInstruction, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.parseGovernanceInstruction(encodedInstruction, overrides || {});
+    }
+    async parseRequestGovernanceDataSourceTransferPayload(encodedPayload, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.parseRequestGovernanceDataSourceTransferPayload(encodedPayload, overrides || {});
+    }
+    async parseSetDataSourcesPayload(encodedPayload, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.parseSetDataSourcesPayload(encodedPayload, overrides || {});
+    }
+    async parseSetFeePayload(encodedPayload, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.parseSetFeePayload(encodedPayload, overrides || {});
+    }
+    async parseSetValidPeriodPayload(encodedPayload, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.parseSetValidPeriodPayload(encodedPayload, overrides || {});
+    }
+    async parseUpgradeContractPayload(encodedPayload, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.parseUpgradeContractPayload(encodedPayload, overrides || {});
+    }
+    async priceFeedExists(id, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.priceFeedExists(id, overrides || {});
+    }
+    async proxiableUUID(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.proxiableUUID(overrides || {});
+    }
+    async pythUpgradableMagic(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.pythUpgradableMagic(overrides || {});
+    }
+    async queryPriceFeed(id, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.queryPriceFeed(id, overrides || {});
+    }
+    async singleUpdateFeeInWei(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.singleUpdateFeeInWei(overrides || {});
+    }
+    async validDataSources(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.validDataSources(overrides || {});
+    }
+    async validTimePeriodSeconds(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.validTimePeriodSeconds(overrides || {});
+    }
+    async version(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.version(overrides || {});
+    }
+    async wormhole(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.wormhole(overrides || {});
+    }
+}
+export class PythProcessor extends BaseProcessor {
+    onEventAdminChanged(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["AdminChanged(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventBatchPriceFeedUpdate(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["BatchPriceFeedUpdate(uint16,uint64)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventBeaconUpgraded(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["BeaconUpgraded(address)"](null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventContractUpgraded(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["ContractUpgraded(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventDataSourcesSet(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["DataSourcesSet((uint16,bytes32)[],(uint16,bytes32)[])"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventFeeSet(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["FeeSet(uint256,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventGovernanceDataSourceSet(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["GovernanceDataSourceSet((uint16,bytes32),(uint16,bytes32),uint64)"](null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventOwnershipTransferred(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["OwnershipTransferred(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventPriceFeedUpdate(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["PriceFeedUpdate(bytes32,uint64,int64,uint64)"](null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventUpgraded(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["Upgraded(address)"](null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventValidPeriodSet(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["ValidPeriodSet(uint256,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onCallChainId(handler, fetchConfig) {
+        return super.onTrace("0x9a8a0592", handler, fetchConfig);
+    }
+    onCallExecuteGovernanceInstruction(handler, fetchConfig) {
+        return super.onTrace("0xb6ed701e", handler, fetchConfig);
+    }
+    onCallGetEmaPrice(handler, fetchConfig) {
+        return super.onTrace("0xb5dcc911", handler, fetchConfig);
+    }
+    onCallGetEmaPriceNoOlderThan(handler, fetchConfig) {
+        return super.onTrace("0x711a2e28", handler, fetchConfig);
+    }
+    onCallGetEmaPriceUnsafe(handler, fetchConfig) {
+        return super.onTrace("0x9474f45b", handler, fetchConfig);
+    }
+    onCallGetPrice(handler, fetchConfig) {
+        return super.onTrace("0x31d98b3f", handler, fetchConfig);
+    }
+    onCallGetPriceNoOlderThan(handler, fetchConfig) {
+        return super.onTrace("0xa4ae35e0", handler, fetchConfig);
+    }
+    onCallGetPriceUnsafe(handler, fetchConfig) {
+        return super.onTrace("0x96834ad3", handler, fetchConfig);
+    }
+    onCallGetUpdateFee_bytes_array(handler, fetchConfig) {
+        return super.onTrace("0xd47eed45", handler, fetchConfig);
+    }
+    onCallGetUpdateFee_uint256(handler, fetchConfig) {
+        return super.onTrace("0xe17efd48", handler, fetchConfig);
+    }
+    onCallGetValidTimePeriod(handler, fetchConfig) {
+        return super.onTrace("0xe18910a3", handler, fetchConfig);
+    }
+    onCallGovernanceDataSource(handler, fetchConfig) {
+        return super.onTrace("0x426234e4", handler, fetchConfig);
+    }
+    onCallGovernanceDataSourceIndex(handler, fetchConfig) {
+        return super.onTrace("0x6c72f51b", handler, fetchConfig);
+    }
+    onCallHashDataSource(handler, fetchConfig) {
+        return super.onTrace("0x89a5bb4d", handler, fetchConfig);
+    }
+    onCallInitialize(handler, fetchConfig) {
+        return super.onTrace("0x146faf77", handler, fetchConfig);
+    }
+    onCallIsValidDataSource(handler, fetchConfig) {
+        return super.onTrace("0x437209a7", handler, fetchConfig);
+    }
+    onCallIsValidGovernanceDataSource(handler, fetchConfig) {
+        return super.onTrace("0x58c67635", handler, fetchConfig);
+    }
+    onCallLastExecutedGovernanceSequence(handler, fetchConfig) {
+        return super.onTrace("0x586d3cf8", handler, fetchConfig);
+    }
+    onCallLatestPriceInfoPublishTime(handler, fetchConfig) {
+        return super.onTrace("0x4c469d8c", handler, fetchConfig);
+    }
+    onCallOwner(handler, fetchConfig) {
+        return super.onTrace("0x8da5cb5b", handler, fetchConfig);
+    }
+    onCallParseAuthorizeGovernanceDataSourceTransferPayload(handler, fetchConfig) {
+        return super.onTrace("0xd82d58a5", handler, fetchConfig);
+    }
+    onCallParseGovernanceInstruction(handler, fetchConfig) {
+        return super.onTrace("0x6b7f53ca", handler, fetchConfig);
+    }
+    onCallParsePriceFeedUpdates(handler, fetchConfig) {
+        return super.onTrace("0x4716e9c5", handler, fetchConfig);
+    }
+    onCallParseRequestGovernanceDataSourceTransferPayload(handler, fetchConfig) {
+        return super.onTrace("0x7b72bcae", handler, fetchConfig);
+    }
+    onCallParseSetDataSourcesPayload(handler, fetchConfig) {
+        return super.onTrace("0x87c5bd1b", handler, fetchConfig);
+    }
+    onCallParseSetFeePayload(handler, fetchConfig) {
+        return super.onTrace("0x4d7a734e", handler, fetchConfig);
+    }
+    onCallParseSetValidPeriodPayload(handler, fetchConfig) {
+        return super.onTrace("0x14dd317f", handler, fetchConfig);
+    }
+    onCallParseUpgradeContractPayload(handler, fetchConfig) {
+        return super.onTrace("0x8881016f", handler, fetchConfig);
+    }
+    onCallPriceFeedExists(handler, fetchConfig) {
+        return super.onTrace("0xb5ec0261", handler, fetchConfig);
+    }
+    onCallProxiableUUID(handler, fetchConfig) {
+        return super.onTrace("0x52d1902d", handler, fetchConfig);
+    }
+    onCallPythUpgradableMagic(handler, fetchConfig) {
+        return super.onTrace("0xe3795cc1", handler, fetchConfig);
+    }
+    onCallQueryPriceFeed(handler, fetchConfig) {
+        return super.onTrace("0xcaaf43f1", handler, fetchConfig);
+    }
+    onCallRenounceOwnership(handler, fetchConfig) {
+        return super.onTrace("0x715018a6", handler, fetchConfig);
+    }
+    onCallSingleUpdateFeeInWei(handler, fetchConfig) {
+        return super.onTrace("0x48b6404d", handler, fetchConfig);
+    }
+    onCallTransferOwnership(handler, fetchConfig) {
+        return super.onTrace("0xf2fde38b", handler, fetchConfig);
+    }
+    onCallUpdatePriceFeeds(handler, fetchConfig) {
+        return super.onTrace("0xef9e5e28", handler, fetchConfig);
+    }
+    onCallUpdatePriceFeedsIfNecessary(handler, fetchConfig) {
+        return super.onTrace("0xb9256d28", handler, fetchConfig);
+    }
+    onCallUpgradeTo(handler, fetchConfig) {
+        return super.onTrace("0x3659cfe6", handler, fetchConfig);
+    }
+    onCallUpgradeToAndCall(handler, fetchConfig) {
+        return super.onTrace("0x4f1ef286", handler, fetchConfig);
+    }
+    onCallValidDataSources(handler, fetchConfig) {
+        return super.onTrace("0xa38d81c6", handler, fetchConfig);
+    }
+    onCallValidTimePeriodSeconds(handler, fetchConfig) {
+        return super.onTrace("0xcb718a9b", handler, fetchConfig);
+    }
+    onCallVersion(handler, fetchConfig) {
+        return super.onTrace("0x54fd4d50", handler, fetchConfig);
+    }
+    onCallWormhole(handler, fetchConfig) {
+        return super.onTrace("0x84acd1bb", handler, fetchConfig);
+    }
+    static filters = {
+        AdminChanged(previousAdmin, newAdmin) {
+            return templateContract.filters["AdminChanged(address,address)"](previousAdmin, newAdmin);
+        },
+        BatchPriceFeedUpdate(chainId, sequenceNumber) {
+            return templateContract.filters["BatchPriceFeedUpdate(uint16,uint64)"](chainId, sequenceNumber);
+        },
+        BeaconUpgraded(beacon) {
+            return templateContract.filters["BeaconUpgraded(address)"](beacon);
+        },
+        ContractUpgraded(oldImplementation, newImplementation) {
+            return templateContract.filters["ContractUpgraded(address,address)"](oldImplementation, newImplementation);
+        },
+        DataSourcesSet(oldDataSources, newDataSources) {
+            return templateContract.filters["DataSourcesSet((uint16,bytes32)[],(uint16,bytes32)[])"](oldDataSources, newDataSources);
+        },
+        FeeSet(oldFee, newFee) {
+            return templateContract.filters["FeeSet(uint256,uint256)"](oldFee, newFee);
+        },
+        GovernanceDataSourceSet(oldDataSource, newDataSource, initialSequence) {
+            return templateContract.filters["GovernanceDataSourceSet((uint16,bytes32),(uint16,bytes32),uint64)"](oldDataSource, newDataSource, initialSequence);
+        },
+        OwnershipTransferred(previousOwner, newOwner) {
+            return templateContract.filters["OwnershipTransferred(address,address)"](previousOwner, newOwner);
+        },
+        PriceFeedUpdate(id, publishTime, price, conf) {
+            return templateContract.filters["PriceFeedUpdate(bytes32,uint64,int64,uint64)"](id, publishTime, price, conf);
+        },
+        Upgraded(implementation) {
+            return templateContract.filters["Upgraded(address)"](implementation);
+        },
+        ValidPeriodSet(oldValidPeriod, newValidPeriod) {
+            return templateContract.filters["ValidPeriodSet(uint256,uint256)"](oldValidPeriod, newValidPeriod);
+        },
+    };
+    CreateBoundContractView() {
+        const view = getPythContract(this.config.address, this.config.network);
+        return new PythBoundContractView(this.config.address, view);
+    }
+    static bind(options) {
+        if (!options.name) {
+            options.name = "Pyth";
+        }
+        let processor = getProcessor(options);
+        if (!processor) {
+            processor = new PythProcessor(options);
+            addProcessor(options, processor);
+        }
+        return processor;
+    }
+}
+export class PythProcessorTemplate extends BaseProcessorTemplate {
+    bindInternal(options) {
+        if (!options.name) {
+            options.name = "Pyth";
+        }
+        let processor = getProcessor(options);
+        if (!processor) {
+            processor = new PythProcessor(options);
+            addProcessor(options, processor);
+        }
+        return processor;
+    }
+    onEventAdminChanged(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["AdminChanged(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventBatchPriceFeedUpdate(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["BatchPriceFeedUpdate(uint16,uint64)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventBeaconUpgraded(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["BeaconUpgraded(address)"](null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventContractUpgraded(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["ContractUpgraded(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventDataSourcesSet(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["DataSourcesSet((uint16,bytes32)[],(uint16,bytes32)[])"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventFeeSet(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["FeeSet(uint256,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventGovernanceDataSourceSet(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["GovernanceDataSourceSet((uint16,bytes32),(uint16,bytes32),uint64)"](null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventOwnershipTransferred(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["OwnershipTransferred(address,address)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventPriceFeedUpdate(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["PriceFeedUpdate(bytes32,uint64,int64,uint64)"](null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventUpgraded(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["Upgraded(address)"](null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventValidPeriodSet(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["ValidPeriodSet(uint256,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+}
+export function getPythContract(address, network = 1) {
+    let contract = getContractByABI("Pyth", address, network);
+    if (!contract) {
+        const rawContract = Pyth__factory.connect(address, getProvider(network));
+        contract = new PythContractView(rawContract);
+        addContractByABI("Pyth", address, network, contract);
+    }
+    return contract;
+}
+//# sourceMappingURL=pyth-processor.js.map