opnet 1.0.19 → 1.0.20

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.18";
+export declare const version = "1.0.20";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.0.18';
+export const version = '1.0.20';

package/build/block/interfaces/BlockWitness.d.ts

@@ -0,0 +1,11 @@
+export interface IBlockWitnessAPI {
+    readonly trusted: boolean;
+    readonly signature: string;
+    readonly identity?: string;
+    readonly opnetPubKey?: string;
+}
+export interface IBlockWitness {
+    blockNumber: bigint | string;
+    readonly witnesses: IBlockWitnessAPI[];
+}
+export type BlockWitnesses = IBlockWitness[];

package/build/block/interfaces/BlockWitness.js

@@ -0,0 +1 @@
+export {};

package/build/contracts/Contract.d.ts

@@ -5,6 +5,7 @@ import { BaseContractProperties } from '../abi/interfaces/BaseContractProperties
 import { BitcoinInterfaceAbi } from '../abi/interfaces/BitcoinInterfaceAbi.js';
 import { BitcoinAddressLike, DecodedCallResult } from '../common/CommonTypes.js';
 import { AbstractRpcProvider } from '../providers/AbstractRpcProvider.js';
+import { ContractEvents } from '../transactions/interfaces/ITransactionReceipt.js';
 import { IContract } from './interfaces/IContract.js';
 import { OPNetEvent } from './OPNetEvent.js';
 declare const internal: unique symbol;
@@ -22,7 +23,8 @@ export declare abstract class IBaseContract<T extends BaseContractProperties> im
     readonly [internal]: keyof T | undefined;
     private events;
     protected constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider);
-    decodeEvents(events: NetEvent[]): OPNetEvent[];
+    decodeEvents(events: NetEvent[] | ContractEvents): OPNetEvent[];
+    decodeEvent(event: NetEvent): OPNetEvent;
     protected getFunction(name: symbol): BaseContractProperty | undefined | string | number | symbol;
     private defineInternalFunctions;
     private encodeFunctionData;

package/build/contracts/Contract.js

@@ -19,21 +19,28 @@ export class IBaseContract {
     }
     decodeEvents(events) {
         const decodedEvents = [];
-        for (let event of events) {
-            const eventData = this.events.get(event.eventType);
-            if (!eventData || eventData.values.length === 0) {
-                const decodedEvent = new OPNetEvent(event.eventType, event.eventDataSelector, event.eventData);
-                decodedEvents.push(decodedEvent);
-                continue;
+        if (!Array.isArray(events)) {
+            events = events[this.address.toString()];
+            if (!events) {
+                return [];
             }
-            const binaryReader = new BinaryReader(event.eventData);
-            const out = this.decodeOutput(eventData.values, binaryReader);
-            const decodedEvent = new OPNetEvent(event.eventType, event.eventDataSelector, event.eventData);
-            decodedEvent.setDecoded(out);
-            decodedEvents.push(decodedEvent);
+        }
+        for (let event of events) {
+            decodedEvents.push(this.decodeEvent(event));
         }
         return decodedEvents;
     }
+    decodeEvent(event) {
+        const eventData = this.events.get(event.eventType);
+        if (!eventData || eventData.values.length === 0) {
+            return new OPNetEvent(event.eventType, event.eventDataSelector, event.eventData);
+        }
+        const binaryReader = new BinaryReader(event.eventData);
+        const out = this.decodeOutput(eventData.values, binaryReader);
+        const decodedEvent = new OPNetEvent(event.eventType, event.eventDataSelector, event.eventData);
+        decodedEvent.setDecoded(out);
+        return decodedEvent;
+    }
     getFunction(name) {
         const key = name;
         return this[key];
@@ -178,7 +185,8 @@ export class IBaseContract {
     callFunction(element) {
         return async (...args) => {
             const data = this.encodeFunctionData(element, args);
-            const response = await this.provider.call(this.address, Buffer.from(data.getBuffer()));
+            const buffer = Buffer.from(data.getBuffer());
+            const response = await this.provider.call(this.address, buffer);
             if ('error' in response) {
                 return response;
             }

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

@@ -1,7 +1,9 @@
 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;
-    decodeEvents(events: NetEvent[]): OPNetEvent[];
+    decodeEvents(events: NetEvent[] | ContractEvents): OPNetEvent[];
+    decodeEvent(event: NetEvent): OPNetEvent;
 }

package/build/generator/WrappedGenerationParameters.d.ts

@@ -0,0 +1,9 @@
+import { GenerationConstraints, WrappedGenerationParameters } from '../providers/interfaces/Generate.js';
+export declare class WrappedGeneration implements WrappedGenerationParameters {
+    readonly constraints: GenerationConstraints;
+    readonly entities: string[];
+    readonly keys: string[];
+    readonly signature: string;
+    readonly vault: string;
+    constructor(params: WrappedGenerationParameters);
+}

package/build/generator/WrappedGenerationParameters.js

@@ -0,0 +1,14 @@
+export class WrappedGeneration {
+    constraints;
+    entities;
+    keys;
+    signature;
+    vault;
+    constructor(params) {
+        this.constraints = params.constraints;
+        this.entities = params.entities;
+        this.keys = params.keys;
+        this.signature = params.signature;
+        this.vault = params.vault;
+    }
+}

package/build/opnet.d.ts

@@ -9,7 +9,11 @@ export * from './transactions/TransactionOutput.js';
 export * from './providers/JSONRpcProvider.js';
 export * from './providers/AbstractRpcProvider.js';
 export * from './providers/WebsocketRpcProvider.js';
+export * from './providers/interfaces/Generate.js';
+export * from './providers/interfaces/ReorgInformation.js';
 export * from './block/Block.js';
+export * from './block/interfaces/IBlock.js';
+export * from './block/interfaces/BlockWitness.js';
 export * from './transactions/TransactionParser.js';
 export * from './contracts/ContractData.js';
 export * from './contracts/CallResult.js';
@@ -25,13 +29,14 @@ export * from './abi/BitcoinAbiTypes.js';
 export * from './abi/interfaces/BaseContractProperties.js';
 export * from './abi/BaseContractProperty.js';
 export * from './utils/BitcoinUtils.js';
+export * from './generator/WrappedGenerationParameters.js';
 export * from './storage/StoredValue.js';
 export * from './storage/interfaces/IStorageValue.js';
-export * from './block/interfaces/IBlock.js';
 export * from './transactions/interfaces/ITransaction.js';
 export * from './transactions/interfaces/ITransactionReceipt.js';
 export * from './transactions/TransactionReceipt.js';
 export * from './contracts/interfaces/IRawContract.js';
+export * from './transactions/interfaces/BroadcastedTransaction.js';
 export * from './common/CommonTypes.js';
 export * from './bitcoin/BitcoinAddress.js';
 export * from './bitcoin/UTXOs.js';

package/build/opnet.js

@@ -9,7 +9,11 @@ export * from './transactions/TransactionOutput.js';
 export * from './providers/JSONRpcProvider.js';
 export * from './providers/AbstractRpcProvider.js';
 export * from './providers/WebsocketRpcProvider.js';
+export * from './providers/interfaces/Generate.js';
+export * from './providers/interfaces/ReorgInformation.js';
 export * from './block/Block.js';
+export * from './block/interfaces/IBlock.js';
+export * from './block/interfaces/BlockWitness.js';
 export * from './transactions/TransactionParser.js';
 export * from './contracts/ContractData.js';
 export * from './contracts/CallResult.js';
@@ -25,13 +29,14 @@ export * from './abi/BitcoinAbiTypes.js';
 export * from './abi/interfaces/BaseContractProperties.js';
 export * from './abi/BaseContractProperty.js';
 export * from './utils/BitcoinUtils.js';
+export * from './generator/WrappedGenerationParameters.js';
 export * from './storage/StoredValue.js';
 export * from './storage/interfaces/IStorageValue.js';
-export * from './block/interfaces/IBlock.js';
 export * from './transactions/interfaces/ITransaction.js';
 export * from './transactions/interfaces/ITransactionReceipt.js';
 export * from './transactions/TransactionReceipt.js';
 export * from './contracts/interfaces/IRawContract.js';
+export * from './transactions/interfaces/BroadcastedTransaction.js';
 export * from './common/CommonTypes.js';
 export * from './bitcoin/BitcoinAddress.js';
 export * from './bitcoin/UTXOs.js';

package/build/providers/AbstractRpcProvider.d.ts

@@ -3,14 +3,18 @@ import '../serialize/BigInt.js';
 import { Network } from 'bitcoinjs-lib';
 import { BigNumberish, BlockTag, JsonRpcApiProvider } from 'ethers';
 import { Block } from '../block/Block.js';
+import { BlockWitnesses } from '../block/interfaces/BlockWitness.js';
 import { BitcoinAddressLike } from '../common/CommonTypes.js';
 import { CallResult } from '../contracts/CallResult.js';
 import { ContractData } from '../contracts/ContractData.js';
 import { ICallRequestError } from '../contracts/interfaces/ICallResult.js';
+import { WrappedGeneration } from '../generator/WrappedGenerationParameters.js';
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
 import { StoredValue } from '../storage/StoredValue.js';
+import { BroadcastedTransaction } from '../transactions/interfaces/BroadcastedTransaction.js';
 import { TransactionBase } from '../transactions/Transaction.js';
 import { TransactionReceipt } from '../transactions/TransactionReceipt.js';
+import { ReorgInformation } from './interfaces/ReorgInformation.js';
 export declare abstract class AbstractRpcProvider {
     protected abstract readonly provider: JsonRpcApiProvider;
     private nextId;
@@ -26,6 +30,10 @@ export declare abstract class AbstractRpcProvider {
     getCode(address: BitcoinAddressLike, onlyBytecode?: boolean): Promise<ContractData | Buffer>;
     getStorageAt(address: BitcoinAddressLike, rawPointer: bigint | string, proofs?: boolean, height?: BigNumberish): Promise<StoredValue>;
     call(to: BitcoinAddressLike, data: Buffer | string, from?: BitcoinAddressLike, height?: BigNumberish): Promise<CallResult | ICallRequestError>;
+    sendRawTransaction(tx: string, psbt: boolean): Promise<BroadcastedTransaction>;
+    getBlockWitness(height?: BigNumberish | -1, trusted?: boolean, limit?: number, page?: number): Promise<BlockWitnesses>;
+    getReorg(fromBlock?: BigNumberish, toBlock?: BigNumberish): Promise<ReorgInformation[]>;
+    requestTrustedPublicKeyForBitcoinWrapping(amount: BigNumberish): Promise<WrappedGeneration>;
     protected abstract providerUrl(url: string): string;
     private bufferToHex;
     private bigintToBase64;

package/build/providers/AbstractRpcProvider.js

@@ -5,9 +5,11 @@ import { UTXO } from '../bitcoin/UTXOs.js';
 import { Block } from '../block/Block.js';
 import { CallResult } from '../contracts/CallResult.js';
 import { ContractData } from '../contracts/ContractData.js';
+import { WrappedGeneration } from '../generator/WrappedGenerationParameters.js';
 import { StoredValue } from '../storage/StoredValue.js';
 import { TransactionParser } from '../transactions/TransactionParser.js';
 import { TransactionReceipt } from '../transactions/TransactionReceipt.js';
+import { GenerateTarget } from './interfaces/Generate.js';
 export class AbstractRpcProvider {
     nextId = 0;
     constructor() { }
@@ -126,6 +128,67 @@ export class AbstractRpcProvider {
         }
         return new CallResult(result);
     }
+    async sendRawTransaction(tx, psbt) {
+        if (!/^[0-9A-Fa-f]+$/.test(tx)) {
+            throw new Error('Invalid hex string');
+        }
+        const payload = this.buildJsonRpcPayload('btc_sendRawTransaction', [
+            tx,
+            psbt,
+        ]);
+        const rawTx = await this.callPayloadSingle(payload);
+        const result = rawTx.result;
+        if (result && result.identifier) {
+            return {
+                ...result,
+                identifier: BigInt(result.identifier),
+            };
+        }
+        return result;
+    }
+    async getBlockWitness(height = -1, trusted, limit, page) {
+        const params = [height.toString()];
+        if (trusted !== undefined && trusted !== null)
+            params.push(trusted);
+        if (limit !== undefined && limit !== null)
+            params.push(limit);
+        if (page !== undefined && page !== null)
+            params.push(page);
+        const payload = this.buildJsonRpcPayload('btc_blockWitness', params);
+        const rawWitnesses = await this.callPayloadSingle(payload);
+        const result = rawWitnesses.result;
+        for (let i = 0; i < result.length; i++) {
+            result[i].blockNumber = BigInt('0x' + result[i].blockNumber);
+        }
+        return result;
+    }
+    async getReorg(fromBlock, toBlock) {
+        const params = [];
+        if (fromBlock !== undefined && fromBlock !== null)
+            params.push(fromBlock.toString());
+        if (toBlock !== undefined && toBlock !== null)
+            params.push(toBlock.toString());
+        const payload = this.buildJsonRpcPayload('btc_reorg', params);
+        const rawReorg = await this.callPayloadSingle(payload);
+        const result = rawReorg.result;
+        if (result.length > 0) {
+            for (let i = 0; i < result.length; i++) {
+                const res = result[i];
+                res.fromBlock = BigInt('0x' + res.fromBlock);
+                res.toBlock = BigInt('0x' + res.toBlock);
+            }
+        }
+        return result;
+    }
+    async requestTrustedPublicKeyForBitcoinWrapping(amount) {
+        const payload = this.buildJsonRpcPayload('btc_generate', [
+            GenerateTarget.WRAP,
+            amount.toString(),
+        ]);
+        const rawPublicKey = await this.callPayloadSingle(payload);
+        const result = rawPublicKey.result;
+        return new WrappedGeneration(result);
+    }
     bufferToHex(buffer) {
         return buffer.toString('hex');
     }

package/build/providers/interfaces/Generate.d.ts

@@ -0,0 +1,19 @@
+export declare enum GenerateTarget {
+    WRAP = 0
+}
+export interface GenerationConstraints {
+    readonly timestamp: number;
+    readonly version: string;
+    readonly minimum: number;
+    readonly transactionMinimum: number;
+    readonly minimumValidatorTransactionGeneration: number;
+    readonly maximumValidatorPerTrustedEntities: number;
+}
+export interface WrappedGenerationParameters {
+    readonly keys: string[];
+    readonly vault: string;
+    readonly entities: string[];
+    readonly signature: string;
+    readonly constraints: GenerationConstraints;
+}
+export type GenerationParameters = WrappedGenerationParameters;

package/build/providers/interfaces/Generate.js

@@ -0,0 +1,4 @@
+export var GenerateTarget;
+(function (GenerateTarget) {
+    GenerateTarget[GenerateTarget["WRAP"] = 0] = "WRAP";
+})(GenerateTarget || (GenerateTarget = {}));

package/build/providers/interfaces/GenerateResult.js

@@ -0,0 +1 @@
+"use strict";

package/build/providers/interfaces/ReorgInformation.d.ts

@@ -0,0 +1,5 @@
+export interface ReorgInformation {
+    fromBlock: string | bigint;
+    toBlock: string | bigint;
+    readonly timestamp: number;
+}

package/build/providers/interfaces/ReorgInformation.js

@@ -0,0 +1 @@
+export {};

package/build/scripts/testMethods.js

@@ -3,8 +3,8 @@ import { JSONRpcProvider } from '../providers/JSONRpcProvider.js';
 import { TestContractABI } from './ITestContract.js';
 const provider = new JSONRpcProvider('http://localhost:9001');
 (async () => {
-    const transaction = await provider.getTransaction('af7a6001150b2b4ec7361515d3e5075c81d9f975c8ec22989db0a0c474c08418');
-    console.log('Transaction:', transaction);
+    const transaction = (await provider.getTransaction('af7a6001150b2b4ec7361515d3e5075c81d9f975c8ec22989db0a0c474c08418'));
+    console.log('Transaction:', transaction, transaction.calldata.toString('hex'));
     const receipt = await provider.getTransactionReceipt('af7a6001150b2b4ec7361515d3e5075c81d9f975c8ec22989db0a0c474c08418');
     console.log('Receipt:', receipt);
     const contract = getContract('bcrt1pyrs3eqwnrmd4ql3nwvx66yzp0wc24xd2t9pf8699ln340pjs7f3sar3tum', TestContractABI, provider);
@@ -13,8 +13,16 @@ const provider = new JSONRpcProvider('http://localhost:9001');
         console.log('No events');
     }
     else {
-        console.log('Events:', events);
+        console.log('Decoded Events:', receipt, events);
         const decodedEvents = contract.decodeEvents(events);
-        console.log('Decoded events:', decodedEvents);
+        console.log('Decoded Events:', decodedEvents);
     }
+    const callResult = await provider.call('bcrt1pyrs3eqwnrmd4ql3nwvx66yzp0wc24xd2t9pf8699ln340pjs7f3sar3tum', 'ed1470ec6263317065653831396563313361383462353830633934343431383966386237313131653466663335666263656336626534386638346237396137626362356300000000000000008146a1bb27e3b07c40f0209b9f876f80ad503ff71b893e44');
+    console.log('Call result:', callResult);
+    const blockWitness = await provider.getBlockWitness(398);
+    console.dir(blockWitness, { depth: 10, colors: true });
+    const reorgs = await provider.getReorg();
+    console.log('Reorgs:', reorgs);
+    const wrapParams = await provider.requestTrustedPublicKeyForBitcoinWrapping(1000n);
+    console.log('Wrap Params:', wrapParams);
 })();

package/build/transactions/TransactionReceipt.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="node" />
-import { NetEvent } from '@btc-vision/bsi-binary';
-import { ITransactionReceipt } from './interfaces/ITransactionReceipt.js';
+import { ContractEvents, ITransactionReceipt } from './interfaces/ITransactionReceipt.js';
 export declare class TransactionReceipt implements ITransactionReceipt {
     readonly receipt?: Buffer;
     readonly receiptProofs: string[];
-    readonly events: NetEvent[];
+    readonly events: ContractEvents;
     readonly revert?: Buffer;
     constructor(receipt: ITransactionReceipt);
     private parseEvents;
+    private decodeEvent;
 }

package/build/transactions/TransactionReceipt.js

@@ -9,26 +9,45 @@ export class TransactionReceipt {
             ? Buffer.from(receipt.receipt, 'base64')
             : undefined;
         this.receiptProofs = receipt.receiptProofs || [];
-        this.events = receipt.events ? this.parseEvents(receipt.events) : [];
+        this.events = receipt.events ? this.parseEvents(receipt.events) : {};
         this.revert = receipt.revert ? Buffer.from(receipt.revert, 'base64') : undefined;
     }
     parseEvents(events) {
-        return events.map((event) => {
-            let eventData;
-            let eventDataSelector;
-            if (typeof event.eventData === 'string') {
-                eventData = new Uint8Array(Buffer.from(event.eventData, 'base64'));
+        const parsedEvents = {};
+        if (!Array.isArray(events)) {
+            for (const [key, value] of Object.entries(events)) {
+                parsedEvents[key] = value.map((event) => {
+                    return this.decodeEvent(event);
+                });
             }
-            else {
-                eventData = event.eventData;
+        }
+        else {
+            for (const event of events) {
+                const parsedEvent = this.decodeEvent(event);
+                const contractAddress = event.contractAddress;
+                if (!parsedEvents[contractAddress]) {
+                    parsedEvents[contractAddress] = [];
+                }
+                parsedEvents[contractAddress].push(parsedEvent);
             }
-            if (typeof event.eventDataSelector === 'string') {
-                eventDataSelector = BigInt(event.eventDataSelector);
-            }
-            else {
-                eventDataSelector = event.eventDataSelector;
-            }
-            return new NetEvent(event.eventType, eventDataSelector, eventData);
-        });
+        }
+        return parsedEvents;
+    }
+    decodeEvent(event) {
+        let eventData;
+        let eventDataSelector;
+        if (typeof event.eventData === 'string') {
+            eventData = new Uint8Array(Buffer.from(event.eventData, 'base64'));
+        }
+        else {
+            eventData = event.eventData;
+        }
+        if (typeof event.eventDataSelector === 'string') {
+            eventDataSelector = BigInt(event.eventDataSelector);
+        }
+        else {
+            eventDataSelector = event.eventDataSelector;
+        }
+        return new NetEvent(event.eventType, eventDataSelector, eventData);
     }
 }

package/build/transactions/interfaces/BroadcastedTransaction.d.ts

@@ -0,0 +1,7 @@
+export interface BroadcastedTransaction {
+    readonly success: boolean;
+    readonly result?: string;
+    readonly error?: string;
+    readonly peers?: number;
+    readonly identifier: bigint | string;
+}

package/build/transactions/interfaces/BroadcastedTransaction.js

@@ -0,0 +1 @@
+export {};

package/build/transactions/interfaces/ITransaction.d.ts

@@ -1,10 +1,9 @@
 /// <reference types="node" />
-import { NetEvent } from '@btc-vision/bsi-binary';
 import { BigNumberish } from 'ethers';
 import { OPNetTransactionTypes } from '../../interfaces/opnet/OPNetTransactionTypes.js';
 import { ITransactionInput, TransactionInput } from '../TransactionInput.js';
 import { ITransactionOutput, TransactionOutput } from '../TransactionOutput.js';
-import { ITransactionReceipt } from './ITransactionReceipt.js';
+import { ContractEvents, ITransactionReceipt } from './ITransactionReceipt.js';
 export interface ITransactionBase<T extends OPNetTransactionTypes> extends ITransactionReceipt {
     readonly id: string;
     readonly hash: string;
@@ -36,7 +35,7 @@ export interface IInteractionTransaction extends ICommonTransaction<OPNetTransac
     readonly contractSecret: string | Buffer;
     readonly interactionPubKey: string | Buffer;
     readonly from: string;
-    readonly events: NetEvent[];
+    readonly events: ContractEvents;
     readonly receipt?: string | Buffer;
     readonly receiptProofs?: string[];
 }

package/build/transactions/interfaces/ITransactionReceipt.d.ts

@@ -1,13 +1,21 @@
 /// <reference types="node" />
 import { NetEvent } from '@btc-vision/bsi-binary';
 export interface NetEventDocument {
+    readonly contractAddress: string;
     readonly eventType: string;
     readonly eventDataSelector: string;
     readonly eventData: string;
 }
+export interface IRawContractEvents {
+    [key: string]: NetEventDocument[];
+}
+export type RawContractEvents = IRawContractEvents | NetEventDocument[];
+export interface ContractEvents {
+    [key: string]: NetEvent[];
+}
 export interface ITransactionReceipt {
     readonly receipt?: string | Buffer;
     readonly receiptProofs?: string[];
-    readonly events?: NetEventDocument[] | NetEvent[];
+    readonly events?: RawContractEvents | ContractEvents;
     readonly revert?: string | Buffer;
 }

package/cjs/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.12";
+export declare const version = "1.0.19";

package/cjs/_version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = '1.0.12';
+exports.version = '1.0.19';

package/cjs/abi/BitcoinInterface.d.ts

@@ -4,6 +4,7 @@ export declare class BitcoinInterface {
     constructor(abi: BitcoinInterfaceAbi);
     static from(abi: BitcoinInterface | BitcoinInterfaceAbi): BitcoinInterface;
     hasFunction(name: string): boolean;
+    hasEvent(name: string): boolean;
     private verifyAbi;
     private verifyAbiValues;
 }

package/cjs/abi/BitcoinInterface.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitcoinInterface = void 0;
+const BitcoinAbiTypes_js_1 = require("./BitcoinAbiTypes.js");
 class BitcoinInterface {
     abi;
     constructor(abi) {
@@ -14,7 +15,10 @@ class BitcoinInterface {
         return new BitcoinInterface(abi);
     }
     hasFunction(name) {
-        return this.abi.some((element) => element.name === name && element.type === 'function');
+        return this.abi.some((element) => element.name === name && element.type === BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function);
+    }
+    hasEvent(name) {
+        return this.abi.some((element) => element.name === name && element.type === BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event);
     }
     verifyAbi(abi) {
         if (abi.length === 0) {
@@ -28,10 +32,17 @@ class BitcoinInterface {
             if (!element.type) {
                 throw new Error('The ABI provided is missing a type.');
             }
-            if (element.inputs && element.inputs.length)
-                this.verifyAbiValues(element.inputs);
-            if (element.outputs && element.outputs.length)
-                this.verifyAbiValues(element.outputs);
+            if (element.type === BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function) {
+                if (element.inputs && element.inputs.length)
+                    this.verifyAbiValues(element.inputs);
+                if (element.outputs && element.outputs.length) {
+                    this.verifyAbiValues(element.outputs);
+                }
+            }
+            else if (element.type === BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event) {
+                if (element.values && element.values.length)
+                    this.verifyAbiValues(element.values);
+            }
         }
     }
     verifyAbiValues(inputs) {

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

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

package/cjs/abi/interfaces/BitcoinInterfaceAbi.d.ts

@@ -1,11 +1,16 @@
 import { BitcoinAbiTypes } from '../BitcoinAbiTypes.js';
 import { BitcoinAbiValue } from './BitcoinAbiValue.js';
-export interface BitcoinInterfaceAbiBase {
-    readonly constant?: boolean;
+export interface BitcoinInterfaceAbiBase<T extends BitcoinAbiTypes> {
     readonly name: string;
+    readonly type: T;
+}
+export interface FunctionBaseData extends BitcoinInterfaceAbiBase<BitcoinAbiTypes.Function> {
+    readonly constant?: boolean;
+    readonly payable?: boolean;
     readonly inputs?: BitcoinAbiValue[];
     readonly outputs?: BitcoinAbiValue[];
-    readonly type: BitcoinAbiTypes;
-    readonly payable?: boolean;
 }
-export type BitcoinInterfaceAbi = BitcoinInterfaceAbiBase[];
+export interface EventBaseData extends BitcoinInterfaceAbiBase<BitcoinAbiTypes.Event> {
+    readonly values: BitcoinAbiValue[];
+}
+export type BitcoinInterfaceAbi = (FunctionBaseData | EventBaseData)[];

package/cjs/bitcoin/UTXOs.d.ts

@@ -1,10 +1,5 @@
 import { ScriptPubKey } from '@btc-vision/bsi-bitcoin-rpc';
-export interface IUTXO {
-    readonly transactionId: string;
-    readonly outputIndex: number;
-    readonly value: bigint | string;
-    readonly scriptPubKey: ScriptPubKey;
-}
+import { IUTXO } from './interfaces/IUTXO.js';
 export declare class UTXO implements IUTXO {
     readonly transactionId: string;
     readonly outputIndex: number;

package/cjs/bitcoin/interfaces/IUTXO.d.ts

@@ -0,0 +1,7 @@
+import { ScriptPubKey } from '@btc-vision/bsi-bitcoin-rpc';
+export interface IUTXO {
+    readonly transactionId: string;
+    readonly outputIndex: number;
+    readonly value: bigint | string;
+    readonly scriptPubKey: ScriptPubKey;
+}

package/cjs/bitcoin/interfaces/IUTXO.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });