opnet 1.2.26 → 1.3.0

package/browser/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.2.26";
+export declare const version = "1.3.0";

package/browser/abi/shared/interfaces/motoswap/IMotoChefContract.d.ts

@@ -1,5 +1,5 @@
 import { Address } from '@btc-vision/transaction';
-import { CallResult } from '../../../../opnet.js';
+import { CallResult, OPNetEvent } from '../../../../opnet.js';
 import { IOwnableReentrancyGuardContract } from './IOwnableReentrancyGuardContract.js';
 export type PoolInfo = {
     allocPoint: number;
@@ -12,14 +12,23 @@ export type UserInfo = {
 };
 export type Initialize = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<LogPoolAdditionEvent>,
+    OPNetEvent<LogInitEvent>
+]>;
 export type GetLpToken = CallResult<{
     lpTokenAddress: Address;
 }>;
+export type GetLpTokens = CallResult<{
+    lpTokens: Address[];
+}>;
 export type GetRewarder = CallResult<{
     rewarderAddress: Address;
 }>;
 export type GetPoolInfo = CallResult<PoolInfo>;
+export type GetPoolsLength = CallResult<{
+    poolLength: bigint;
+}>;
 export type GetUserInfo = CallResult<UserInfo>;
 export type Pools = CallResult<{
     poolLength: number;
@@ -40,12 +49,28 @@ export type BonusEndBlock = CallResult<{
 export type BonusMultiplier = CallResult<{
     bonusMultiplier: bigint;
 }>;
+export type TotalBtcStaked = CallResult<{
+    totalBtcStaked: bigint;
+}>;
+export type TreasuryAddress = CallResult<{
+    TreasuryAddress: string;
+}>;
+export type GetStakingTxId = CallResult<{
+    stakingTxId: bigint;
+}>;
+export type GetStakingIndex = CallResult<{
+    stakingIndex: bigint;
+}>;
 export type Add = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<LogPoolAdditionEvent>
+]>;
 export type Set = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<LogSetPoolEvent>
+]>;
 export type SetMigrator = CallResult<{
     success: boolean;
 }>;
@@ -61,19 +86,28 @@ export type PendingMoto = CallResult<{
 export type MassUpdatePools = CallResult<{
     success: boolean;
 }>;
-export type UpdatePool = CallResult<PoolInfo>;
+export type UpdatePool = CallResult<PoolInfo, [OPNetEvent<LogUpdatePoolEvent>]>;
 export type Deposit = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<DepositEvent>
+]>;
 export type Withdraw = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<WithdrawEvent>
+]>;
 export type Harvest = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<HarvestEvent>
+]>;
 export type WithdrawAndHarvest = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<WithdrawEvent>,
+    OPNetEvent<HarvestEvent>
+]>;
 export type SetDev = CallResult<{
     success: boolean;
 }>;
@@ -88,75 +122,108 @@ export type SetBonusMultiplier = CallResult<{
 }>;
 export type EmergencyWithdraw = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<EmergencyWithdrawEvent>
+]>;
+export type StakeBtc = CallResult<{
+    success: boolean;
+}, [
+    OPNetEvent<StakeBTCEvent>
+]>;
+export type UnstakeBtc = CallResult<{
+    success: boolean;
+}, [
+    OPNetEvent<UnstakeBTCEvent>
+]>;
+export type LogInitEvent = {
+    success: boolean;
+};
 export type LogPoolAdditionEvent = {
-    readonly pid: number;
+    readonly pid: bigint;
     readonly allocPoint: bigint;
     readonly lpToken: Address;
     readonly rewarder: Address;
 };
 export type LogSetPoolEvent = {
-    readonly pid: number;
+    readonly pid: bigint;
     readonly allocPoint: bigint;
     readonly rewarder: Address;
     readonly overwrite: boolean;
 };
 export type LogUpdatePoolEvent = {
-    readonly pid: number;
+    readonly pid: bigint;
     readonly lastRewardBlock: bigint;
     readonly lpSupply: bigint;
     readonly accMotoPerShare: bigint;
 };
 export type DepositEvent = {
     readonly user: Address;
-    readonly pid: number;
+    readonly pid: bigint;
     readonly amount: bigint;
     readonly to: Address;
 };
 export type WithdrawEvent = {
     readonly user: Address;
-    readonly pid: number;
+    readonly pid: bigint;
     readonly amount: bigint;
     readonly to: Address;
 };
 export type HarvestEvent = {
     readonly user: Address;
-    readonly pid: number;
+    readonly pid: bigint;
     readonly amount: bigint;
 };
 export type EmergencyWithdrawEvent = {
     readonly user: Address;
-    readonly pid: number;
+    readonly pid: bigint;
     readonly amount: bigint;
     readonly to: Address;
 };
+export type StakeBTCEvent = {
+    readonly user: Address;
+    readonly amount: bigint;
+    readonly stakingTxId: bigint;
+    readonly stakingIndex: bigint;
+};
+export type UnstakeBTCEvent = {
+    readonly user: Address;
+    readonly amount: bigint;
+    readonly stakingTxId: bigint;
+    readonly stakingIndex: bigint;
+};
 export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
-    initialize(MOTO: Address, premineAmount: bigint, devaddr: Address, motoPerBlock: bigint, bonusEndBlock: bigint, bonusMultiplier: bigint): Promise<Initialize>;
-    getLpToken(pid: number): Promise<GetLpToken>;
-    getRewarder(pid: number): Promise<GetRewarder>;
-    getPoolInfo(pid: number): Promise<GetPoolInfo>;
-    getUserInfo(pid: number, user: Address): Promise<GetUserInfo>;
-    pools(): Promise<Pools>;
+    initialize(MOTO: Address, premineAmount: bigint, devaddr: Address, motoPerBlock: bigint, bonusEndBlock: bigint, bonusMultiplier: bigint, treasuryAddress: string, btcAllocPoint: bigint): Promise<Initialize>;
+    getLpToken(pid: bigint): Promise<GetLpToken>;
+    getLpTokens(): Promise<GetLpTokens>;
+    getPoolInfo(pid: bigint): Promise<GetPoolInfo>;
+    getPoolsLength(): Promise<GetPoolsLength>;
+    getUserInfo(pid: bigint, user: Address): Promise<GetUserInfo>;
     totalAllocPoint(): Promise<TotalAllocPoint>;
     devaddr(): Promise<Devaddr>;
     getMotoPerBlock(): Promise<MotoPerBlock>;
     getBonusEndBlock(): Promise<BonusEndBlock>;
     getBonusMultiplier(): Promise<BonusMultiplier>;
+    totalBtcStaked(): Promise<TotalBtcStaked>;
+    treasuryAddress(): Promise<TreasuryAddress>;
+    getStakingTxId(): Promise<GetStakingTxId>;
+    getStakingIndex(): Promise<GetStakingIndex>;
     setMotoPerBlock(motoPerBlock: bigint): Promise<SetMotoPerBlock>;
     setBonusEndBlock(bonusEndBlock: bigint): Promise<SetBonusEndBlock>;
     setBonusMultiplier(bonusMultiplier: bigint): Promise<SetBonusMultiplier>;
-    add(allocPoint: bigint, lpToken: Address, rewarder: Address): Promise<Add>;
-    set(pid: number, allocPoint: bigint, rewarder: Address, overwrite: boolean): Promise<Set>;
+    add(allocPoint: bigint, lpToken: Address): Promise<Add>;
+    set(pid: bigint, allocPoint: bigint): Promise<Set>;
     setMigrator(migrator: Address): Promise<SetMigrator>;
-    migrate(pid: number): Promise<Migrate>;
+    migrate(pid: bigint): Promise<Migrate>;
     getMultiplier(from: bigint, to: bigint): Promise<GetMultiplier>;
-    pendingMoto(pid: number, user: Address): Promise<PendingMoto>;
-    massUpdatePools(length: number, pids: number[]): Promise<MassUpdatePools>;
-    updatePool(pid: number): Promise<UpdatePool>;
-    deposit(pid: number, amount: bigint, to: Address): Promise<Deposit>;
-    withdraw(pid: number, amount: bigint, to: Address): Promise<Withdraw>;
-    harvest(pid: number, to: Address): Promise<Harvest>;
-    withdrawAndHarvest(pid: number, amount: bigint, to: Address): Promise<WithdrawAndHarvest>;
-    emergencyWithdraw(pid: number, to: Address): Promise<EmergencyWithdraw>;
+    pendingMoto(pid: bigint, user: Address): Promise<PendingMoto>;
+    massUpdatePools(length: number, pids: bigint[]): Promise<MassUpdatePools>;
+    updatePool(pid: bigint): Promise<UpdatePool>;
+    deposit(pid: bigint, amount: bigint, to: Address): Promise<Deposit>;
+    withdraw(pid: bigint, amount: bigint, to: Address): Promise<Withdraw>;
+    harvest(pid: bigint, to: Address): Promise<Harvest>;
+    withdrawAndHarvest(pid: bigint, amount: bigint, to: Address): Promise<WithdrawAndHarvest>;
+    emergencyWithdraw(pid: bigint, to: Address): Promise<EmergencyWithdraw>;
     setDev(devaddr: Address): Promise<SetDev>;
+    stakeBtc(stakeAmount: bigint): Promise<StakeBtc>;
+    unstakeBtc(): Promise<UnstakeBtc>;
 }

package/browser/abi/shared/interfaces/motoswap/IMotoswapFactoryContract.d.ts

@@ -15,4 +15,10 @@ export interface IMotoswapFactoryContract extends IOP_NETContract {
         pool: bigint;
         address: Address;
     }, [OPNetEvent<PoolCreatedEvent>]>>;
+    setStakingContractAddress(stakingContractAddress: Address): Promise<CallResult<{
+        success: boolean;
+    }>>;
+    getStakingContractAddress(): Promise<CallResult<{
+        stakingContractAddress: Address;
+    }>>;
 }

package/browser/abi/shared/interfaces/motoswap/IMotoswapPoolContract.d.ts

@@ -48,7 +48,10 @@ export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mi
     kLast(): Promise<CallResult<{
         kLast: bigint;
     }>>;
-    burn(to: Address): Promise<CallResult>;
+    burn(to: Address): Promise<CallResult<{
+        amount0: bigint;
+        amount1: bigint;
+    }, [OPNetEvent<PoolBurnEvent>]>>;
     blockTimestampLast(): Promise<CallResult<{
         blockTimestampLast: bigint;
     }>>;
@@ -61,4 +64,13 @@ export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mi
     price1CumulativeLast(): Promise<CallResult<{
         price1CumulativeLast: bigint;
     }>>;
+    MINIMUM_LIQUIDITY(): Promise<CallResult<{
+        MINIMUM_LIQUIDITY: bigint;
+    }>>;
+    mint(to: Address): Promise<CallResult<{
+        liquidity: bigint;
+    }, [OPNetEvent<PoolMintEvent>]>>;
+    initialize(token0: Address, token1: Address): Promise<CallResult<{
+        success: boolean;
+    }>>;
 }

package/browser/abi/shared/interfaces/motoswap/IMotoswapStakingContract.d.ts

@@ -10,6 +10,9 @@ export type BalanceOf = CallResult<{
 export type TotalSupply = CallResult<{
     totalSupply: bigint;
 }>;
+export type MotoAddress = CallResult<{
+    totalSupply: bigint;
+}>;
 export type LastInteractedBlock = CallResult<{
     lastInteractedBlock: bigint;
 }>;
@@ -56,9 +59,9 @@ export type RewardTokenRemovedEvent = {
     readonly token: Address;
 };
 export interface IMotoswapStakingContract extends IOwnableReentrancyGuardContract {
-    getMotoAddress(): Promise<GetMotoAddress>;
     balanceOf(address: Address): Promise<BalanceOf>;
     totalSupply(): Promise<TotalSupply>;
+    motoAddress(): Promise<MotoAddress>;
     lastInteractedBlock(address: Address): Promise<LastInteractedBlock>;
     rewardDebt(user: Address, rewardToken: Address): Promise<RewardDebt>;
     rewardBalances(user: Address): Promise<RewardBalances>;

package/browser/abi/shared/interfaces/motoswap/INativeSwapContract.d.ts

@@ -60,7 +60,6 @@ export type SetFees = CallResult<{
 export type GetFees = CallResult<{
     reservationBaseFee: bigint;
     priorityQueueBaseFee: bigint;
-    pricePerUserInPriorityQueueBTC: bigint;
 }, [
 ]>;
 export type Swap = CallResult<{
@@ -91,15 +90,15 @@ export type GetPriorityQueueCost = CallResult<{
 }, [
 ]>;
 export interface INativeSwapContract extends IOP_NETContract {
-    reserve(token: Address, maximumAmountIn: bigint, minimumAmountOut: bigint, forLP: boolean): Promise<ReserveNativeSwap>;
+    reserve(token: Address, maximumAmountIn: bigint, minimumAmountOut: bigint, forLP: boolean, activationDelay: number): Promise<ReserveNativeSwap>;
     listLiquidity(token: Address, receiver: string, amountIn: bigint, priority: boolean): Promise<ListLiquidity>;
     cancelListing(token: Address): Promise<CancelListing>;
     createPool(token: Address, floorPrice: bigint, initialLiquidity: bigint, receiver: string, antiBotEnabledFor: number, antiBotMaximumTokensPerReservation: bigint, maxReservesIn5BlocksPercent: number): Promise<CreatePool>;
     createPoolWithSignature(signature: Buffer, approveAmount: bigint, nonce: bigint, token: Address, floorPrice: bigint, initialLiquidity: bigint, receiver: string, antiBotEnabledFor: number, antiBotMaximumTokensPerReservation: bigint, maxReservesIn5BlocksPercent: number): Promise<CreatePool>;
-    setFees(reservationBaseFee: bigint, priorityQueueBaseFee: bigint, pricePerUserInPriorityQueueBTC: bigint): Promise<SetFees>;
+    setFees(reservationBaseFee: bigint, priorityQueueBaseFee: bigint): Promise<SetFees>;
     getFees(): Promise<GetFees>;
     addLiquidity(token: Address, receiver: string): Promise<AddLiquidity>;
-    removeLiquidity(token: Address, amount: bigint): Promise<RemoveLiquidity>;
+    removeLiquidity(token: Address): Promise<RemoveLiquidity>;
     swap(token: Address): Promise<Swap>;
     getReserve(token: Address): Promise<GetReserve>;
     getQuote(token: Address, satoshisIn: bigint): Promise<GetQuote>;

package/browser/abi/shared/interfaces/opnet/IOP_20Contract.d.ts

@@ -77,6 +77,6 @@ export interface IOP_20Contract extends IOP_NETContract {
     allowance(owner: Address, spender: Address): Promise<Allowance>;
     burn(value: bigint): Promise<Burn>;
     mint(address: Address, value: bigint): Promise<Mint>;
-    airdrop(tuple: AddressMap<bigint>): Promise<Airdrop>;
+    airdrop(map: AddressMap<bigint>): Promise<Airdrop>;
     airdropWithAmount(amount: bigint, addresses: Address[]): Promise<AirdropWithAmount>;
 }