opnet 1.3.2 → 1.3.3

package/browser/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.3.2";
+export declare const version = "1.3.3";

package/browser/abi/shared/interfaces/motoswap/{IAdministeredOP20.d.ts → IMoto.d.ts}

@@ -1,6 +1,6 @@
 import { Address } from '@btc-vision/transaction';
-import { IOP_20Contract } from '../opnet/IOP_20Contract';
 import { CallResult } from '../../../../opnet';
+import { IOP_20Contract } from '../opnet/IOP_20Contract';
 export type Admin = CallResult<{
     ADDRESS: Address;
 }>;
@@ -13,7 +13,7 @@ export type AdminMint = CallResult<{
 export type AdminBurn = CallResult<{
     success: boolean;
 }>;
-export interface IAdministeredOP20Contract extends IOP_20Contract {
+export interface IMoto extends IOP_20Contract {
     admin(): Promise<Admin>;
     changeAdmin(newAdmin: Address): Promise<ChangeAdmin>;
     adminMint(to: Address, amount: bigint): Promise<AdminMint>;

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

@@ -0,0 +1,208 @@
+import { Address } from '@btc-vision/transaction';
+import { CallResult, OPNetEvent } from '../../../../opnet';
+import { IOP_NETContract } from '../opnet/IOP_NETContract';
+export type OwnershipTransferredEvent = {
+    readonly previousOwner: Address;
+    readonly newOwner: Address;
+};
+export type Owner = CallResult<{
+    owner: Address;
+}, OPNetEvent<never>[]>;
+export type RenounceOwnership = CallResult<{
+    success: boolean;
+}, OPNetEvent<OwnershipTransferredEvent>[]>;
+export type TransferOwnership = CallResult<{
+    success: boolean;
+}, OPNetEvent<OwnershipTransferredEvent>[]>;
+interface IOwnable extends IOP_NETContract {
+    owner(): Promise<Owner>;
+    renounceOwnership(): Promise<RenounceOwnership>;
+    transferOwnership(newOwner: Address): Promise<TransferOwnership>;
+}
+export type LogPoolAdditionEvent = {
+    readonly poolId: bigint;
+    readonly allocPoint: bigint;
+    readonly lpToken: Address;
+};
+export type LogInitEvent = {};
+export type LogUpdatePoolEvent = {
+    readonly poolId: bigint;
+    readonly lastRewardBlock: bigint;
+    readonly lpSupply: bigint;
+    readonly accMotoPerShare: bigint;
+};
+export type StakedBTCEvent = {
+    readonly user: Address;
+    readonly netAmount: bigint;
+    readonly stakeTxHash: bigint;
+    readonly stakeIndex: bigint;
+};
+export type UnstakedBTCEvent = {
+    readonly user: Address;
+    readonly pendingMoto: bigint;
+    readonly storedTxHash: bigint;
+    readonly storedIndex: bigint;
+};
+export type LogSetPoolEvent = {
+    readonly poolId: bigint;
+    readonly allocPoint: bigint;
+};
+export type DepositEvent = {
+    readonly user: Address;
+    readonly poolId: bigint;
+    readonly amount: bigint;
+    readonly to: Address;
+};
+export type WithdrawEvent = {
+    readonly user: Address;
+    readonly poolId: bigint;
+    readonly amount: bigint;
+    readonly to: Address;
+};
+export type HarvestEvent = {
+    readonly user: Address;
+    readonly poolId: bigint;
+    readonly amount: bigint;
+};
+export type EmergencyWithdrawEvent = {
+    readonly user: Address;
+    readonly poolId: bigint;
+    readonly amount: bigint;
+    readonly to: Address;
+};
+export type Initialize = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogPoolAdditionEvent | LogInitEvent>[]>;
+export type TotalAllocPoint = CallResult<{
+    totalAllocPoint: bigint;
+}, OPNetEvent<never>[]>;
+export type DevAddress = CallResult<{
+    devAddress: Address;
+}, 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: bigint;
+}, 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 GetStakingTxHash = CallResult<{
+    stakingTxHash: bigint;
+}, OPNetEvent<never>[]>;
+export type GetStakingIndex = CallResult<{
+    stakingIndex: bigint;
+}, OPNetEvent<never>[]>;
+export type TotalBTCStaked = CallResult<{
+    totalBTCStaked: bigint;
+}, OPNetEvent<never>[]>;
+export type StakeBTC = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogUpdatePoolEvent | StakedBTCEvent>[]>;
+export type UnstakeBTC = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogUpdatePoolEvent | UnstakedBTCEvent>[]>;
+export type Add = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogPoolAdditionEvent>[]>;
+export type Set = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogSetPoolEvent>[]>;
+export type UpdatePool = CallResult<{
+    accMotoPerShare: bigint;
+    lastRewardBlock: bigint;
+    allocPoint: bigint;
+}, OPNetEvent<LogUpdatePoolEvent>[]>;
+export type MassUpdatePools = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogUpdatePoolEvent>[]>;
+export type Deposit = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogUpdatePoolEvent | DepositEvent>[]>;
+export type Withdraw = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogUpdatePoolEvent | WithdrawEvent>[]>;
+export type Harvest = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogUpdatePoolEvent | HarvestEvent>[]>;
+export type WithdrawAndHarvest = CallResult<{
+    success: boolean;
+}, OPNetEvent<LogUpdatePoolEvent | WithdrawEvent | HarvestEvent>[]>;
+export type EmergencyWithdraw = CallResult<{
+    success: boolean;
+}, OPNetEvent<EmergencyWithdrawEvent>[]>;
+export type SetMotoPerBlock = CallResult<{
+    success: boolean;
+}, OPNetEvent<never>[]>;
+export type SetBonusEndBlock = CallResult<{
+    success: boolean;
+}, OPNetEvent<never>[]>;
+export type SetBonusMultiplier = CallResult<{
+    success: boolean;
+}, OPNetEvent<never>[]>;
+export type SetDev = CallResult<{
+    success: boolean;
+}, OPNetEvent<never>[]>;
+export interface IMotoChef extends IOwnable {
+    initialize(motoAddress: Address, premineAmount: bigint, devAddress: Address, motoPerBlock: bigint, bonusEndBlock: bigint, bonusMultiplier: bigint, treasuryAddress: string, BTCAllocPoint: bigint): Promise<Initialize>;
+    totalAllocPoint(): Promise<TotalAllocPoint>;
+    devAddress(): Promise<DevAddress>;
+    getMotoPerBlock(): Promise<GetMotoPerBlock>;
+    getBonusEndBlock(): Promise<GetBonusEndBlock>;
+    getBonusMultiplier(): Promise<GetBonusMultiplier>;
+    getLpTokens(): Promise<GetLpTokens>;
+    getPoolsLength(): Promise<GetPoolsLength>;
+    getLpToken(poolId: bigint): Promise<GetLpToken>;
+    getPoolInfo(poolId: bigint): Promise<GetPoolInfo>;
+    getUserInfo(poolId: bigint, user: Address): Promise<GetUserInfo>;
+    getMultiplier(from: bigint, to: bigint): Promise<GetMultiplier>;
+    pendingMoto(poolId: bigint, user: Address): Promise<PendingMoto>;
+    treasuryAddress(): Promise<TreasuryAddress>;
+    getStakingTxHash(user: Address): Promise<GetStakingTxHash>;
+    getStakingIndex(user: Address): Promise<GetStakingIndex>;
+    totalBTCStaked(): Promise<TotalBTCStaked>;
+    stakeBTC(amount: bigint): Promise<StakeBTC>;
+    unstakeBTC(): Promise<UnstakeBTC>;
+    add(allocPoint: bigint, lpToken: Address): Promise<Add>;
+    set(poolId: bigint, allocPoint: bigint): Promise<Set>;
+    updatePool(poolId: bigint): Promise<UpdatePool>;
+    massUpdatePools(length: number, poolIds: bigint[]): Promise<MassUpdatePools>;
+    deposit(poolId: bigint, amount: bigint, to: Address): Promise<Deposit>;
+    withdraw(poolId: bigint, amount: bigint, to: Address): Promise<Withdraw>;
+    harvest(poolId: bigint, to: Address): Promise<Harvest>;
+    withdrawAndHarvest(poolId: bigint, amount: bigint, to: Address): Promise<WithdrawAndHarvest>;
+    emergencyWithdraw(poolId: bigint, to: Address): Promise<EmergencyWithdraw>;
+    setMotoPerBlock(motoPerBlock: bigint): Promise<SetMotoPerBlock>;
+    setBonusEndBlock(bonusEndBlock: bigint): Promise<SetBonusEndBlock>;
+    setBonusMultiplier(bonusMultiplier: bigint): Promise<SetBonusMultiplier>;
+    setDev(devAddress: Address): Promise<SetDev>;
+}
+export {};

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

@@ -25,10 +25,6 @@ export type SwapEvent = {
     readonly amount1Out: bigint;
     readonly to: Address;
 };
-export type SyncEvent = {
-    readonly reserve0: bigint;
-    readonly reserve1: bigint;
-};
 export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mint'> {
     token0(): Promise<CallResult<{
         token0: Address;

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

@@ -1,6 +1,21 @@
 import { Address } from '@btc-vision/transaction';
-import { CallResult } from '../../../../opnet.js';
-import { IOwnableReentrancyGuardContract } from './IOwnableReentrancyGuardContract.js';
+import { CallResult, IOP_NETContract } from '../../../../opnet.js';
+export type Status = CallResult<{
+    status: bigint;
+}>;
+interface IMotoswapReentrancyGuard extends IOP_NETContract {
+    status(): Promise<Status>;
+}
+export type Admin = CallResult<{
+    adminAddress: Address;
+}>;
+export type ChangeAdmin = CallResult<{
+    success: boolean;
+}>;
+interface IMotoswapOwnableReentrancyGuard extends IMotoswapReentrancyGuard {
+    admin(): Promise<Admin>;
+    changeAdmin(newAdmin: Address): Promise<ChangeAdmin>;
+}
 export type GetMotoAddress = CallResult<{
     motoAddress: Address;
 }>;
@@ -58,7 +73,7 @@ export type RewardTokenAddedEvent = {
 export type RewardTokenRemovedEvent = {
     readonly token: Address;
 };
-export interface IMotoswapStakingContract extends IOwnableReentrancyGuardContract {
+export interface IMotoswapStakingContract extends IMotoswapOwnableReentrancyGuard {
     balanceOf(address: Address): Promise<BalanceOf>;
     totalSupply(): Promise<TotalSupply>;
     motoAddress(): Promise<MotoAddress>;
@@ -76,3 +91,4 @@ export interface IMotoswapStakingContract extends IOwnableReentrancyGuardContrac
     adminChangeLockupParameters(newLockupDuration: bigint, newMaxSlashingFeePercent: bigint, newBlocksPerOnePercentSlashingFeeReduction: bigint): Promise<AdminChangeLockupParameters>;
     adminEnableEmergencyWithdrawals(): Promise<AdminEnableEmergencyWithdrawals>;
 }
+export {};

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

@@ -34,22 +34,30 @@ export type UnlistEvent = {
 export type LiquidityReservedEvent = {
     readonly depositAddress: string;
     readonly amount: bigint;
+    readonly providerId: bigint;
+};
+export type ActivateProviderEvent = {
+    readonly providerId: bigint;
+    readonly listingAmount: bigint;
+};
+export type FulfilledProviderEvent = {
+    readonly providerId: bigint;
 };
 export type ReserveNativeSwap = CallResult<{
     ok: boolean;
-}, OPNetEvent<LiquidityReservedEvent | ReservationCreatedEvent | TransferEvent>[]>;
+}, OPNetEvent<LiquidityReservedEvent | ReservationCreatedEvent | TransferEvent | FulfilledProviderEvent>[]>;
 export type AddLiquidity = CallResult<{
     ok: boolean;
-}, OPNetEvent<LiquidityAddedEvent | TransferEvent>[]>;
+}, OPNetEvent<LiquidityAddedEvent | TransferEvent | ActivateProviderEvent | FulfilledProviderEvent>[]>;
 export type RemoveLiquidity = CallResult<{
     ok: boolean;
-}, OPNetEvent<LiquidityRemovedEvent | TransferEvent>[]>;
+}, OPNetEvent<LiquidityRemovedEvent | TransferEvent | FulfilledProviderEvent>[]>;
 export type ListLiquidity = CallResult<{
     ok: boolean;
 }, OPNetEvent<LiquidityListedEvent>[]>;
 export type CancelListing = CallResult<{
     ok: boolean;
-}, OPNetEvent<UnlistEvent | TransferEvent>[]>;
+}, OPNetEvent<UnlistEvent | TransferEvent | FulfilledProviderEvent>[]>;
 export type CreatePool = CallResult<{
     ok: boolean;
 }, OPNetEvent<TransferEvent | LiquidityAddedEvent>[]>;
@@ -64,7 +72,7 @@ export type GetFees = CallResult<{
 ]>;
 export type Swap = CallResult<{
     ok: boolean;
-}, OPNetEvent<SwapExecutedEvent | TransferEvent>[]>;
+}, OPNetEvent<SwapExecutedEvent | TransferEvent | ActivateProviderEvent | FulfilledProviderEvent>[]>;
 export type GetReserve = CallResult<{
     liquidity: bigint;
     reservedLiquidity: bigint;

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

@@ -2,7 +2,7 @@ import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
 import { BaseContractProperties } from '../../../interfaces/BaseContractProperties.js';
 export interface IOP_NETContract extends BaseContractProperties {
-    deployer(): Promise<CallResult<{
-        deployer: Address;
+    contractDeployer(): Promise<CallResult<{
+        contractDeployer: Address;
     }>>;
 }

package/browser/abi/shared/json/generic/STAKING_ABI.d.ts

@@ -1,3 +1,2 @@
 import { BitcoinInterfaceAbi } from '../../../interfaces/BitcoinInterfaceAbi.js';
-export declare const StackingEvents: BitcoinInterfaceAbi;
 export declare const STAKING_ABI: BitcoinInterfaceAbi;

package/{build/abi/shared/json/motoswap/REENTRANCY_GUARD_ABI.d.ts → browser/abi/shared/json/motoswap/MOTOCHEF_ABI.d.ts}

@@ -1,2 +1,2 @@
 import { BitcoinInterfaceAbi } from '../../../interfaces/BitcoinInterfaceAbi.js';
-export declare const REENTRANCY_GUARD_ABI: BitcoinInterfaceAbi;
+export declare const MOTOCHEF_ABI: BitcoinInterfaceAbi;

package/browser/abi/shared/json/motoswap/MOTOSWAP_STAKING_ABI.d.ts

@@ -1,3 +1,2 @@
 import { BitcoinInterfaceAbi } from '../../../interfaces/BitcoinInterfaceAbi.js';
-export declare const MotoswapStakingEvents: BitcoinInterfaceAbi;
 export declare const MOTOSWAP_STAKING_ABI: BitcoinInterfaceAbi;

package/browser/abi/shared/json/motoswap/MOTO_ABI.d.ts

@@ -0,0 +1,2 @@
+import { BitcoinInterfaceAbi } from '../../../interfaces/BitcoinInterfaceAbi';
+export declare const MOTO_ABI: BitcoinInterfaceAbi;

package/browser/abi/shared/json/motoswap/NATIVE_SWAP_ABI.d.ts

@@ -1,3 +1,2 @@
 import { BitcoinInterfaceAbi } from '../../../interfaces/BitcoinInterfaceAbi.js';
-export declare const NativeSwapEvents: BitcoinInterfaceAbi;
 export declare const NativeSwapAbi: BitcoinInterfaceAbi;

package/browser/fetch/fetch-browser.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function fetch(input: any, init: any): Promise<Response>;
+}
+export default _default;

package/browser/fetch/fetch.d.ts

@@ -0,0 +1,2 @@
+import { fetch } from 'undici';
+export default fetch;