@sentio/sdk 2.3.6-rc.1 → 2.4.0

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

@@ -0,0 +1,596 @@
+import { addContractByABI, getContractByABI, addProcessor, getProcessor, getProvider, transformEtherError, BaseProcessor, BaseProcessorTemplate, BoundContractView, ContractView, DummyProvider, toBlockTag, } from "@sentio/sdk/eth";
+import { MembershipStakerV3__factory } from "./index.js";
+const templateContract = MembershipStakerV3__factory.connect("0x0", DummyProvider);
+export class MembershipStakerV3ContractView extends ContractView {
+    constructor(contract) {
+        super(contract);
+    }
+    async amountRyoshiStaked(_address, overrides) {
+        try {
+            return await this.contract.getFunction("amountRyoshiStaked(address)")(_address, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async amountStaked(staker, overrides) {
+        try {
+            return await this.contract.getFunction("amountStaked(address)")(staker, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async completedPool(overrides) {
+        try {
+            return await this.contract.getFunction("completedPool()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async curPool(overrides) {
+        try {
+            return await this.contract.getFunction("curPool()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async currentPoolId(overrides) {
+        try {
+            return await this.contract.getFunction("currentPoolId()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async currentStaked(overrides) {
+        try {
+            return await this.contract.getFunction("currentStaked()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async epochLength(overrides) {
+        try {
+            return await this.contract.getFunction("epochLength()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getReleasedReward(_address, overrides) {
+        try {
+            return await this.contract.getFunction("getReleasedReward(address)")(_address, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async getReward(_address, overrides) {
+        try {
+            return await this.contract.getFunction("getReward(address)")(_address, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async name(overrides) {
+        try {
+            return await this.contract.getFunction("name()")(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 periodEnd(overrides) {
+        try {
+            return await this.contract.getFunction("periodEnd()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async poolBalance(overrides) {
+        try {
+            return await this.contract.getFunction("poolBalance()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async pools(arg0, overrides) {
+        try {
+            return await this.contract.getFunction("pools(uint256)")(arg0, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async rewardsId(overrides) {
+        try {
+            return await this.contract.getFunction("rewardsId()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async rewardsPaid(overrides) {
+        try {
+            return await this.contract.getFunction("rewardsPaid()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async stakedRyoshi(arg0, overrides) {
+        try {
+            return await this.contract.getFunction("stakedRyoshi(uint256)")(arg0, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async supportsInterface(interfaceId, overrides) {
+        try {
+            return await this.contract.getFunction("supportsInterface(bytes4)")(interfaceId, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async totalStaked(overrides) {
+        try {
+            return await this.contract.getFunction("totalStaked()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+}
+export class MembershipStakerV3BoundContractView extends BoundContractView {
+    async amountRyoshiStaked(_address, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.amountRyoshiStaked(_address, overrides || {});
+    }
+    async amountStaked(staker, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.amountStaked(staker, overrides || {});
+    }
+    async completedPool(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.completedPool(overrides || {});
+    }
+    async curPool(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.curPool(overrides || {});
+    }
+    async currentPoolId(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.currentPoolId(overrides || {});
+    }
+    async currentStaked(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.currentStaked(overrides || {});
+    }
+    async epochLength(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.epochLength(overrides || {});
+    }
+    async getReleasedReward(_address, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getReleasedReward(_address, overrides || {});
+    }
+    async getReward(_address, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.getReward(_address, overrides || {});
+    }
+    async name(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.name(overrides || {});
+    }
+    async owner(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.owner(overrides || {});
+    }
+    async periodEnd(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.periodEnd(overrides || {});
+    }
+    async poolBalance(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.poolBalance(overrides || {});
+    }
+    async pools(arg0, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.pools(arg0, overrides || {});
+    }
+    async rewardsId(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.rewardsId(overrides || {});
+    }
+    async rewardsPaid(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.rewardsPaid(overrides || {});
+    }
+    async stakedRyoshi(arg0, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.stakedRyoshi(arg0, overrides || {});
+    }
+    async supportsInterface(interfaceId, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.supportsInterface(interfaceId, overrides || {});
+    }
+    async totalStaked(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.totalStaked(overrides || {});
+    }
+}
+export class MembershipStakerV3Processor extends BaseProcessor {
+    onEventAdminChanged(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["AdminChanged(address,address)"](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);
+    }
+    onEventHarvest(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["Harvest(address,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventMembershipStaked(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["MembershipStaked(address,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventMembershipUnstaked(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["MembershipUnstaked(address,uint256)"](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);
+    }
+    onEventRyoshiStaked(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RyoshiStaked(address,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRyoshiUnstaked(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RyoshiUnstaked(address,uint256)"](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);
+    }
+    onCallAmountRyoshiStaked(handler, fetchConfig) {
+        return super.onTrace("0xe210d4db", handler, fetchConfig);
+    }
+    onCallAmountStaked(handler, fetchConfig) {
+        return super.onTrace("0xef40a670", handler, fetchConfig);
+    }
+    onCallCompletedPool(handler, fetchConfig) {
+        return super.onTrace("0x3702615e", handler, fetchConfig);
+    }
+    onCallCurPool(handler, fetchConfig) {
+        return super.onTrace("0xf4a9081d", handler, fetchConfig);
+    }
+    onCallCurrentPoolId(handler, fetchConfig) {
+        return super.onTrace("0xebc5163b", handler, fetchConfig);
+    }
+    onCallCurrentStaked(handler, fetchConfig) {
+        return super.onTrace("0x695464e9", handler, fetchConfig);
+    }
+    onCallEndInitPeriod(handler, fetchConfig) {
+        return super.onTrace("0x0e0f634e", handler, fetchConfig);
+    }
+    onCallEpochLength(handler, fetchConfig) {
+        return super.onTrace("0x57d775f8", handler, fetchConfig);
+    }
+    onCallGetReleasedReward(handler, fetchConfig) {
+        return super.onTrace("0xb8b81472", handler, fetchConfig);
+    }
+    onCallGetReward(handler, fetchConfig) {
+        return super.onTrace("0xc00007b0", handler, fetchConfig);
+    }
+    onCallHarvest(handler, fetchConfig) {
+        return super.onTrace("0x0e5c011e", handler, fetchConfig);
+    }
+    onCallInitialize(handler, fetchConfig) {
+        return super.onTrace("0xc4d66de8", handler, fetchConfig);
+    }
+    onCallName(handler, fetchConfig) {
+        return super.onTrace("0x06fdde03", handler, fetchConfig);
+    }
+    onCallOnERC1155BatchReceived(handler, fetchConfig) {
+        return super.onTrace("0xbc197c81", handler, fetchConfig);
+    }
+    onCallOnERC1155Received(handler, fetchConfig) {
+        return super.onTrace("0xf23a6e61", handler, fetchConfig);
+    }
+    onCallOwner(handler, fetchConfig) {
+        return super.onTrace("0x8da5cb5b", handler, fetchConfig);
+    }
+    onCallPeriodEnd(handler, fetchConfig) {
+        return super.onTrace("0x506ec095", handler, fetchConfig);
+    }
+    onCallPoolBalance(handler, fetchConfig) {
+        return super.onTrace("0x96365d44", handler, fetchConfig);
+    }
+    onCallPools(handler, fetchConfig) {
+        return super.onTrace("0xac4afa38", handler, fetchConfig);
+    }
+    onCallRenounceOwnership(handler, fetchConfig) {
+        return super.onTrace("0x715018a6", handler, fetchConfig);
+    }
+    onCallRewardsId(handler, fetchConfig) {
+        return super.onTrace("0xdfb19e5b", handler, fetchConfig);
+    }
+    onCallRewardsPaid(handler, fetchConfig) {
+        return super.onTrace("0x69d8d6d2", handler, fetchConfig);
+    }
+    onCallSetEpochLength(handler, fetchConfig) {
+        return super.onTrace("0x54eea796", handler, fetchConfig);
+    }
+    onCallSetRyoshiVIP(handler, fetchConfig) {
+        return super.onTrace("0x75d6417b", handler, fetchConfig);
+    }
+    onCallStake(handler, fetchConfig) {
+        return super.onTrace("0xa694fc3a", handler, fetchConfig);
+    }
+    onCallStakeRyoshi(handler, fetchConfig) {
+        return super.onTrace("0x28cef9ca", handler, fetchConfig);
+    }
+    onCallStakedRyoshi(handler, fetchConfig) {
+        return super.onTrace("0x5c23a49f", handler, fetchConfig);
+    }
+    onCallSupportsInterface(handler, fetchConfig) {
+        return super.onTrace("0x01ffc9a7", handler, fetchConfig);
+    }
+    onCallTotalStaked(handler, fetchConfig) {
+        return super.onTrace("0x817b1cd2", handler, fetchConfig);
+    }
+    onCallTransferOwnership(handler, fetchConfig) {
+        return super.onTrace("0xf2fde38b", handler, fetchConfig);
+    }
+    onCallUnstake(handler, fetchConfig) {
+        return super.onTrace("0x2e17de78", handler, fetchConfig);
+    }
+    onCallUnstakeRyoshi(handler, fetchConfig) {
+        return super.onTrace("0x41e316c3", handler, fetchConfig);
+    }
+    onCallUpdatePool(handler, fetchConfig) {
+        return super.onTrace("0xe3161ddd", handler, fetchConfig);
+    }
+    onCallUpgradeTo(handler, fetchConfig) {
+        return super.onTrace("0x3659cfe6", handler, fetchConfig);
+    }
+    onCallUpgradeToAndCall(handler, fetchConfig) {
+        return super.onTrace("0x4f1ef286", handler, fetchConfig);
+    }
+    static filters = {
+        AdminChanged(previousAdmin, newAdmin) {
+            return templateContract.filters["AdminChanged(address,address)"](previousAdmin, newAdmin);
+        },
+        BeaconUpgraded(beacon) {
+            return templateContract.filters["BeaconUpgraded(address)"](beacon);
+        },
+        Harvest(arg0, amount) {
+            return templateContract.filters["Harvest(address,uint256)"](arg0, amount);
+        },
+        MembershipStaked(staker, totalStaked) {
+            return templateContract.filters["MembershipStaked(address,uint256)"](staker, totalStaked);
+        },
+        MembershipUnstaked(staker, totalStaked) {
+            return templateContract.filters["MembershipUnstaked(address,uint256)"](staker, totalStaked);
+        },
+        OwnershipTransferred(previousOwner, newOwner) {
+            return templateContract.filters["OwnershipTransferred(address,address)"](previousOwner, newOwner);
+        },
+        RyoshiStaked(owner, tokenId) {
+            return templateContract.filters["RyoshiStaked(address,uint256)"](owner, tokenId);
+        },
+        RyoshiUnstaked(owner, tokenId) {
+            return templateContract.filters["RyoshiUnstaked(address,uint256)"](owner, tokenId);
+        },
+        Upgraded(implementation) {
+            return templateContract.filters["Upgraded(address)"](implementation);
+        },
+    };
+    CreateBoundContractView() {
+        const view = getMembershipStakerV3Contract(this.config.address, this.config.network);
+        return new MembershipStakerV3BoundContractView(this.config.address, view);
+    }
+    static bind(options) {
+        if (!options.name) {
+            options.name = "MembershipStakerV3";
+        }
+        let processor = getProcessor(options);
+        if (!processor) {
+            processor = new MembershipStakerV3Processor(options);
+            addProcessor(options, processor);
+        }
+        return processor;
+    }
+}
+export class MembershipStakerV3ProcessorTemplate extends BaseProcessorTemplate {
+    bindInternal(options) {
+        if (!options.name) {
+            options.name = "MembershipStakerV3";
+        }
+        let processor = getProcessor(options);
+        if (!processor) {
+            processor = new MembershipStakerV3Processor(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);
+    }
+    onEventBeaconUpgraded(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["BeaconUpgraded(address)"](null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventHarvest(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["Harvest(address,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventMembershipStaked(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["MembershipStaked(address,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventMembershipUnstaked(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["MembershipUnstaked(address,uint256)"](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);
+    }
+    onEventRyoshiStaked(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RyoshiStaked(address,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRyoshiUnstaked(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RyoshiUnstaked(address,uint256)"](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);
+    }
+}
+export function getMembershipStakerV3Contract(address, network = 1) {
+    let contract = getContractByABI("MembershipStakerV3", address, network);
+    if (!contract) {
+        const rawContract = MembershipStakerV3__factory.connect(address, getProvider(network));
+        contract = new MembershipStakerV3ContractView(rawContract);
+        addContractByABI("MembershipStakerV3", address, network, contract);
+    }
+    return contract;
+}
+//# sourceMappingURL=membershipstakerv3-processor.js.map