opnet 1.2.26 → 1.3.0

package/build/providers/AbstractRpcProvider.js

@@ -63,13 +63,14 @@ export class AbstractRpcProvider {
         const payload = this.buildJsonRpcPayload(JSONRpcMethods.TRANSACTION_PREIMAGE, []);
         const rawBlockNumber = await this.callPayloadSingle(payload);
         const result = rawBlockNumber.result;
-        if (!result || result.preimage === '0000000000000000000000000000000000000000000000000000000000000000') {
+        if (!result ||
+            result.preimage === '0000000000000000000000000000000000000000000000000000000000000000') {
             throw new Error('No preimage found. OPNet is probably not active yet on this blockchain.');
         }
         const preimage = Buffer.from(result.preimage, 'hex');
         this.preimageCache = {
             preimage: preimage,
-            expireAt: Date.now() + 10_000
+            expireAt: Date.now() + 10_000,
         };
         return preimage;
     }
@@ -361,7 +362,7 @@ export class AbstractRpcProvider {
             jsonrpc: '2.0',
         };
     }
-    async getPublicKeysInfo(addresses) {
+    async getPublicKeysInfo(addresses, logErrors = false) {
         const addressArray = Array.isArray(addresses) ? addresses : [addresses];
         addressArray.forEach((addr) => {
             if (this.validateAddress(addr, this.network) === null) {
@@ -380,7 +381,10 @@ export class AbstractRpcProvider {
         for (const pubKey of keys) {
             const pubKeyValue = result[pubKey];
             if ('error' in pubKeyValue) {
-                throw new Error(`Error fetching public key info: ${pubKeyValue.error}`);
+                if (logErrors) {
+                    console.error(`Error fetching public key info for ${pubKey}: ${pubKeyValue.error}`);
+                }
+                continue;
             }
             response[pubKey] = pubKeyValue.originalPubKey
                 ? Address.fromString(pubKeyValue.originalPubKey)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opnet",
   "type": "module",
-  "version": "1.2.26",
+  "version": "1.3.0",
   "author": "OP_NET",
   "description": "The perfect library for building Bitcoin-based applications.",
   "engines": {
@@ -60,24 +60,24 @@
     "docs": "typedoc --out docs --tsconfig tsconfig.json --readme README.md --name OPNet --plugin typedoc-material-theme --themeColor '#cb9820' --exclude src/scripts/test.ts --exclude src/index.ts src"
   },
   "devDependencies": {
-    "@babel/core": "^7.26.8",
+    "@babel/core": "^7.26.9",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
-    "@babel/plugin-transform-runtime": "^7.26.8",
-    "@babel/preset-env": "^7.26.8",
+    "@babel/plugin-transform-runtime": "^7.26.9",
+    "@babel/preset-env": "^7.26.9",
     "@babel/preset-flow": "^7.25.9",
     "@babel/preset-react": "^7.26.3",
     "@babel/preset-typescript": "^7.26.0",
-    "@eslint/js": "^9.20.0",
-    "@types/node": "^22.13.2",
+    "@eslint/js": "^9.22.0",
+    "@types/node": "^22.13.10",
     "@types/sha.js": "^2.4.4",
-    "@types/ws": "^8.5.14",
+    "@types/ws": "^8.18.0",
     "assert": "^2.1.0",
     "babel-loader": "^9.2.1",
     "babel-plugin-transform-import-meta": "^2.3.2",
     "babel-preset-react": "^6.24.1",
     "babelify": "^10.0.0",
-    "eslint": "^9.20.1",
+    "eslint": "^9.22.0",
     "gulp": "^5.0.0",
     "gulp-cached": "^1.1.1",
     "gulp-clean": "^0.4.0",
@@ -86,23 +86,23 @@
     "gulp-typescript": "^6.0.0-alpha.1",
     "https-browserify": "^1.0.0",
     "os-browserify": "^0.3.0",
-    "prettier": "^3.5.0",
+    "prettier": "^3.5.3",
     "process": "^0.11.10",
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "ts-loader": "^9.5.2",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.27.7",
+    "typedoc": "^0.27.9",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.24.0",
-    "webpack": "^5.97.1",
+    "typescript-eslint": "^8.26.0",
+    "webpack": "^5.98.0",
     "webpack-cli": "^6.0.1"
   },
   "dependencies": {
     "@bitcoinerlab/secp256k1": "^1.2.0",
     "@btc-vision/bitcoin": "^6.3.6",
     "@btc-vision/bitcoin-rpc": "^1.0.1",
-    "@btc-vision/transaction": "^1.2.14",
+    "@btc-vision/transaction": "^1.3.1",
     "@noble/hashes": "^1.7.1",
     "bignumber.js": "^9.1.2",
     "buffer": "^6.0.3",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.2.26';
+export const version = '1.3.0';

package/src/abi/shared/interfaces/motoswap/IMotoChefContract.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 = {
@@ -13,20 +13,31 @@ export type UserInfo = {
     rewardDebt: bigint;
 };
 
-export type Initialize = CallResult<{
-    success: boolean;
-}>;
+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<{
@@ -54,14 +65,36 @@ export type BonusMultiplier = CallResult<{
     bonusMultiplier: bigint;
 }>;
 
-export type Add = CallResult<{
-    success: boolean;
+export type TotalBtcStaked = CallResult<{
+    totalBtcStaked: bigint;
 }>;
 
-export type Set = CallResult<{
-    success: boolean;
+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;
 }>;
@@ -82,23 +115,35 @@ export type MassUpdatePools = CallResult<{
     success: boolean;
 }>;
 
-export type UpdatePool = CallResult<PoolInfo>;
-
-export type Deposit = CallResult<{
-    success: boolean;
-}>;
-
-export type Withdraw = CallResult<{
-    success: boolean;
-}>;
-
-export type Harvest = CallResult<{
-    success: boolean;
-}>;
-
-export type WithdrawAndHarvest = CallResult<{
-    success: boolean;
-}>;
+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;
@@ -116,27 +161,48 @@ export type SetBonusMultiplier = CallResult<{
     success: boolean;
 }>;
 
-export type EmergencyWithdraw = CallResult<{
-    success: boolean;
-}>;
+export type EmergencyWithdraw = CallResult<
+    {
+        success: boolean;
+    },
+    [OPNetEvent<EmergencyWithdrawEvent>]
+>;
+
+export type StakeBtc = CallResult<
+    {
+        success: boolean;
+    },
+    [OPNetEvent<StakeBTCEvent>]
+>;
+
+export type UnstakeBtc = CallResult<
+    {
+        success: boolean;
+    },
+    [OPNetEvent<UnstakeBTCEvent>]
+>;
 
 // EVENTS
+export type LogInitEvent = {
+    success: boolean;
+};
+
 export type LogPoolAdditionEvent = {
-    readonly pid: number; // uint32
+    readonly pid: bigint; // uint256
     readonly allocPoint: bigint; // uint256
     readonly lpToken: Address;
     readonly rewarder: Address;
 };
 
 export type LogSetPoolEvent = {
-    readonly pid: number; // uint32
+    readonly pid: bigint; // uint256
     readonly allocPoint: bigint; // uint256
     readonly rewarder: Address;
     readonly overwrite: boolean; // bool
 };
 
 export type LogUpdatePoolEvent = {
-    readonly pid: number; // uint32
+    readonly pid: bigint; // uint256
     readonly lastRewardBlock: bigint; // uint64
     readonly lpSupply: bigint; // uint256
     readonly accMotoPerShare: bigint; // uint256
@@ -144,32 +210,44 @@ export type LogUpdatePoolEvent = {
 
 export type DepositEvent = {
     readonly user: Address;
-    readonly pid: number; // uint32
+    readonly pid: bigint; // uint32
     readonly amount: bigint; // uint256
     readonly to: Address;
 };
 
 export type WithdrawEvent = {
     readonly user: Address;
-    readonly pid: number; // uint32
+    readonly pid: bigint; // uint256
     readonly amount: bigint; // uint256
     readonly to: Address;
 };
 
 export type HarvestEvent = {
     readonly user: Address;
-    readonly pid: number; // uint32
+    readonly pid: bigint; // uint256
     readonly amount: bigint; // uint256
 };
 
 export type EmergencyWithdrawEvent = {
     readonly user: Address;
-    readonly pid: number; // uint32
+    readonly pid: bigint; // uint256
     readonly amount: bigint; // uint256
     readonly to: Address;
 };
 
-// TODO: Add events to results.
+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;
+};
 
 /**
  * @description This interface represents the MotoChef contract.
@@ -186,6 +264,8 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {bigint} motoPerBlock The amount of MOTOs created per block.
      * @param {bigint} bonusEndBlock The block number when the bonus MOTO period ends.
      * @param {bigint} bonusMultiplier The bonus muliplier for early moto makers.
+     * @param treasuryAddress The treasury address for btc
+     * @param btcAllocPoint The alloc point for the BTC pool
      * @returns {Initialize}
      */
     initialize(
@@ -195,6 +275,8 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
         motoPerBlock: bigint,
         bonusEndBlock: bigint,
         bonusMultiplier: bigint,
+        treasuryAddress: string,
+        btcAllocPoint: bigint,
     ): Promise<Initialize>;
 
     /**
@@ -202,21 +284,18 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {number} pid The index of the pool
      * @returns {GetLpToken}
      */
-    getLpToken(pid: number): Promise<GetLpToken>;
+    getLpToken(pid: bigint): Promise<GetLpToken>;
 
-    /**
-     * @description Gets the rewarder address of a pool
-     * @param {number} pid The index of the pool
-     * @returns {GetRewarder}
-     */
-    getRewarder(pid: number): Promise<GetRewarder>;
+    getLpTokens(): Promise<GetLpTokens>;
 
     /**
      * @description Gets the pool info of a pool
      * @param {number} pid The index of the pool
      * @returns {GetPoolInfo}
      */
-    getPoolInfo(pid: number): Promise<GetPoolInfo>;
+    getPoolInfo(pid: bigint): Promise<GetPoolInfo>;
+
+    getPoolsLength(): Promise<GetPoolsLength>;
 
     /**
      * @description Gets the user info of a pool
@@ -224,13 +303,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {Address} user The address of the user
      * @returns {GetUserInfo}
      */
-    getUserInfo(pid: number, user: Address): Promise<GetUserInfo>;
-
-    /**
-     * @description Gets all the available pools
-     * @returns {Pools}
-     */
-    pools(): Promise<Pools>;
+    getUserInfo(pid: bigint, user: Address): Promise<GetUserInfo>;
 
     /**
      * @description Gets the total alloc point
@@ -262,6 +335,14 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      */
     getBonusMultiplier(): Promise<BonusMultiplier>;
 
+    totalBtcStaked(): Promise<TotalBtcStaked>;
+
+    treasuryAddress(): Promise<TreasuryAddress>;
+
+    getStakingTxId(): Promise<GetStakingTxId>;
+
+    getStakingIndex(): Promise<GetStakingIndex>;
+
     /**
      * @description Set the moto per block. Can only be called by an admin.
      * @param {bigint} motoPerBlock The amount of MOTO per block.
@@ -290,7 +371,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {Address} rewarder Address of the rewarder delegate.
      * @returns {Add}
      */
-    add(allocPoint: bigint, lpToken: Address, rewarder: Address): Promise<Add>;
+    add(allocPoint: bigint, lpToken: Address): Promise<Add>;
 
     /**
      * @description Update the given pool's MOTO allocation point and `IRewarder` contract. Can only be called by an admin.
@@ -300,7 +381,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {boolean} overwrite True if _rewarder should be `set`. Otherwise `_rewarder` is ignored.
      * @returns {Set}
      */
-    set(pid: number, allocPoint: bigint, rewarder: Address, overwrite: boolean): Promise<Set>;
+    set(pid: bigint, allocPoint: bigint): Promise<Set>;
 
     /**
      * @description Set the `migrator` contract. Can only be called by an admin.
@@ -314,7 +395,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {number} pid The index of the pool.
      * @returns {Migrate}
      */
-    migrate(pid: number): Promise<Migrate>;
+    migrate(pid: bigint): Promise<Migrate>;
 
     /**
      * @description Get the multiplier over the given _from to _to block.
@@ -330,7 +411,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {Address} user Address of user.
      * @returns {PendingMoto}
      */
-    pendingMoto(pid: number, user: Address): Promise<PendingMoto>;
+    pendingMoto(pid: bigint, user: Address): Promise<PendingMoto>;
 
     /**
      * @description Update reward variables for all pools. Be careful of gas spending!
@@ -338,14 +419,14 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {number[]} pids Pool IDs of all to be updated. Make sure to update all active pools.
      * @returns {MassUpdatePools}
      */
-    massUpdatePools(length: number, pids: number[]): Promise<MassUpdatePools>;
+    massUpdatePools(length: number, pids: bigint[]): Promise<MassUpdatePools>;
 
     /**
      * @description Update reward variables of the given pool.
      * @param {number} pid The index of the pool
      * @returns {UpdatePool}
      */
-    updatePool(pid: number): Promise<UpdatePool>;
+    updatePool(pid: bigint): Promise<UpdatePool>;
 
     /**
      * @description Deposit LP tokens to MotoChef for MOTO allocation.
@@ -354,7 +435,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {Address} to The receiver of `amount` deposit benefit.
      * @returns {Deposit}
      */
-    deposit(pid: number, amount: bigint, to: Address): Promise<Deposit>;
+    deposit(pid: bigint, amount: bigint, to: Address): Promise<Deposit>;
 
     /**
      * @description Withdraw LP tokens from MotoChef.
@@ -363,7 +444,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {Address} to The receiver of `amount` deposit benefit.
      * @returns {Withdraw}
      */
-    withdraw(pid: number, amount: bigint, to: Address): Promise<Withdraw>;
+    withdraw(pid: bigint, amount: bigint, to: Address): Promise<Withdraw>;
 
     /**
      * @description Harvest proceeds for transaction sender to `to`.
@@ -371,7 +452,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {Address} to Receiver of MOTO rewards.
      * @returns {Harvest}
      */
-    harvest(pid: number, to: Address): Promise<Harvest>;
+    harvest(pid: bigint, to: Address): Promise<Harvest>;
 
     /**
      * @description Withdraw LP tokens from MotoChef and harvest proceeds for transaction sender to `to`.
@@ -380,7 +461,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {Address} to Receiver of the LP tokens and MOTO rewards.
      * @returns {WithdrawAndHarvest}
      */
-    withdrawAndHarvest(pid: number, amount: bigint, to: Address): Promise<WithdrawAndHarvest>;
+    withdrawAndHarvest(pid: bigint, amount: bigint, to: Address): Promise<WithdrawAndHarvest>;
 
     /**
      * @description Withdraw without caring about rewards. EMERGENCY ONLY.
@@ -388,7 +469,7 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @param {Address} to Receiver of the LP tokens.
      * @returns {EmergencyWithdraw}
      */
-    emergencyWithdraw(pid: number, to: Address): Promise<EmergencyWithdraw>;
+    emergencyWithdraw(pid: bigint, to: Address): Promise<EmergencyWithdraw>;
 
     /**
      * @description Update dev address by the previous dev.
@@ -396,4 +477,8 @@ export interface IMotoChefContract extends IOwnableReentrancyGuardContract {
      * @returns {SetDev}
      */
     setDev(devaddr: Address): Promise<SetDev>;
+
+    stakeBtc(stakeAmount: bigint): Promise<StakeBtc>;
+
+    unstakeBtc(): Promise<UnstakeBtc>;
 }

package/src/abi/shared/interfaces/motoswap/IMotoswapFactoryContract.ts

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

package/src/abi/shared/interfaces/motoswap/IMotoswapPoolContract.ts

@@ -98,7 +98,9 @@ export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mi
      * @param {Address} to
      * @returns {Promise<CallResult>}
      */
-    burn(to: Address): Promise<CallResult>;
+    burn(
+        to: Address,
+    ): Promise<CallResult<{ amount0: bigint; amount1: bigint }, [OPNetEvent<PoolBurnEvent>]>>;
 
     /**
      * Get block timestamp last
@@ -124,4 +126,10 @@ export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mi
      * @returns {Promise<CallResult>}
      */
     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/src/abi/shared/interfaces/motoswap/IMotoswapStakingContract.ts

@@ -1,4 +1,4 @@
-import { ABIDataTypes, Address } from '@btc-vision/transaction';
+import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../opnet.js';
 import { IOwnableReentrancyGuardContract } from './IOwnableReentrancyGuardContract.js';
 
@@ -14,6 +14,10 @@ export type TotalSupply = CallResult<{
     totalSupply: bigint;
 }>;
 
+export type MotoAddress = CallResult<{
+    totalSupply: bigint;
+}>;
+
 export type LastInteractedBlock = CallResult<{
     lastInteractedBlock: bigint;
 }>;
@@ -82,12 +86,6 @@ export type RewardTokenRemovedEvent = {
  * @cathegory Contracts
  */
 export interface IMotoswapStakingContract extends IOwnableReentrancyGuardContract {
-    /**
-     * @description Gets the Moto token address the staking contract uses for deposits
-     * @returns {GetMotoAddress}
-     */
-    getMotoAddress(): Promise<GetMotoAddress>;
-
     /**
      * @description Gets the stake of a given user
      * @param address {Address} the address of the staker
@@ -101,6 +99,12 @@ export interface IMotoswapStakingContract extends IOwnableReentrancyGuardContrac
      */
     totalSupply(): Promise<TotalSupply>;
 
+    /**
+     * @description Returns the address of the MOTO token accepted as a deposit by the staking contract
+     * @returns {MotoAddress}
+     */
+    motoAddress(): Promise<MotoAddress>;
+
     /**
      * @description Returns the last block the user interacted with the protocol by staking, unstaking or claiming rewards
      * @param address {Address} the address of the staker
@@ -174,6 +178,7 @@ export interface IMotoswapStakingContract extends IOwnableReentrancyGuardContrac
     /**
      * @description Changes the address of the Moto token the protocol allows the users to stake
      * Also affects what token is paid out when unstaking.
+     * NOTE: Can only be called if the Moto token address is not set yet (i.e. == Address.dead())
      * @param token {Address} the address of the Moto token
      * @returns {AdminChangeMotoAddress}
      */