opnet 1.0.39 → 1.0.40

package/cjs/abi/shared/json/STAKING_ABI.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STAKING_ABI = exports.StackingEvents = void 0;
+const bsi_binary_1 = require("@btc-vision/bsi-binary");
+const BitcoinAbiTypes_js_1 = require("../../BitcoinAbiTypes.js");
+exports.StackingEvents = [
+    {
+        name: 'Stake',
+        values: [
+            {
+                name: 'amount',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event,
+    },
+    {
+        name: 'Unstake',
+        values: [
+            {
+                name: 'amount',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event,
+    },
+    {
+        name: 'Claim',
+        values: [
+            {
+                name: 'amount',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event,
+    },
+];
+exports.STAKING_ABI = [
+    {
+        name: 'stake',
+        inputs: [
+            {
+                name: 'amount',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        outputs: [
+            {
+                name: 'success',
+                type: bsi_binary_1.ABIDataTypes.BOOL,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    {
+        name: 'unstake',
+        inputs: [],
+        outputs: [
+            {
+                name: 'success',
+                type: bsi_binary_1.ABIDataTypes.BOOL,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    {
+        name: 'stakedAmount',
+        inputs: [
+            {
+                name: 'address',
+                type: bsi_binary_1.ABIDataTypes.ADDRESS,
+            },
+        ],
+        outputs: [
+            {
+                name: 'amount',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    {
+        name: 'stakedReward',
+        inputs: [
+            {
+                name: 'address',
+                type: bsi_binary_1.ABIDataTypes.ADDRESS,
+            },
+        ],
+        outputs: [
+            {
+                name: 'amount',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    {
+        name: 'claim',
+        inputs: [],
+        outputs: [
+            {
+                name: 'success',
+                type: bsi_binary_1.ABIDataTypes.BOOL,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    {
+        name: 'rewardPool',
+        inputs: [],
+        outputs: [
+            {
+                name: 'reward',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    {
+        name: 'totalStaked',
+        inputs: [],
+        outputs: [
+            {
+                name: 'total',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    ...exports.StackingEvents,
+];

package/cjs/abi/shared/json/WBTC_ABI.d.ts

@@ -0,0 +1,3 @@
+import { BitcoinInterfaceAbi } from '../../interfaces/BitcoinInterfaceAbi.js';
+export declare const WBTCEvents: BitcoinInterfaceAbi;
+export declare const WBTC_ABI: BitcoinInterfaceAbi;

package/cjs/abi/shared/json/WBTC_ABI.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WBTC_ABI = exports.WBTCEvents = void 0;
+const bsi_binary_1 = require("@btc-vision/bsi-binary");
+const BitcoinAbiTypes_js_1 = require("../../BitcoinAbiTypes.js");
+const OP_20_ABI_js_1 = require("./OP_20_ABI.js");
+const STAKING_ABI_js_1 = require("./STAKING_ABI.js");
+exports.WBTCEvents = [
+    {
+        name: 'WithdrawalRequest',
+        values: [
+            {
+                name: 'address',
+                type: bsi_binary_1.ABIDataTypes.ADDRESS,
+            },
+            {
+                name: 'amount',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event,
+    },
+];
+exports.WBTC_ABI = [
+    {
+        name: 'requestWithdrawal',
+        inputs: [
+            {
+                name: 'amount',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        outputs: [
+            {
+                name: 'success',
+                type: bsi_binary_1.ABIDataTypes.BOOL,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    {
+        name: 'withdrawableBalanceOf',
+        inputs: [
+            {
+                name: 'address',
+                type: bsi_binary_1.ABIDataTypes.ADDRESS,
+            },
+        ],
+        outputs: [
+            {
+                name: 'balance',
+                type: bsi_binary_1.ABIDataTypes.UINT256,
+            },
+        ],
+        type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+    },
+    ...exports.WBTCEvents,
+    ...STAKING_ABI_js_1.STAKING_ABI,
+    ...OP_20_ABI_js_1.OP_20_ABI,
+];

package/cjs/common/CommonTypes.d.ts

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

package/cjs/contracts/CallResult.d.ts

@@ -1,15 +1,19 @@
+/// <reference types="node" />
 import { BinaryReader, NetEvent } from '@btc-vision/bsi-binary';
 import { DecodedCallResult } from '../common/CommonTypes.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 ICallResultData {
+export declare class CallResult<T extends ContractDecodedObjectResult = {}> implements Omit<ICallResultData, 'estimatedGas'> {
     readonly result: BinaryReader;
     readonly events: NetEvent[];
     readonly accessList: IAccessList;
+    calldata: Buffer | undefined;
+    readonly estimatedGas: bigint | undefined;
     readonly decoded: Array<DecodedCallResult>;
     properties: T;
-    constructor(iCallResult: ICallResultData);
+    constructor(callResult: ICallResultData);
     setDecoded(decoded: DecodedOutput): void;
+    setCalldata(calldata: Buffer): void;
     private base64ToUint8Array;
 }

package/cjs/contracts/CallResult.js

@@ -6,20 +6,28 @@ class CallResult {
     result;
     events;
     accessList;
+    calldata;
+    estimatedGas;
     decoded = [];
     properties = {};
-    constructor(iCallResult) {
-        this.events = iCallResult.events;
-        this.accessList = iCallResult.accessList;
+    constructor(callResult) {
+        this.events = callResult.events;
+        this.accessList = callResult.accessList;
+        if (callResult.estimatedGas) {
+            this.estimatedGas = BigInt(callResult.estimatedGas);
+        }
         this.result =
-            typeof iCallResult.result === 'string'
-                ? new bsi_binary_1.BinaryReader(this.base64ToUint8Array(iCallResult.result))
-                : iCallResult.result;
+            typeof callResult.result === 'string'
+                ? new bsi_binary_1.BinaryReader(this.base64ToUint8Array(callResult.result))
+                : callResult.result;
     }
     setDecoded(decoded) {
         this.properties = Object.freeze(decoded.obj);
         this.decoded.push(...decoded.values);
     }
+    setCalldata(calldata) {
+        this.calldata = calldata;
+    }
     base64ToUint8Array(base64) {
         return bsi_binary_1.BufferHelper.bufferToUint8Array(Buffer.from(base64, 'base64'));
     }

package/cjs/contracts/Contract.d.ts

@@ -1,4 +1,5 @@
-import { NetEvent } from '@btc-vision/bsi-binary';
+/// <reference types="node" />
+import { Address, NetEvent } from '@btc-vision/bsi-binary';
 import { BaseContractProperty } from '../abi/BaseContractProperty.js';
 import { BitcoinInterface } from '../abi/BitcoinInterface.js';
 import { BaseContractProperties } from '../abi/interfaces/BaseContractProperties.js';
@@ -20,11 +21,14 @@ export declare abstract class IBaseContract<T extends BaseContractProperties> im
     readonly address: BitcoinAddressLike;
     readonly interface: BitcoinInterface;
     readonly provider: AbstractRpcProvider;
+    from?: Address;
     readonly [internal]: keyof T | undefined;
     private events;
-    protected constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider);
+    protected constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, from?: Address);
+    setSender(sender: Address): void;
     decodeEvents(events: NetEvent[] | ContractEvents): OPNetEvent[];
     decodeEvent(event: NetEvent): OPNetEvent;
+    encodeCalldata(functionName: string, args: unknown[]): Buffer;
     protected getFunction(name: symbol): BaseContractProperty | undefined | string | number | symbol;
     private defineInternalFunctions;
     private encodeFunctionData;
@@ -33,8 +37,8 @@ export declare abstract class IBaseContract<T extends BaseContractProperties> im
     private callFunction;
 }
 export declare class BaseContract<T extends BaseContractProperties> extends IBaseContract<T> {
-    constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider);
+    constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, sender?: Address);
     private proxify;
 }
-export declare function getContract<T extends BaseContractProperties>(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider): BaseContract<T> & Omit<T, keyof BaseContract<T>>;
+export declare function getContract<T extends BaseContractProperties>(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider, sender?: Address): BaseContract<T> & Omit<T, keyof BaseContract<T>>;
 export {};

package/cjs/contracts/Contract.js

@@ -11,15 +11,20 @@ class IBaseContract {
     address;
     interface;
     provider;
+    from;
     [internal];
     events = new Map();
-    constructor(address, abi, provider) {
+    constructor(address, abi, provider, from) {
         this.address = address;
         this.provider = provider;
         this.interface = BitcoinInterface_js_1.BitcoinInterface.from(abi);
+        this.from = from;
         Object.defineProperty(this, internal, { value: {} });
         this.defineInternalFunctions();
     }
+    setSender(sender) {
+        this.from = sender;
+    }
     decodeEvents(events) {
         const decodedEvents = [];
         if (!Array.isArray(events)) {
@@ -44,6 +49,15 @@ class IBaseContract {
         decodedEvent.setDecoded(out);
         return decodedEvent;
     }
+    encodeCalldata(functionName, args) {
+        for (const element of this.interface.abi) {
+            if (element.name === functionName) {
+                const data = this.encodeFunctionData(element, args);
+                return Buffer.from(data.getBuffer());
+            }
+        }
+        throw new Error(`Function not found: ${functionName}`);
+    }
     getFunction(name) {
         const key = name;
         return this[key];
@@ -51,16 +65,24 @@ class IBaseContract {
     defineInternalFunctions() {
         for (const element of this.interface.abi) {
             switch (element.type) {
-                case BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function:
+                case BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function: {
+                    if (this[element.name]) {
+                        throw new Error(`Duplicate function found in the ABI: ${element.name}.`);
+                    }
                     Object.defineProperty(this, element.name, {
                         value: this.callFunction(element).bind(this),
                     });
                     break;
-                case BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event:
+                }
+                case BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event: {
+                    if (this.events.has(element.name)) {
+                        throw new Error(`Duplicate event found in the ABI: ${element.name}.`);
+                    }
                     this.events.set(element.name, element);
                     break;
+                }
                 default:
-                    break;
+                    throw new Error(`Unsupported type.`);
             }
         }
     }
@@ -83,60 +105,147 @@ class IBaseContract {
         const type = abi.type;
         const name = abi.name;
         switch (type) {
-            case bsi_binary_1.ABIDataTypes.UINT256:
+            case bsi_binary_1.ABIDataTypes.UINT256: {
                 if (typeof value !== 'bigint') {
                     throw new Error(`Expected value to be of type bigint (${name})`);
                 }
                 writer.writeU256(value);
                 break;
-            case bsi_binary_1.ABIDataTypes.BOOL:
+            }
+            case bsi_binary_1.ABIDataTypes.BOOL: {
                 if (typeof value !== 'boolean') {
                     throw new Error(`Expected value to be of type boolean (${name})`);
                 }
                 writer.writeBoolean(value);
                 break;
-            case bsi_binary_1.ABIDataTypes.STRING:
+            }
+            case bsi_binary_1.ABIDataTypes.STRING: {
                 if (typeof value !== 'string') {
                     throw new Error(`Expected value to be of type string (${name})`);
                 }
                 writer.writeStringWithLength(value);
                 break;
-            case bsi_binary_1.ABIDataTypes.ADDRESS:
+            }
+            case bsi_binary_1.ABIDataTypes.ADDRESS: {
                 const address = value;
                 writer.writeAddress(address.toString());
                 break;
-            case bsi_binary_1.ABIDataTypes.TUPLE:
+            }
+            case bsi_binary_1.ABIDataTypes.TUPLE: {
                 if (!(value instanceof Array)) {
                     throw new Error(`Expected value to be of type Array (${name})`);
                 }
                 writer.writeTuple(value);
                 break;
-            case bsi_binary_1.ABIDataTypes.UINT8:
+            }
+            case bsi_binary_1.ABIDataTypes.UINT8: {
                 if (typeof value !== 'number') {
                     throw new Error(`Expected value to be of type number (${name})`);
                 }
                 writer.writeU8(value);
                 break;
-            case bsi_binary_1.ABIDataTypes.UINT16:
+            }
+            case bsi_binary_1.ABIDataTypes.UINT16: {
                 if (typeof value !== 'number') {
                     throw new Error(`Expected value to be of type number (${name})`);
                 }
                 writer.writeU16(value);
                 break;
-            case bsi_binary_1.ABIDataTypes.UINT32:
+            }
+            case bsi_binary_1.ABIDataTypes.UINT32: {
                 if (typeof value !== 'number') {
                     throw new Error(`Expected value to be of type number (${name})`);
                 }
                 writer.writeU32(value);
                 break;
-            case bsi_binary_1.ABIDataTypes.BYTES32:
+            }
+            case bsi_binary_1.ABIDataTypes.BYTES32: {
                 if (!(value instanceof Uint8Array)) {
                     throw new Error(`Expected value to be of type Uint8Array (${name})`);
                 }
                 writer.writeBytes(value);
                 break;
-            default:
+            }
+            case bsi_binary_1.ABIDataTypes.ADDRESS_UINT256_TUPLE: {
+                if (!(value instanceof Map)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeAddressValueTupleMap(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.BYTES: {
+                if (!(value instanceof Uint8Array)) {
+                    throw new Error(`Expected value to be of type Uint8Array (${name})`);
+                }
+                writer.writeBytesWithLength(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.UINT64: {
+                if (typeof value !== 'bigint') {
+                    throw new Error(`Expected value to be of type bigint (${name})`);
+                }
+                writer.writeU64(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.ARRAY_OF_ADDRESSES: {
+                if (!(value instanceof Array)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeAddressArray(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT256: {
+                if (!(value instanceof Array)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeU256Array(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT32: {
+                if (!(value instanceof Array)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeU32Array(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.ARRAY_OF_STRING: {
+                if (!(value instanceof Array)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeStringArray(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.ARRAY_OF_BYTES: {
+                if (!(value instanceof Array)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeBytesArray(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT64: {
+                if (!(value instanceof Array)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeU64Array(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT8: {
+                if (!(value instanceof Array)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeU8Array(value);
+                break;
+            }
+            case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT16: {
+                if (!(value instanceof Array)) {
+                    throw new Error(`Expected value to be of type Array (${name})`);
+                }
+                writer.writeU16Array(value);
+                break;
+            }
+            default: {
                 throw new Error(`Unsupported type: ${type} (${name})`);
+            }
         }
     }
     decodeOutput(abi, reader) {
@@ -174,6 +283,49 @@ class IBaseContract {
                 case bsi_binary_1.ABIDataTypes.BYTES32:
                     decodedResult = reader.readBytes(32);
                     break;
+                case bsi_binary_1.ABIDataTypes.ADDRESS_UINT256_TUPLE:
+                    decodedResult = reader.readAddressValueTuple();
+                    break;
+                case bsi_binary_1.ABIDataTypes.BYTES: {
+                    decodedResult = reader.readBytesWithLength();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.UINT64: {
+                    decodedResult = reader.readU64();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.ARRAY_OF_ADDRESSES: {
+                    decodedResult = reader.readAddressArray();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT256: {
+                    decodedResult = reader.readU256Array();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT32: {
+                    decodedResult = reader.readU32Array();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.ARRAY_OF_STRING: {
+                    decodedResult = reader.readStringArray();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.ARRAY_OF_BYTES: {
+                    decodedResult = reader.readBytesArray();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT64: {
+                    decodedResult = reader.readU64Array();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT8: {
+                    decodedResult = reader.readU8Array();
+                    break;
+                }
+                case bsi_binary_1.ABIDataTypes.ARRAY_OF_UINT16: {
+                    decodedResult = reader.readU16Array();
+                    break;
+                }
                 default:
                     throw new Error(`Unsupported type: ${type} (${name})`);
             }
@@ -189,7 +341,7 @@ class IBaseContract {
         return async (...args) => {
             const data = this.encodeFunctionData(element, args);
             const buffer = Buffer.from(data.getBuffer());
-            const response = await this.provider.call(this.address, buffer);
+            const response = await this.provider.call(this.address, buffer, this.from);
             if ('error' in response) {
                 return response;
             }
@@ -197,14 +349,15 @@ class IBaseContract {
                 ? this.decodeOutput(element.outputs, response.result)
                 : { values: [], obj: {} };
             response.setDecoded(decoded);
+            response.setCalldata(buffer);
             return response;
         };
     }
 }
 exports.IBaseContract = IBaseContract;
 class BaseContract extends IBaseContract {
-    constructor(address, abi, provider) {
-        super(address, abi, provider);
+    constructor(address, abi, provider, sender) {
+        super(address, abi, provider, sender);
         return this.proxify();
     }
     proxify() {
@@ -238,8 +391,8 @@ exports.BaseContract = BaseContract;
 function contractBase() {
     return BaseContract;
 }
-function getContract(address, abi, provider) {
+function getContract(address, abi, provider, sender) {
     const base = contractBase();
-    return new base(address, abi, provider);
+    return new base(address, abi, provider, sender);
 }
 exports.getContract = getContract;

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

@@ -7,5 +7,6 @@ export interface ICallResultData {
     readonly result: string | BinaryReader;
     readonly events: NetEvent[];
     readonly accessList: IAccessList;
+    readonly estimatedGas?: string;
 }
 export type ICallResult = ICallRequestError | ICallResultData;

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

@@ -1,9 +1,12 @@
+/// <reference types="node" />
 import { NetEvent } from '@btc-vision/bsi-binary';
 import { BitcoinAddressLike } from '../../common/CommonTypes.js';
 import { ContractEvents } from '../../transactions/interfaces/ITransactionReceipt.js';
 import { OPNetEvent } from '../OPNetEvent.js';
 export interface IContract {
     readonly address: BitcoinAddressLike;
+    setSender(sender: BitcoinAddressLike): void;
     decodeEvents(events: NetEvent[] | ContractEvents): OPNetEvent[];
     decodeEvent(event: NetEvent): OPNetEvent;
+    encodeCalldata(method: string, ...args: unknown[]): Buffer;
 }

package/cjs/opnet.d.ts

@@ -45,8 +45,26 @@ export * from './providers/interfaces/JSONRpc.js';
 export * from './providers/interfaces/JSONRpcMethods.js';
 export * from './providers/interfaces/JSONRpcParams.js';
 export * from './providers/interfaces/JSONRpcResult.js';
+export * from './transactions/decoders/UnwrapTransaction.js';
+export * from './transactions/interfaces/transactions/IUnwrapTransaction.js';
 export * from './common/CommonTypes.js';
 export * from './bitcoin/BitcoinAddress.js';
 export * from './bitcoin/UTXOs.js';
 export * from './bitcoin/interfaces/IUTXO.js';
 export { ABIDataTypes } from '@btc-vision/bsi-binary';
+export * from './abi/shared/json/OP_20_ABI.js';
+export * from './abi/shared/json/OP_NET_ABI.js';
+export * from './abi/shared/json/WBTC_ABI.js';
+export * from './abi/shared/json/STAKING_ABI.js';
+export * from './abi/shared/json/MOTOSWAP_FACTORY_ABI.js';
+export * from './abi/shared/json/MOTO_TOKEN_ABI.js';
+export * from './abi/shared/json/MOTOSWAP_POOL_ABI.js';
+export * from './abi/shared/json/MOTOSWAP_ROUTER_ABI.js';
+export * from './abi/shared/interfaces/IOP_20Contract.js';
+export * from './abi/shared/interfaces/IOP_NETContract.js';
+export * from './abi/shared/interfaces/IWBTCContract.js';
+export * from './abi/shared/interfaces/IStackingContract.js';
+export * from './abi/shared/interfaces/IMotoswapFactoryContract.js';
+export * from './abi/shared/interfaces/IMotoContract.js';
+export * from './abi/shared/interfaces/IMotoswapPoolContract.js';
+export * from './abi/shared/interfaces/IMotoswapRouterContract.js';