opnet 1.0.21 → 1.0.22

package/build/transactions/decoders/GenericTransaction.js

@@ -0,0 +1,6 @@
+import { TransactionBase } from '../Transaction.js';
+export class GenericTransaction extends TransactionBase {
+    constructor(transaction) {
+        super(transaction);
+    }
+}

package/build/transactions/decoders/InteractionTransaction.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+import { InteractionType } from '../../interfaces/opnet/OPNetTransactionTypes.js';
+import { IInteractionTransaction } from '../interfaces/transactions/IInteractionTransaction.js';
+import { TransactionBase } from '../Transaction.js';
+export declare class InteractionTransaction extends TransactionBase<InteractionType> implements IInteractionTransaction {
+    readonly calldata: Buffer;
+    readonly senderPubKeyHash: Buffer;
+    readonly contractSecret: Buffer;
+    readonly interactionPubKey: Buffer;
+    readonly wasCompressed: boolean;
+    readonly from: string;
+    readonly contractAddress: string;
+    constructor(transaction: IInteractionTransaction);
+}

package/build/transactions/decoders/InteractionTransaction.js

@@ -0,0 +1,21 @@
+import { Buffer } from 'buffer';
+import { TransactionBase } from '../Transaction.js';
+export class InteractionTransaction extends TransactionBase {
+    calldata;
+    senderPubKeyHash;
+    contractSecret;
+    interactionPubKey;
+    wasCompressed;
+    from;
+    contractAddress;
+    constructor(transaction) {
+        super(transaction);
+        this.calldata = Buffer.from(transaction.calldata, 'base64');
+        this.senderPubKeyHash = Buffer.from(transaction.senderPubKeyHash, 'base64');
+        this.contractSecret = Buffer.from(transaction.contractSecret, 'base64');
+        this.interactionPubKey = Buffer.from(transaction.interactionPubKey, 'base64');
+        this.wasCompressed = transaction.wasCompressed;
+        this.from = transaction.from;
+        this.contractAddress = transaction.contractAddress;
+    }
+}

package/build/transactions/decoders/WrapInteractionTransaction.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+import { OPNetTransactionTypes } from '../../interfaces/opnet/OPNetTransactionTypes.js';
+import { IInteractionTransaction } from '../interfaces/ITransaction.js';
+import { TransactionBase } from '../Transaction.js';
+export declare class InteractionTransaction extends TransactionBase<OPNetTransactionTypes.Interaction> implements IInteractionTransaction {
+    readonly calldata: Buffer;
+    readonly senderPubKeyHash: Buffer;
+    readonly contractSecret: Buffer;
+    readonly interactionPubKey: Buffer;
+    readonly wasCompressed: boolean;
+    readonly from: string;
+    readonly contractAddress: string;
+    constructor(transaction: IInteractionTransaction);
+}

package/build/transactions/decoders/WrapInteractionTransaction.js

@@ -0,0 +1,21 @@
+import { Buffer } from 'buffer';
+import { TransactionBase } from '../Transaction.js';
+export class InteractionTransaction extends TransactionBase {
+    calldata;
+    senderPubKeyHash;
+    contractSecret;
+    interactionPubKey;
+    wasCompressed;
+    from;
+    contractAddress;
+    constructor(transaction) {
+        super(transaction);
+        this.calldata = Buffer.from(transaction.calldata, 'base64');
+        this.senderPubKeyHash = Buffer.from(transaction.senderPubKeyHash, 'base64');
+        this.contractSecret = Buffer.from(transaction.contractSecret, 'base64');
+        this.interactionPubKey = Buffer.from(transaction.interactionPubKey, 'base64');
+        this.wasCompressed = transaction.wasCompressed;
+        this.from = transaction.from;
+        this.contractAddress = transaction.contractAddress;
+    }
+}

package/build/transactions/decoders/WrapTransaction.d.ts

@@ -0,0 +1,15 @@
+import { EcKeyPair } from '@btc-vision/transaction';
+import { Network } from 'bitcoinjs-lib';
+import { IWrapTransaction } from '../interfaces/transactions/IWrapTransaction.js';
+import { InteractionTransaction } from './InteractionTransaction.js';
+export declare class WrapTransaction extends InteractionTransaction implements IWrapTransaction {
+    readonly penalized: boolean;
+    readonly wrappingFees: bigint | string;
+    readonly depositAmount: bigint | string;
+    readonly depositAddress: string;
+    readonly vault: string;
+    readonly pubKeys: string[];
+    readonly minimumSignatures: number;
+    constructor(transaction: IWrapTransaction);
+    parsedTrustedKeys(trustedKeys: string[], network: Network): EcKeyPair[];
+}

package/build/transactions/decoders/WrapTransaction.js

@@ -0,0 +1,30 @@
+import { EcKeyPair } from '@btc-vision/transaction';
+import { InteractionTransaction } from './InteractionTransaction.js';
+export class WrapTransaction extends InteractionTransaction {
+    penalized;
+    wrappingFees;
+    depositAmount;
+    depositAddress;
+    vault;
+    pubKeys;
+    minimumSignatures;
+    constructor(transaction) {
+        super(transaction);
+        this.penalized = transaction.penalized;
+        this.wrappingFees = BigInt(transaction.wrappingFees || '0x00') || 0n;
+        this.depositAmount = BigInt(transaction.depositAmount || '0x00') || 0n;
+        this.depositAddress = transaction.depositAddress;
+        this.vault = transaction.vault;
+        this.pubKeys = transaction.pubKeys;
+        this.minimumSignatures = transaction.minimumSignatures;
+    }
+    parsedTrustedKeys(trustedKeys, network) {
+        if (!trustedKeys) {
+            return [];
+        }
+        return trustedKeys.map((key) => {
+            const buffer = Buffer.from(key, 'base64');
+            return EcKeyPair.fromPublicKey(buffer, network);
+        });
+    }
+}

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

@@ -1,9 +1,12 @@
 /// <reference types="node" />
 import { BigNumberish } from 'ethers';
 import { OPNetTransactionTypes } from '../../interfaces/opnet/OPNetTransactionTypes.js';
-import { ITransactionInput, TransactionInput } from '../TransactionInput.js';
-import { ITransactionOutput, TransactionOutput } from '../TransactionOutput.js';
-import { ContractEvents, ITransactionReceipt } from './ITransactionReceipt.js';
+import { ITransactionInput, TransactionInput } from '../metadata/TransactionInput.js';
+import { ITransactionOutput, TransactionOutput } from '../metadata/TransactionOutput.js';
+import { ITransactionReceipt } from './ITransactionReceipt.js';
+import { IDeploymentTransaction } from './transactions/IDeploymentTransaction.js';
+import { IInteractionTransaction } from './transactions/IInteractionTransaction.js';
+import { IWrapTransaction } from './transactions/IWrapTransaction.js';
 export interface ITransactionBase<T extends OPNetTransactionTypes> extends ITransactionReceipt {
     readonly id: string;
     readonly hash: string;
@@ -13,30 +16,8 @@ export interface ITransactionBase<T extends OPNetTransactionTypes> extends ITran
     readonly inputs: ITransactionInput[] | TransactionInput[];
     readonly outputs: ITransactionOutput[] | TransactionOutput[];
     readonly OPNetType: T;
+    readonly gasUsed: string | bigint;
 }
 export interface IGenericTransaction extends ITransactionBase<OPNetTransactionTypes.Generic> {
 }
-export interface ICommonTransaction<T extends OPNetTransactionTypes> extends ITransactionBase<T> {
-    readonly from: string;
-    readonly contractAddress: string;
-    readonly wasCompressed: boolean;
-}
-export interface IDeploymentTransaction extends ICommonTransaction<OPNetTransactionTypes.Deployment> {
-    readonly virtualAddress: string;
-    readonly bytecode: Buffer | string;
-    readonly deployerPubKey: Buffer | string;
-    readonly deployerAddress: string;
-    readonly contractSeed: Buffer | string;
-    readonly contractSaltHash: Buffer | string;
-}
-export interface IInteractionTransaction extends ICommonTransaction<OPNetTransactionTypes.Interaction> {
-    readonly calldata: string | Buffer;
-    readonly senderPubKeyHash: string | Buffer;
-    readonly contractSecret: string | Buffer;
-    readonly interactionPubKey: string | Buffer;
-    readonly from: string;
-    readonly events: ContractEvents;
-    readonly receipt?: string | Buffer;
-    readonly receiptProofs?: string[];
-}
-export type ITransaction = IDeploymentTransaction | IInteractionTransaction | IGenericTransaction;
+export type ITransaction = IDeploymentTransaction | IInteractionTransaction | IGenericTransaction | IWrapTransaction;

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

@@ -0,0 +1,3 @@
+import { IInteractionTransaction } from './ITransaction.js';
+export interface IWrapTransaction extends IInteractionTransaction {
+}

package/build/transactions/interfaces/IWrapTransaction.js

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

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

@@ -0,0 +1,7 @@
+import { OPNetTransactionTypes } from '../../../interfaces/opnet/OPNetTransactionTypes.js';
+import { ITransactionBase } from '../ITransaction.js';
+export interface ICommonTransaction<T extends OPNetTransactionTypes> extends ITransactionBase<T> {
+    readonly from: string;
+    readonly contractAddress: string;
+    readonly wasCompressed: boolean;
+}

package/build/transactions/interfaces/transactions/ICommonTransaction.js

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

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { OPNetTransactionTypes } from '../../../interfaces/opnet/OPNetTransactionTypes.js';
+import { ICommonTransaction } from './ICommonTransaction.js';
+export interface IDeploymentTransaction extends ICommonTransaction<OPNetTransactionTypes.Deployment> {
+    readonly contractAddress: string;
+    readonly p2trAddress: string;
+    readonly virtualAddress: string;
+    readonly bytecode: Buffer | string;
+    readonly deployerPubKey: Buffer | string;
+    readonly deployerAddress: string;
+    readonly contractSeed: Buffer | string;
+    readonly contractSaltHash: Buffer | string;
+}

package/build/transactions/interfaces/transactions/IDeploymentTransaction.js

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

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

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { InteractionType } from '../../../interfaces/opnet/OPNetTransactionTypes.js';
+import { ContractEvents } from '../ITransactionReceipt.js';
+import { ICommonTransaction } from './ICommonTransaction.js';
+export interface IInteractionTransaction extends ICommonTransaction<InteractionType> {
+    readonly calldata: string | Buffer;
+    readonly senderPubKeyHash: string | Buffer;
+    readonly contractSecret: string | Buffer;
+    readonly interactionPubKey: string | Buffer;
+    readonly from: string;
+    readonly events: ContractEvents;
+    readonly receipt?: string | Buffer;
+    readonly receiptProofs?: string[];
+}

package/build/transactions/interfaces/transactions/IInteractionTransaction.js

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

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

@@ -0,0 +1,10 @@
+import { IInteractionTransaction } from './IInteractionTransaction.js';
+export interface IWrapTransaction extends IInteractionTransaction {
+    readonly penalized: boolean;
+    readonly wrappingFees: bigint | string;
+    readonly depositAmount: bigint | string;
+    readonly depositAddress: string;
+    readonly vault: string;
+    readonly pubKeys: string[];
+    readonly minimumSignatures: number;
+}

package/build/transactions/interfaces/transactions/IWrapTransaction.js

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

package/build/transactions/metadata/TransactionInput.d.ts

@@ -0,0 +1,16 @@
+import { ScriptSig } from '@btc-vision/bsi-bitcoin-rpc';
+export interface ITransactionInput {
+    readonly originalTransactionId: string | undefined;
+    readonly outputTransactionIndex: number | undefined;
+    readonly scriptSignature: ScriptSig | undefined;
+    readonly sequenceId: number;
+    readonly transactionInWitness?: string[];
+}
+export declare class TransactionInput implements ITransactionInput {
+    readonly originalTransactionId: string | undefined;
+    readonly outputTransactionIndex: number | undefined;
+    readonly scriptSignature: ScriptSig | undefined;
+    readonly sequenceId: number;
+    readonly transactionInWitness: string[];
+    constructor(data: ITransactionInput);
+}

package/build/transactions/metadata/TransactionInput.js

@@ -0,0 +1,14 @@
+export class TransactionInput {
+    originalTransactionId;
+    outputTransactionIndex;
+    scriptSignature;
+    sequenceId;
+    transactionInWitness = [];
+    constructor(data) {
+        this.originalTransactionId = data.originalTransactionId;
+        this.outputTransactionIndex = data.outputTransactionIndex;
+        this.scriptSignature = data.scriptSignature;
+        this.sequenceId = data.sequenceId;
+        this.transactionInWitness = data.transactionInWitness || [];
+    }
+}

package/build/transactions/metadata/TransactionOutput.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { ScriptPubKey } from '@btc-vision/bsi-bitcoin-rpc';
+export interface ITransactionOutput {
+    readonly index: number;
+    readonly scriptPubKey: {
+        hex: string;
+        addresses?: string[];
+        address?: string;
+    };
+    readonly value: string;
+}
+export declare class TransactionOutput {
+    readonly value: bigint;
+    readonly index: number;
+    readonly scriptPubKey: ScriptPubKey;
+    readonly script: Array<number | Buffer> | null;
+    constructor(data: ITransactionOutput);
+    private convertValue;
+}

package/build/transactions/metadata/TransactionOutput.js

@@ -0,0 +1,16 @@
+import { script } from 'bitcoinjs-lib';
+export class TransactionOutput {
+    value;
+    index;
+    scriptPubKey;
+    script;
+    constructor(data) {
+        this.value = this.convertValue(data.value);
+        this.index = data.index;
+        this.scriptPubKey = data.scriptPubKey;
+        this.script = script.decompile(Buffer.from(this.scriptPubKey.hex, 'hex'));
+    }
+    convertValue(value) {
+        return BigInt(value);
+    }
+}

package/build/transactions/metadata/TransactionReceipt.d.ts

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

package/build/transactions/metadata/TransactionReceipt.js

@@ -0,0 +1,53 @@
+import { NetEvent } from '@btc-vision/bsi-binary';
+export class TransactionReceipt {
+    receipt;
+    receiptProofs;
+    events;
+    revert;
+    constructor(receipt) {
+        this.receipt = receipt.receipt
+            ? Buffer.from(receipt.receipt, 'base64')
+            : undefined;
+        this.receiptProofs = receipt.receiptProofs || [];
+        this.events = receipt.events ? this.parseEvents(receipt.events) : {};
+        this.revert = receipt.revert ? Buffer.from(receipt.revert, 'base64') : undefined;
+    }
+    parseEvents(events) {
+        const parsedEvents = {};
+        if (!Array.isArray(events)) {
+            for (const [key, value] of Object.entries(events)) {
+                parsedEvents[key] = value.map((event) => {
+                    return this.decodeEvent(event);
+                });
+            }
+        }
+        else {
+            for (const event of events) {
+                const parsedEvent = this.decodeEvent(event);
+                const contractAddress = event.contractAddress;
+                if (!parsedEvents[contractAddress]) {
+                    parsedEvents[contractAddress] = [];
+                }
+                parsedEvents[contractAddress].push(parsedEvent);
+            }
+        }
+        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/types/DeploymentTransaction.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
+import { IDeploymentTransaction } from './interfaces/ITransaction.js';
+import { TransactionBase } from './Transaction.js';
+export declare class DeploymentTransaction extends TransactionBase<OPNetTransactionTypes.Deployment> implements IDeploymentTransaction {
+    readonly contractAddress: string;
+    readonly virtualAddress: string;
+    readonly bytecode: Buffer;
+    readonly wasCompressed: boolean;
+    readonly deployerPubKey: Buffer;
+    readonly deployerAddress: string;
+    readonly contractSeed: Buffer;
+    readonly contractSaltHash: Buffer;
+    readonly from: string;
+    constructor(transaction: IDeploymentTransaction);
+}

package/build/transactions/types/DeploymentTransaction.js

@@ -0,0 +1,24 @@
+import { TransactionBase } from './Transaction.js';
+export class DeploymentTransaction extends TransactionBase {
+    contractAddress;
+    virtualAddress;
+    bytecode;
+    wasCompressed;
+    deployerPubKey;
+    deployerAddress;
+    contractSeed;
+    contractSaltHash;
+    from;
+    constructor(transaction) {
+        super(transaction);
+        this.from = transaction.from;
+        this.contractAddress = transaction.contractAddress;
+        this.virtualAddress = transaction.virtualAddress;
+        this.bytecode = Buffer.from(transaction.bytecode, 'base64');
+        this.wasCompressed = transaction.wasCompressed;
+        this.deployerPubKey = Buffer.from(transaction.deployerPubKey, 'base64');
+        this.deployerAddress = transaction.deployerAddress;
+        this.contractSeed = Buffer.from(transaction.contractSeed, 'base64');
+        this.contractSaltHash = Buffer.from(transaction.contractSaltHash, 'base64');
+    }
+}

package/build/transactions/types/GenericTransaction.d.ts

@@ -0,0 +1,6 @@
+import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
+import { IGenericTransaction } from './interfaces/ITransaction.js';
+import { TransactionBase } from './Transaction.js';
+export declare class GenericTransaction extends TransactionBase<OPNetTransactionTypes.Generic> implements IGenericTransaction {
+    constructor(transaction: IGenericTransaction);
+}

package/build/transactions/types/GenericTransaction.js

@@ -0,0 +1,6 @@
+import { TransactionBase } from './Transaction.js';
+export class GenericTransaction extends TransactionBase {
+    constructor(transaction) {
+        super(transaction);
+    }
+}

package/build/transactions/types/InteractionTransaction.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
+import { IInteractionTransaction } from './interfaces/ITransaction.js';
+import { TransactionBase } from './Transaction.js';
+export declare class InteractionTransaction extends TransactionBase<OPNetTransactionTypes.Interaction> implements IInteractionTransaction {
+    readonly calldata: Buffer;
+    readonly senderPubKeyHash: Buffer;
+    readonly contractSecret: Buffer;
+    readonly interactionPubKey: Buffer;
+    readonly wasCompressed: boolean;
+    readonly from: string;
+    readonly contractAddress: string;
+    constructor(transaction: IInteractionTransaction);
+}

package/build/transactions/types/InteractionTransaction.js

@@ -0,0 +1,21 @@
+import { Buffer } from 'buffer';
+import { TransactionBase } from './Transaction.js';
+export class InteractionTransaction extends TransactionBase {
+    calldata;
+    senderPubKeyHash;
+    contractSecret;
+    interactionPubKey;
+    wasCompressed;
+    from;
+    contractAddress;
+    constructor(transaction) {
+        super(transaction);
+        this.calldata = Buffer.from(transaction.calldata, 'base64');
+        this.senderPubKeyHash = Buffer.from(transaction.senderPubKeyHash, 'base64');
+        this.contractSecret = Buffer.from(transaction.contractSecret, 'base64');
+        this.interactionPubKey = Buffer.from(transaction.interactionPubKey, 'base64');
+        this.wasCompressed = transaction.wasCompressed;
+        this.from = transaction.from;
+        this.contractAddress = transaction.contractAddress;
+    }
+}

package/cjs/_version.d.ts

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

package/cjs/_version.js

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

package/cjs/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/cjs/block/interfaces/BlockWitness.js

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

package/cjs/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/cjs/contracts/Contract.js

@@ -22,21 +22,28 @@ 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_js_1.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 bsi_binary_1.BinaryReader(event.eventData);
-            const out = this.decodeOutput(eventData.values, binaryReader);
-            const decodedEvent = new OPNetEvent_js_1.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_js_1.OPNetEvent(event.eventType, event.eventDataSelector, event.eventData);
+        }
+        const binaryReader = new bsi_binary_1.BinaryReader(event.eventData);
+        const out = this.decodeOutput(eventData.values, binaryReader);
+        const decodedEvent = new OPNetEvent_js_1.OPNetEvent(event.eventType, event.eventDataSelector, event.eventData);
+        decodedEvent.setDecoded(out);
+        return decodedEvent;
+    }
     getFunction(name) {
         const key = name;
         return this[key];
@@ -182,7 +189,6 @@ class IBaseContract {
         return async (...args) => {
             const data = this.encodeFunctionData(element, args);
             const buffer = Buffer.from(data.getBuffer());
-            console.log(buffer.toString('hex'));
             const response = await this.provider.call(this.address, buffer);
             if ('error' in response) {
                 return response;

package/cjs/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/cjs/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/cjs/generator/WrappedGenerationParameters.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrappedGeneration = void 0;
+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;
+    }
+}
+exports.WrappedGeneration = WrappedGeneration;