opnet 1.0.62 → 1.1.0

package/browser/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.62";
+export declare const version = "1.1.0";

package/browser/abi/interfaces/BaseContractProperties.d.ts

@@ -1,5 +1,5 @@
+import { CallResult } from '../../contracts/CallResult.js';
 import { IContract } from '../../contracts/interfaces/IContract.js';
-import { BaseContractProperty } from '../BaseContractProperty.js';
 export interface BaseContractProperties extends IContract {
-    [key: symbol]: BaseContractProperty;
+    [key: symbol]: CallResult;
 }

package/browser/abi/interfaces/BitcoinAbiValue.d.ts

@@ -1,4 +1,4 @@
-import { ABIDataTypes } from '@btc-vision/bsi-binary';
+import { ABIDataTypes } from '@btc-vision/transaction';
 export interface BitcoinAbiValue {
     name: string;
     type: ABIDataTypes;

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

@@ -1,7 +1,7 @@
-import { Address } from '@btc-vision/bsi-binary';
-import { BaseContractProperty } from '../../BaseContractProperty.js';
+import { Address } from '@btc-vision/transaction';
+import { CallResult } from '../../../contracts/CallResult.js';
 import { IOP_NETContract } from './IOP_NETContract.js';
 export interface IMotoswapFactoryContract extends IOP_NETContract {
-    getPool(token0: Address, token1: Address): Promise<BaseContractProperty>;
-    createPool(token0: Address, token1: Address): Promise<BaseContractProperty>;
+    getPool(token0: Address, token1: Address): Promise<CallResult>;
+    createPool(token0: Address, token1: Address): Promise<CallResult>;
 }

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

@@ -1,13 +1,13 @@
-import { Address } from '@btc-vision/bsi-binary';
-import { BaseContractProperty } from '../../BaseContractProperty.js';
+import { Address } from '@btc-vision/transaction';
+import { CallResult } from '../../../contracts/CallResult.js';
 import { IOP_20Contract } from './IOP_20Contract.js';
 export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mint'> {
-    token0(): Promise<BaseContractProperty>;
-    token1(): Promise<BaseContractProperty>;
-    getReserves(): Promise<BaseContractProperty>;
-    swap(amount0Out: bigint, amount1Out: bigint, to: string, data: Uint8Array): Promise<BaseContractProperty>;
-    burn(to: Address): Promise<BaseContractProperty>;
-    sync(): Promise<BaseContractProperty>;
-    price0CumulativeLast(): Promise<BaseContractProperty>;
-    price1CumulativeLast(): Promise<BaseContractProperty>;
+    token0(): Promise<CallResult>;
+    token1(): Promise<CallResult>;
+    getReserves(): Promise<CallResult>;
+    swap(amount0Out: bigint, amount1Out: bigint, to: string, data: Uint8Array): Promise<CallResult>;
+    burn(to: Address): Promise<CallResult>;
+    sync(): Promise<CallResult>;
+    price0CumulativeLast(): Promise<CallResult>;
+    price1CumulativeLast(): Promise<CallResult>;
 }

package/browser/abi/shared/interfaces/IMotoswapRouterContract.d.ts

@@ -1,15 +1,15 @@
-import { Address } from '@btc-vision/bsi-binary';
-import { BaseContractProperty } from '../../BaseContractProperty.js';
+import { Address } from '@btc-vision/transaction';
+import { CallResult } from '../../../contracts/CallResult.js';
 import { IOP_NETContract } from './IOP_NETContract.js';
 export interface IMotoswapRouterContract extends IOP_NETContract {
-    addLiquidity(tokenA: Address, tokenB: Address, amountADesired: bigint, amountBDesired: bigint, amountAMin: bigint, amountBMin: bigint, to: Address, deadline: bigint): Promise<BaseContractProperty>;
-    removeLiquidity(tokenA: Address, tokenB: Address, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: Address, deadline: bigint): Promise<BaseContractProperty>;
-    quote(amountA: bigint, reserveA: bigint, reserveB: bigint): Promise<BaseContractProperty>;
-    getAmountOut(amountIn: bigint, reserveIn: bigint, reserveOut: bigint): Promise<BaseContractProperty>;
-    getAmountIn(amountOut: bigint, reserveIn: bigint, reserveOut: bigint): Promise<BaseContractProperty>;
-    getAmountsOut(amountIn: bigint, path: Address[]): Promise<BaseContractProperty>;
-    getAmountsIn(amountOut: bigint, path: Address[]): Promise<BaseContractProperty>;
-    swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: bigint, amountOutMin: bigint, path: Address[], to: Address, deadline: bigint): Promise<BaseContractProperty>;
-    factory(): Promise<BaseContractProperty>;
-    WBTC(): Promise<BaseContractProperty>;
+    addLiquidity(tokenA: Address, tokenB: Address, amountADesired: bigint, amountBDesired: bigint, amountAMin: bigint, amountBMin: bigint, to: Address, deadline: bigint): Promise<CallResult>;
+    removeLiquidity(tokenA: Address, tokenB: Address, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: Address, deadline: bigint): Promise<CallResult>;
+    quote(amountA: bigint, reserveA: bigint, reserveB: bigint): Promise<CallResult>;
+    getAmountOut(amountIn: bigint, reserveIn: bigint, reserveOut: bigint): Promise<CallResult>;
+    getAmountIn(amountOut: bigint, reserveIn: bigint, reserveOut: bigint): Promise<CallResult>;
+    getAmountsOut(amountIn: bigint, path: Address[]): Promise<CallResult>;
+    getAmountsIn(amountOut: bigint, path: Address[]): Promise<CallResult>;
+    swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: bigint, amountOutMin: bigint, path: Address[], to: Address, deadline: bigint): Promise<CallResult>;
+    factory(): Promise<CallResult>;
+    WBTC(): Promise<CallResult>;
 }

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

@@ -1,16 +1,61 @@
-import { BitcoinAddressLike } from '../../../common/CommonTypes.js';
-import { BaseContractProperty } from '../../BaseContractProperty.js';
+import { Address, AddressMap } from '@btc-vision/transaction';
+import { CallResult } from '../../../contracts/CallResult.js';
 import { IOP_NETContract } from './IOP_NETContract.js';
+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<{
+    maxSupply: bigint;
+}>;
+export type Decimals = CallResult<{
+    decimals: bigint;
+}>;
+export type Transfer = CallResult<{
+    success: boolean;
+}>;
+export type TransferFrom = CallResult<{
+    success: boolean;
+}>;
+export type Approve = CallResult<{
+    success: boolean;
+}>;
+export type Allowance = CallResult<{
+    allowance: bigint;
+}>;
+export type Burn = CallResult<{
+    success: boolean;
+}>;
+export type Mint = CallResult<{
+    success: boolean;
+}>;
+export type Airdrop = CallResult<{
+    success: boolean;
+}>;
+export type AirdropWithAmount = CallResult<{
+    success: boolean;
+}>;
 export interface IOP_20Contract extends IOP_NETContract {
-    balanceOf(address: BitcoinAddressLike): Promise<BaseContractProperty>;
-    name(): Promise<BaseContractProperty>;
-    symbol(): Promise<BaseContractProperty>;
-    totalSupply(): Promise<BaseContractProperty>;
-    decimals(): Promise<BaseContractProperty>;
-    transfer(to: BitcoinAddressLike, value: bigint): Promise<BaseContractProperty>;
-    transferFrom(from: BitcoinAddressLike, to: BitcoinAddressLike, value: bigint): Promise<BaseContractProperty>;
-    approve(spender: BitcoinAddressLike, value: bigint): Promise<BaseContractProperty>;
-    allowance(owner: BitcoinAddressLike, spender: BitcoinAddressLike): Promise<BaseContractProperty>;
-    mint(to: BitcoinAddressLike, value: bigint): Promise<BaseContractProperty>;
-    burn(to: BitcoinAddressLike, value: bigint): Promise<BaseContractProperty>;
+    balanceOf(account: Address): Promise<BalanceOf>;
+    name(): Promise<Name>;
+    symbol(): Promise<SymbolOf>;
+    totalSupply(): Promise<TotalSupply>;
+    maxSupply(): Promise<MaxSupply>;
+    decimals(): Promise<Decimals>;
+    transfer(recipient: Address, amount: bigint): Promise<Transfer>;
+    transferFrom(sender: Address, recipient: Address, amount: bigint): Promise<TransferFrom>;
+    approve(spender: Address, amount: bigint): Promise<Approve>;
+    allowance(owner: Address, spender: Address): Promise<Allowance>;
+    burn(value: bigint): Promise<Burn>;
+    mint(value: bigint): Promise<Mint>;
+    airdrop(tuple: AddressMap<bigint>): Promise<Airdrop>;
+    airdropWithAmount(amount: bigint, addresses: Address[]): Promise<AirdropWithAmount>;
 }

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

@@ -1,7 +1,7 @@
-import { BitcoinAddressLike } from '../../../common/CommonTypes.js';
-import { BaseContractProperty } from '../../BaseContractProperty.js';
+import { Address } from '@btc-vision/transaction';
+import { CallResult } from '../../../contracts/CallResult.js';
 import { BaseContractProperties } from '../../interfaces/BaseContractProperties.js';
 export interface IOP_NETContract extends BaseContractProperties {
-    owner(): Promise<BaseContractProperty>;
-    isAddressOwner(address: BitcoinAddressLike): Promise<BaseContractProperty>;
+    owner(): Promise<CallResult>;
+    isAddressOwner(address: Address): Promise<CallResult>;
 }

package/browser/abi/shared/interfaces/IStackingContract.d.ts

@@ -1,4 +1,4 @@
-import { Address } from '@btc-vision/bsi-binary';
+import { Address } from '@btc-vision/transaction';
 import { BaseContractProperties } from '../../interfaces/BaseContractProperties.js';
 export interface IStackingContract {
     stake(amount: bigint): Promise<BaseContractProperties>;

package/browser/abi/shared/interfaces/IWBTCContract.d.ts

@@ -1,8 +1,8 @@
-import { BaseContractProperty } from '../../BaseContractProperty.js';
+import { CallResult } from '../../../contracts/CallResult.js';
 import { IOP_20Contract } from './IOP_20Contract.js';
 import { IStackingContract } from './IStackingContract.js';
 export type MergedOP_20AndStackingContract = IOP_20Contract & IStackingContract;
 export interface IWBTCContract extends MergedOP_20AndStackingContract {
-    requestWithdrawal(amount: bigint): Promise<BaseContractProperty>;
-    withdrawableBalanceOf(address: string): Promise<BaseContractProperty>;
+    requestWithdrawal(amount: bigint): Promise<CallResult>;
+    withdrawableBalanceOf(address: string): Promise<CallResult>;
 }

package/browser/common/CommonTypes.d.ts

@@ -1,8 +1,6 @@
-import { Address } from '@btc-vision/bsi-binary';
-import { BitcoinAddress } from '../bitcoin/BitcoinAddress.js';
-export type BitcoinAddressLike = string | BitcoinAddress;
+import { Address, AddressMap } from '@btc-vision/transaction';
 export type PointerLike = bigint | string;
-export type DecodedCallResult = bigint | string | boolean | number | Uint8Array | Array<bigint> | Array<string> | Array<boolean> | Array<number> | Array<Uint8Array> | Map<Address, bigint>;
+export type DecodedCallResult = bigint | string | boolean | number | Address | Uint8Array | Array<bigint> | Array<string> | Array<boolean> | Array<number> | Array<Uint8Array> | AddressMap<bigint>;
 export type Numeric = number | bigint;
 export type BigNumberish = Numeric | string;
 export type BlockTag = BigNumberish | string;

package/browser/contracts/CallResult.d.ts

@@ -1,19 +1,45 @@
-import { BinaryReader, NetEvent } from '@btc-vision/bsi-binary';
+import { BinaryReader, UTXO } from '@btc-vision/transaction';
+import { Network, Signer } from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
 import { DecodedCallResult } from '../common/CommonTypes.js';
+import { AbstractRpcProvider } from '../providers/AbstractRpcProvider.js';
 import { ContractDecodedObjectResult, DecodedOutput } from './Contract.js';
 import { IAccessList } from './interfaces/IAccessList.js';
-import { ICallResultData } from './interfaces/ICallResult.js';
-export declare class CallResult<T extends ContractDecodedObjectResult = {}> implements Omit<ICallResultData, 'estimatedGas'> {
+import { EventList, ICallResultData } from './interfaces/ICallResult.js';
+import { OPNetEvent } from './OPNetEvent.js';
+export interface TransactionParameters {
+    readonly signer: Signer | ECPairInterface;
+    readonly refundTo: string;
+    readonly priorityFee?: bigint;
+    readonly feeRate?: number;
+    readonly utxos?: UTXO[];
+    readonly maximumAllowedSatToSpend: bigint;
+    readonly network: Network;
+}
+export interface InteractionTransactionReceipt {
+    readonly transactionId: string;
+    readonly newUTXOs: UTXO[];
+    readonly peerAcknowledgements: number;
+}
+export declare class CallResult<T extends ContractDecodedObjectResult = {}> implements Omit<ICallResultData, 'estimatedGas' | 'events'> {
+    #private;
     readonly result: BinaryReader;
-    readonly events: NetEvent[];
     readonly accessList: IAccessList;
     readonly revert: string | undefined;
     calldata: Buffer | undefined;
     readonly estimatedGas: bigint | undefined;
     readonly decoded: Array<DecodedCallResult>;
     properties: T;
-    constructor(callResult: ICallResultData);
+    estimatedSatGas: bigint;
+    events: OPNetEvent[];
+    to: string | undefined;
+    constructor(callResult: ICallResultData, provider: AbstractRpcProvider);
+    get rawEvents(): EventList;
+    setTo(to: string): void;
+    sendTransaction(interactionParams: TransactionParameters): Promise<InteractionTransactionReceipt>;
+    setGasEstimation(estimatedGas: bigint): void;
     setDecoded(decoded: DecodedOutput): void;
     setCalldata(calldata: Buffer): void;
+    private parseEvents;
     private base64ToUint8Array;
 }

package/browser/contracts/Contract.d.ts

@@ -1,11 +1,13 @@
-import { Address, NetEvent } from '@btc-vision/bsi-binary';
-import { BaseContractProperty } from '../abi/BaseContractProperty.js';
+import { Address, NetEvent } from '@btc-vision/transaction';
+import { Network } from 'bitcoinjs-lib';
 import { BitcoinInterface } from '../abi/BitcoinInterface.js';
 import { BaseContractProperties } from '../abi/interfaces/BaseContractProperties.js';
 import { BitcoinInterfaceAbi } from '../abi/interfaces/BitcoinInterfaceAbi.js';
-import { BitcoinAddressLike, DecodedCallResult } from '../common/CommonTypes.js';
+import { BlockGasParameters } from '../block/BlockGasParameters.js';
+import { DecodedCallResult } from '../common/CommonTypes.js';
 import { AbstractRpcProvider } from '../providers/AbstractRpcProvider.js';
 import { ContractEvents } from '../transactions/interfaces/ITransactionReceipt.js';
+import { CallResult } from './CallResult.js';
 import { IContract } from './interfaces/IContract.js';
 import { OPNetEvent } from './OPNetEvent.js';
 declare const internal: unique symbol;
@@ -17,27 +19,34 @@ export type DecodedOutput = {
     obj: ContractDecodedObjectResult;
 };
 export declare abstract class IBaseContract<T extends BaseContractProperties> implements IContract {
-    readonly address: BitcoinAddressLike;
+    readonly address: string | Address;
+    readonly network: Network;
     readonly interface: BitcoinInterface;
     readonly provider: AbstractRpcProvider;
     from?: Address;
     readonly [internal]: keyof T | undefined;
     private events;
-    protected constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, from?: Address);
+    private gasParameters;
+    private readonly fetchGasParametersAfter;
+    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[];
     decodeEvent(event: NetEvent): OPNetEvent;
     encodeCalldata(functionName: string, args: unknown[]): Buffer;
-    protected getFunction(name: symbol | string): BaseContractProperty | undefined | string | number | symbol | ((functionName: string, args: unknown[]) => Buffer);
+    currentGasParameters(): Promise<BlockGasParameters>;
+    protected getFunction(name: symbol | string): CallResult | undefined | string | number | symbol | Address | Network | (() => Promise<BlockGasParameters>) | ((functionName: string, args: unknown[]) => Buffer);
     private defineInternalFunctions;
     private encodeFunctionData;
     private encodeInput;
     private decodeOutput;
+    private estimateGas;
+    private max;
     private callFunction;
 }
 export declare class BaseContract<T extends BaseContractProperties> extends IBaseContract<T> {
-    constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, sender?: Address);
+    constructor(address: string | Address, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, network: Network, sender?: Address);
     private proxify;
 }
-export declare function getContract<T extends BaseContractProperties>(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, sender?: Address): BaseContract<T> & Omit<T, keyof BaseContract<T>>;
+export declare function getContract<T extends BaseContractProperties>(address: string | Address, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, network: Network, sender?: Address): BaseContract<T> & Omit<T, keyof BaseContract<T>>;
 export {};

package/browser/contracts/ContractData.d.ts

@@ -1,4 +1,4 @@
-import { Address } from '@btc-vision/bsi-binary';
+import { Address } from '@btc-vision/transaction';
 import { IRawContract } from './interfaces/IRawContract.js';
 export declare class ContractData implements IRawContract {
     readonly contractAddress: Address;

package/browser/contracts/OPNetEvent.d.ts

@@ -1,4 +1,4 @@
-import { NetEvent } from '@btc-vision/bsi-binary';
+import { NetEvent } from '@btc-vision/transaction';
 import { DecodedCallResult } from '../common/CommonTypes.js';
 import { ContractDecodedObjectResult, DecodedOutput } from './Contract.js';
 export interface IDecodedEvent extends NetEvent {
@@ -6,10 +6,9 @@ export interface IDecodedEvent extends NetEvent {
 }
 export declare class OPNetEvent<T extends ContractDecodedObjectResult = {}> extends NetEvent implements IDecodedEvent {
     readonly eventType: string;
-    readonly eventDataSelector: bigint;
     readonly eventData: Uint8Array;
     properties: T;
     values: Array<DecodedCallResult>;
-    constructor(eventType: string, eventDataSelector: bigint, eventData: Uint8Array);
+    constructor(eventType: string, eventData: Uint8Array);
     setDecoded(decoded: DecodedOutput): void;
 }

package/browser/contracts/interfaces/ICallResult.d.ts

@@ -1,11 +1,21 @@
-import { BinaryReader, NetEvent } from '@btc-vision/bsi-binary';
+import { BinaryReader, NetEvent } from '@btc-vision/transaction';
 import { IAccessList } from './IAccessList.js';
 export interface ICallRequestError {
     readonly error: string;
 }
+export interface RawNetEvent {
+    readonly eventType: string;
+    readonly eventData: string;
+}
+export interface RawEventList {
+    readonly [key: string]: RawNetEvent[];
+}
+export interface EventList {
+    [key: string]: NetEvent[];
+}
 export interface ICallResultData {
     readonly result: string | BinaryReader;
-    readonly events: NetEvent[];
+    readonly events: RawEventList;
     readonly accessList: IAccessList;
     readonly revert?: string;
     readonly estimatedGas?: string;

package/browser/contracts/interfaces/IContract.d.ts

@@ -1,10 +1,12 @@
-import { NetEvent } from '@btc-vision/bsi-binary';
-import { BitcoinAddressLike } from '../../common/CommonTypes.js';
+import { Address, NetEvent } from '@btc-vision/transaction';
+import { BlockGasParameters } from '../../block/BlockGasParameters.js';
 import { ContractEvents } from '../../transactions/interfaces/ITransactionReceipt.js';
 import { OPNetEvent } from '../OPNetEvent.js';
 export interface IContract {
-    readonly address: BitcoinAddressLike;
-    setSender(sender: BitcoinAddressLike): void;
+    readonly address: Address | string;
+    get p2trOrTweaked(): string;
+    currentGasParameters(): Promise<BlockGasParameters>;
+    setSender(sender: Address): void;
     decodeEvents(events: NetEvent[] | ContractEvents): OPNetEvent[];
     decodeEvent(event: NetEvent): OPNetEvent;
     encodeCalldata(method: string, ...args: unknown[]): Buffer;

package/browser/contracts/interfaces/IRawContract.d.ts

@@ -1,4 +1,4 @@
-import { Address } from '@btc-vision/bsi-binary';
+import { Address } from '@btc-vision/transaction';
 export interface IRawContract {
     readonly contractAddress: Address;
     readonly virtualAddress: Address;