opnet 1.2.13 → 1.2.15

package/browser/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.2.13";
+export declare const version = "1.2.15";

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

@@ -1,6 +1,6 @@
 import { Address } from '@btc-vision/transaction';
-import { IOwnableReentrancyGuardContract } from './IOwnableReentrancyGuardContract';
 import { CallResult } from '../../../../opnet';
+import { IOwnableReentrancyGuardContract } from './IOwnableReentrancyGuardContract';
 export type PoolInfo = {
     allocPoint: number;
     lastRewardBlock: number;
@@ -89,6 +89,47 @@ export type SetBonusMultiplier = CallResult<{
 export type EmergencyWithdraw = CallResult<{
     success: boolean;
 }>;
+export type LogPoolAdditionEvent = {
+    readonly pid: number;
+    readonly allocPoint: bigint;
+    readonly lpToken: Address;
+    readonly rewarder: Address;
+};
+export type LogSetPoolEvent = {
+    readonly pid: number;
+    readonly allocPoint: bigint;
+    readonly rewarder: Address;
+    readonly overwrite: boolean;
+};
+export type LogUpdatePoolEvent = {
+    readonly pid: number;
+    readonly lastRewardBlock: bigint;
+    readonly lpSupply: bigint;
+    readonly accMotoPerShare: bigint;
+};
+export type DepositEvent = {
+    readonly user: Address;
+    readonly pid: number;
+    readonly amount: bigint;
+    readonly to: Address;
+};
+export type WithdrawEvent = {
+    readonly user: Address;
+    readonly pid: number;
+    readonly amount: bigint;
+    readonly to: Address;
+};
+export type HarvestEvent = {
+    readonly user: Address;
+    readonly pid: number;
+    readonly amount: bigint;
+};
+export type EmergencyWithdrawEvent = {
+    readonly user: Address;
+    readonly pid: number;
+    readonly amount: bigint;
+    readonly to: Address;
+};
 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>;

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

@@ -1,6 +1,12 @@
 import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
 import { IOP_NETContract } from '../opnet/IOP_NETContract.js';
+export type PoolCreatedEvent = {
+    readonly token0: Address;
+    readonly token1: Address;
+    readonly pool: bigint;
+};
 export interface IMotoswapFactoryContract extends IOP_NETContract {
     getPool(token0: Address, token1: Address): Promise<CallResult<{
         pool: bigint;
@@ -8,5 +14,5 @@ export interface IMotoswapFactoryContract extends IOP_NETContract {
     createPool(token0: Address, token1: Address): Promise<CallResult<{
         pool: bigint;
         address: Address;
-    }>>;
+    }, [OPNetEvent<PoolCreatedEvent>]>>;
 }

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

@@ -1,11 +1,34 @@
 import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
 import { IOP_20Contract } from '../opnet/IOP_20Contract.js';
 export type Reserves = {
     readonly reserve0: bigint;
     readonly reserve1: bigint;
     readonly blockTimestampLast: bigint;
 };
+export type PoolBurnEvent = {
+    readonly sender: Address;
+    readonly amount0: bigint;
+    readonly amount1: bigint;
+};
+export type PoolMintEvent = {
+    readonly sender: Address;
+    readonly amount0: bigint;
+    readonly amount1: bigint;
+};
+export type SwapEvent = {
+    readonly sender: Address;
+    readonly amount0In: bigint;
+    readonly amount1In: bigint;
+    readonly amount0Out: bigint;
+    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;
@@ -16,7 +39,9 @@ export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mi
     getReserves(): Promise<CallResult<Reserves>>;
     swap(amount0Out: bigint, amount1Out: bigint, to: string, data: Uint8Array): Promise<CallResult<{
         success: boolean;
-    }>>;
+    }, [
+        OPNetEvent<SwapEvent>
+    ]>>;
     skim(): Promise<CallResult<{
         success: boolean;
     }>>;

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

@@ -1,54 +1,94 @@
 import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
+import { TransferEvent } from '../opnet/IOP_20Contract.js';
 import { IOP_NETContract } from '../opnet/IOP_NETContract.js';
+export type LiquidityAddedEvent = {
+    readonly totalTokensContributed: bigint;
+    readonly virtualTokenExchanged: bigint;
+    readonly totalSatoshisSpent: bigint;
+};
+export type LiquidityListedEvent = {
+    readonly totalLiquidity: bigint;
+    readonly provider: string;
+};
+export type LiquidityRemovedEvent = {
+    readonly providerId: bigint;
+    readonly btcOwed: bigint;
+    readonly tokenAmount: bigint;
+};
+export type ReservationCreatedEvent = {
+    readonly expectedAmountOut: bigint;
+    readonly totalSatoshis: bigint;
+};
+export type SwapExecutedEvent = {
+    readonly buyer: Address;
+    readonly amountIn: bigint;
+    readonly amountOut: bigint;
+};
+export type UnlistEvent = {
+    readonly token: Address;
+    readonly amount: bigint;
+    readonly remainingLiquidity: bigint;
+};
+export type LiquidityReservedEvent = {
+    readonly depositAddress: string;
+    readonly amount: bigint;
+};
 export type ReserveNativeSwap = CallResult<{
     ok: boolean;
-}>;
+}, OPNetEvent<LiquidityReservedEvent | ReservationCreatedEvent | TransferEvent>[]>;
 export type AddLiquidity = CallResult<{
     ok: boolean;
-}>;
+}, OPNetEvent<LiquidityAddedEvent | TransferEvent>[]>;
 export type RemoveLiquidity = CallResult<{
     ok: boolean;
-}>;
+}, OPNetEvent<LiquidityRemovedEvent | TransferEvent>[]>;
 export type ListLiquidity = CallResult<{
     ok: boolean;
-}>;
+}, OPNetEvent<LiquidityListedEvent>[]>;
 export type CancelListing = CallResult<{
     ok: boolean;
-}>;
+}, OPNetEvent<UnlistEvent | TransferEvent>[]>;
 export type CreatePool = CallResult<{
     ok: boolean;
-}>;
+}, OPNetEvent<TransferEvent | LiquidityAddedEvent>[]>;
 export type SetFees = CallResult<{
     ok: boolean;
-}>;
+}, [
+]>;
 export type GetFees = CallResult<{
     reservationBaseFee: bigint;
     priorityQueueBaseFee: bigint;
     pricePerUserInPriorityQueueBTC: bigint;
-}>;
+}, [
+]>;
 export type Swap = CallResult<{
     ok: boolean;
-}>;
+}, OPNetEvent<SwapExecutedEvent | TransferEvent>[]>;
 export type GetReserve = CallResult<{
     liquidity: bigint;
     reservedLiquidity: bigint;
     virtualBTCReserve: bigint;
     virtualTokenReserve: bigint;
-}>;
+}, [
+]>;
 export type GetQuote = CallResult<{
     tokensOut: bigint;
     requiredSatoshis: bigint;
     price: bigint;
-}>;
+}, [
+]>;
 export type GetProviderDetails = CallResult<{
     liquidity: bigint;
     reserved: bigint;
     btcReceiver: string;
-}>;
+}, [
+]>;
 export type GetPriorityQueueCost = CallResult<{
     cost: bigint;
-}>;
+}, [
+]>;
 export interface INativeSwapContract extends IOP_NETContract {
     reserve(token: Address, maximumAmountIn: bigint, minimumAmountOut: bigint, forLP: boolean): Promise<ReserveNativeSwap>;
     listLiquidity(token: Address, receiver: string, amountIn: bigint, priority: boolean): Promise<ListLiquidity>;
@@ -57,7 +97,7 @@ export interface INativeSwapContract extends IOP_NETContract {
     createPoolWithSignature(signature: Buffer, approveAmount: 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>;
     getFees(): Promise<GetFees>;
-    addLiquidity(token: Address, receiver: string, amountIn: bigint, priority: boolean): Promise<AddLiquidity>;
+    addLiquidity(token: Address, receiver: string): Promise<AddLiquidity>;
     removeLiquidity(token: Address, amount: bigint): Promise<RemoveLiquidity>;
     swap(token: Address): Promise<Swap>;
     getReserve(token: Address): Promise<GetReserve>;

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

@@ -1,48 +1,68 @@
 import { Address, AddressMap } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
 import { IOP_NETContract } from './IOP_NETContract.js';
+export type MintEvent = {
+    to: Address;
+    amount: bigint;
+};
+export type TransferEvent = {
+    from: Address;
+    to: Address;
+    amount: bigint;
+};
+export type BurnEvent = {
+    amount: bigint;
+};
+export type ApproveEvent = {
+    owner: Address;
+    spender: Address;
+    value: bigint;
+};
 export type Name = CallResult<{
     name: string;
-}>;
+}, []>;
 export type BalanceOf = CallResult<{
     balance: bigint;
-}>;
+}, []>;
 export type SymbolOf = CallResult<{
     symbol: string;
-}>;
+}, []>;
 export type TotalSupply = CallResult<{
     totalSupply: bigint;
-}>;
+}, []>;
 export type MaxSupply = CallResult<{
     maximumSupply: bigint;
-}>;
+}, []>;
 export type Decimals = CallResult<{
     decimals: number;
-}>;
+}, []>;
 export type Transfer = CallResult<{
     success: boolean;
-}>;
+}, [
+    OPNetEvent<TransferEvent>
+]>;
 export type TransferFrom = CallResult<{
     success: boolean;
-}>;
+}, [OPNetEvent<TransferEvent>]>;
 export type Approve = CallResult<{
     success: boolean;
-}>;
+}, [OPNetEvent<ApproveEvent>]>;
 export type Allowance = CallResult<{
     remaining: bigint;
-}>;
+}, []>;
 export type Burn = CallResult<{
     success: boolean;
-}>;
+}, [OPNetEvent<BurnEvent>]>;
 export type Mint = CallResult<{
     success: boolean;
-}>;
+}, [OPNetEvent<MintEvent>]>;
 export type Airdrop = CallResult<{
     success: boolean;
-}>;
+}, OPNetEvent<MintEvent>[]>;
 export type AirdropWithAmount = CallResult<{
     success: boolean;
-}>;
+}, OPNetEvent<MintEvent>[]>;
 export interface IOP_20Contract extends IOP_NETContract {
     balanceOf(account: Address): Promise<BalanceOf>;
     name(): Promise<Name>;

package/browser/contracts/CallResult.d.ts

@@ -23,7 +23,7 @@ export interface InteractionTransactionReceipt {
     readonly estimatedFees: bigint;
     readonly preimage: string;
 }
-export declare class CallResult<T extends ContractDecodedObjectResult = {}> implements Omit<ICallResultData, 'estimatedGas' | 'events'> {
+export declare class CallResult<T extends ContractDecodedObjectResult = {}, U extends OPNetEvent<ContractDecodedObjectResult>[] = OPNetEvent<ContractDecodedObjectResult>[]> implements Omit<ICallResultData, 'estimatedGas' | 'events'> {
     #private;
     readonly result: BinaryReader;
     readonly accessList: IAccessList;
@@ -32,7 +32,7 @@ export declare class CallResult<T extends ContractDecodedObjectResult = {}> impl
     readonly estimatedGas: bigint | undefined;
     properties: T;
     estimatedSatGas: bigint;
-    events: OPNetEvent[];
+    events: U;
     to: string | undefined;
     constructor(callResult: ICallResultData, provider: AbstractRpcProvider);
     get rawEvents(): EventList;
@@ -40,6 +40,7 @@ export declare class CallResult<T extends ContractDecodedObjectResult = {}> impl
     sendTransaction(interactionParams: TransactionParameters): Promise<InteractionTransactionReceipt>;
     setGasEstimation(estimatedGas: bigint): void;
     setDecoded(decoded: DecodedOutput): void;
+    setEvents(events: U): void;
     setCalldata(calldata: Buffer): void;
     private contractToString;
     private parseEvents;

package/browser/contracts/Contract.d.ts

@@ -36,7 +36,7 @@ export declare abstract class IBaseContract<T extends BaseContractProperties> im
     protected constructor(address: string | Address, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, network: Network, from?: Address);
     get p2trOrTweaked(): string;
     setSender(sender: Address): void;
-    decodeEvents(events: NetEvent[] | ContractEvents): OPNetEvent[];
+    decodeEvents(events: NetEvent[] | ContractEvents): OPNetEvent<ContractDecodedObjectResult>[];
     decodeEvent(event: NetEvent): OPNetEvent;
     encodeCalldata(functionName: string, args: unknown[]): Buffer;
     currentGasParameters(): Promise<BlockGasParameters>;