opnet/browser/abi/shared/interfaces/motoswap/IMotoChef.d.ts

The perfect library for building Bitcoin-based applications.

import { Address } from '../../../../../node_modules/@btc-vision/transaction/build/index.js';
import { CallResult } from '../../../../contracts/CallResult.js';
import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
import { IOP_NETContract } from '../opnet/IOP_NETContract.js';
export type OwnershipTransferredEvent = {
    readonly previousOwner: Address;
    readonly newOwner: Address;
};
export type Owner = CallResult<{
    owner: Address;
}, OPNetEvent<never>[]>;
export type RenounceOwnership = CallResult<{}, OPNetEvent<OwnershipTransferredEvent>[]>;
export type TransferOwnership = CallResult<{}, OPNetEvent<OwnershipTransferredEvent>[]>;
interface IOwnable extends IOP_NETContract {
    owner(): Promise<Owner>;
    renounceOwnership(): Promise<RenounceOwnership>;
    transferOwnership(newOwner: Address): Promise<TransferOwnership>;
}
export type PoolAddedEvent = {
    readonly poolId: number;
    readonly allocPoint: bigint;
    readonly lpToken: Address;
};
export type InitializedEvent = {};
export type PoolUpdatedEvent = {
    readonly poolId: number;
    readonly lastRewardBlock: bigint;
    readonly lpSupply: bigint;
    readonly accMotoPerShare: bigint;
};
export type BTCStakedEvent = {
    readonly user: Address;
    readonly netAmount: bigint;
    readonly stakeTxId: bigint;
    readonly stakeIndex: bigint;
};
export type BTCUnstakedEvent = {
    readonly user: Address;
    readonly pendingMoto: bigint;
    readonly storedTxId: bigint;
    readonly storedIndex: bigint;
};
export type BTCStakeRemovedEvent = {
    readonly user: Address;
    readonly storedTxId: bigint;
    readonly storedIndex: bigint;
};
export type PoolSetEvent = {
    readonly poolId: number;
    readonly allocPoint: bigint;
};
export type DepositedEvent = {
    readonly user: Address;
    readonly poolId: number;
    readonly amount: bigint;
    readonly to: Address;
};
export type WithdrawnEvent = {
    readonly user: Address;
    readonly poolId: number;
    readonly amount: bigint;
    readonly to: Address;
};
export type HarvestedEvent = {
    readonly user: Address;
    readonly poolId: number;
    readonly amount: bigint;
};
export type EmergencyWithdrawnEvent = {
    readonly user: Address;
    readonly poolId: number;
    readonly amount: bigint;
    readonly to: Address;
};
export type Update = CallResult<{}, OPNetEvent<never>[]>;
export type Initialize = CallResult<{}, OPNetEvent<PoolAddedEvent | InitializedEvent>[]>;
export type TotalAllocPoint = CallResult<{
    totalAllocPoint: bigint;
}, OPNetEvent<never>[]>;
export type GetMotoPerBlock = CallResult<{
    motoPerBlock: bigint;
}, OPNetEvent<never>[]>;
export type GetBonusEndBlock = CallResult<{
    bonusEndBlock: bigint;
}, OPNetEvent<never>[]>;
export type GetBonusMultiplier = CallResult<{
    bonusMultiplier: bigint;
}, OPNetEvent<never>[]>;
export type GetLpTokens = CallResult<{
    lpTokens: Address[];
}, OPNetEvent<never>[]>;
export type GetPoolsLength = CallResult<{
    poolsLength: number;
}, OPNetEvent<never>[]>;
export type GetLpToken = CallResult<{
    lpToken: Address;
}, OPNetEvent<never>[]>;
export type GetPoolInfo = CallResult<{
    accMotoPerShare: bigint;
    lastRewardBlock: bigint;
    allocPoint: bigint;
}, OPNetEvent<never>[]>;
export type GetUserInfo = CallResult<{
    amount: bigint;
    rewardDebt: bigint;
}, OPNetEvent<never>[]>;
export type GetMultiplier = CallResult<{
    multiplier: bigint;
}, OPNetEvent<never>[]>;
export type PendingMoto = CallResult<{
    pendingMoto: bigint;
}, OPNetEvent<never>[]>;
export type TreasuryAddress = CallResult<{
    treasuryAddress: string;
}, OPNetEvent<never>[]>;
export type GetStakingTxId = CallResult<{
    stakingTxId: bigint;
}, OPNetEvent<never>[]>;
export type GetStakingIndex = CallResult<{
    stakingIndex: bigint;
}, OPNetEvent<never>[]>;
export type TotalBTCStaked = CallResult<{
    totalBTCStaked: bigint;
}, OPNetEvent<never>[]>;
export type StakeBTC = CallResult<{}, OPNetEvent<PoolUpdatedEvent | BTCStakedEvent | BTCStakeRemovedEvent>[]>;
export type UnstakeBTC = CallResult<{}, OPNetEvent<PoolUpdatedEvent | BTCUnstakedEvent>[]>;
export type RemoveBTCStake = CallResult<{}, OPNetEvent<PoolUpdatedEvent | BTCStakeRemovedEvent>[]>;
export type Add = CallResult<{}, OPNetEvent<PoolAddedEvent>[]>;
export type Set = CallResult<{}, OPNetEvent<PoolSetEvent>[]>;
export type UpdatePool = CallResult<{
    accMotoPerShare: bigint;
    lastRewardBlock: bigint;
    allocPoint: bigint;
}, OPNetEvent<PoolUpdatedEvent>[]>;
export type MassUpdatePools = CallResult<{}, OPNetEvent<PoolUpdatedEvent>[]>;
export type Deposit = CallResult<{}, OPNetEvent<PoolUpdatedEvent | DepositedEvent>[]>;
export type Withdraw = CallResult<{}, OPNetEvent<PoolUpdatedEvent | WithdrawnEvent>[]>;
export type Harvest = CallResult<{}, OPNetEvent<PoolUpdatedEvent | HarvestedEvent>[]>;
export type WithdrawAndHarvest = CallResult<{}, OPNetEvent<PoolUpdatedEvent | WithdrawnEvent | HarvestedEvent>[]>;
export type EmergencyWithdraw = CallResult<{}, OPNetEvent<EmergencyWithdrawnEvent>[]>;
export type SetMotoPerBlock = CallResult<{}, OPNetEvent<never>[]>;
export type SetBonusEndBlock = CallResult<{}, OPNetEvent<never>[]>;
export type SetBonusMultiplier = CallResult<{}, OPNetEvent<never>[]>;
export type OnOP20Received = CallResult<{
    selector: Uint8Array;
}, OPNetEvent<never>[]>;
export interface IMotoChef extends IOwnable {
    update(sourceAddress: Address, updateCalldata: Uint8Array): Promise<Update>;
    initialize(motoAddress: Address, premineAmount: bigint, premineRecipient: Address, motoPerBlock: bigint, bonusEndBlock: bigint, bonusMultiplier: bigint, treasuryAddress: string, BTCAllocPoint: bigint, MOTOAllocPoint: bigint): Promise<Initialize>;
    totalAllocPoint(): Promise<TotalAllocPoint>;
    getMotoPerBlock(): Promise<GetMotoPerBlock>;
    getBonusEndBlock(): Promise<GetBonusEndBlock>;
    getBonusMultiplier(): Promise<GetBonusMultiplier>;
    getLpTokens(): Promise<GetLpTokens>;
    getPoolsLength(): Promise<GetPoolsLength>;
    getLpToken(poolId: number): Promise<GetLpToken>;
    getPoolInfo(poolId: number): Promise<GetPoolInfo>;
    getUserInfo(poolId: number, user: Address): Promise<GetUserInfo>;
    getMultiplier(from: bigint, to: bigint): Promise<GetMultiplier>;
    pendingMoto(poolId: number, user: Address): Promise<PendingMoto>;
    treasuryAddress(): Promise<TreasuryAddress>;
    getStakingTxId(user: Address): Promise<GetStakingTxId>;
    getStakingIndex(user: Address): Promise<GetStakingIndex>;
    totalBTCStaked(): Promise<TotalBTCStaked>;
    stakeBTC(amount: bigint): Promise<StakeBTC>;
    unstakeBTC(): Promise<UnstakeBTC>;
    removeBTCStake(user: Address): Promise<RemoveBTCStake>;
    add(allocPoint: bigint, lpToken: Address): Promise<Add>;
    set(poolId: number, allocPoint: bigint, withUpdate: number): Promise<Set>;
    updatePool(poolId: number): Promise<UpdatePool>;
    massUpdatePools(length: number, poolIds: number[]): Promise<MassUpdatePools>;
    deposit(poolId: number, amount: bigint, to: Address): Promise<Deposit>;
    withdraw(poolId: number, amount: bigint, to: Address): Promise<Withdraw>;
    harvest(poolId: number, to: Address): Promise<Harvest>;
    withdrawAndHarvest(poolId: number, amount: bigint, to: Address): Promise<WithdrawAndHarvest>;
    emergencyWithdraw(poolId: number, to: Address): Promise<EmergencyWithdraw>;
    onOP20Received(operator: Address, from: Address, amount: bigint, data: Uint8Array): Promise<OnOP20Received>;
    setMotoPerBlock(motoPerBlock: bigint): Promise<SetMotoPerBlock>;
    setBonusEndBlock(bonusEndBlock: bigint): Promise<SetBonusEndBlock>;
    setBonusMultiplier(bonusMultiplier: bigint): Promise<SetBonusMultiplier>;
}
export {};