opnet 1.0.13 → 1.0.15

package/cjs/providers/AbstractRpcProvider.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRpcProvider = void 0;
+require("../serialize/BigInt.js");
+const bsi_binary_1 = require("@btc-vision/bsi-binary");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const UTXOs_js_1 = require("../bitcoin/UTXOs.js");
+const Block_js_1 = require("../block/Block.js");
+const CallResult_js_1 = require("../contracts/CallResult.js");
+const ContractData_js_1 = require("../contracts/ContractData.js");
+const StoredValue_js_1 = require("../storage/StoredValue.js");
+const TransactionParser_js_1 = require("../transactions/TransactionParser.js");
+const TransactionReceipt_js_1 = require("../transactions/TransactionReceipt.js");
+class AbstractRpcProvider {
+    nextId = 0;
+    constructor() { }
+    async getBlockNumber() {
+        return await this.provider.getBlockNumber();
+    }
+    async getBlock(blockNumberOrHash, prefetchTxs = false) {
+        const method = typeof blockNumberOrHash === 'string' ? 'btc_getBlockByHash' : 'btc_getBlockByNumber';
+        const payload = this.buildJsonRpcPayload(method, [
+            blockNumberOrHash,
+            prefetchTxs,
+        ]);
+        const block = await this.callPayloadSingle(payload);
+        const result = block.result;
+        return new Block_js_1.Block(result);
+    }
+    async getBlockByHash(blockHash) {
+        return await this.getBlock(blockHash);
+    }
+    async getBalance(addressLike) {
+        const address = addressLike.toString();
+        const payload = this.buildJsonRpcPayload('btc_getBalance', [address]);
+        const rawBalance = await this.callPayloadSingle(payload);
+        const result = rawBalance.result;
+        if (!result || (result && !result.startsWith('0x'))) {
+            throw new Error(`Invalid balance returned from provider: ${result}`);
+        }
+        return BigInt(result);
+    }
+    async getUXTOs(address, optimize = false) {
+        const addressStr = address.toString();
+        const payload = this.buildJsonRpcPayload('btc_getUTXOs', [
+            addressStr,
+            optimize,
+        ]);
+        const rawUXTOs = await this.callPayloadSingle(payload);
+        const result = rawUXTOs.result || [];
+        return result.map((utxo) => {
+            return new UTXOs_js_1.UTXO(utxo);
+        });
+    }
+    async getTransaction(txHash) {
+        const payload = this.buildJsonRpcPayload('btc_getTransactionByHash', [
+            txHash,
+        ]);
+        const rawTransaction = await this.callPayloadSingle(payload);
+        const result = rawTransaction.result;
+        return TransactionParser_js_1.TransactionParser.parseTransaction(result);
+    }
+    async getTransactionReceipt(txHash) {
+        const payload = this.buildJsonRpcPayload('btc_getTransactionReceipt', [
+            txHash,
+        ]);
+        const rawTransaction = await this.callPayloadSingle(payload);
+        return new TransactionReceipt_js_1.TransactionReceipt(rawTransaction.result);
+    }
+    async getNetwork() {
+        const network = await this.provider.getNetwork();
+        switch (network.chainId) {
+            case 1n:
+                return bitcoinjs_lib_1.networks.bitcoin;
+            case 2n:
+                return bitcoinjs_lib_1.networks.testnet;
+            case 3n:
+                return bitcoinjs_lib_1.networks.regtest;
+            default:
+                throw new Error(`Invalid chain id: ${network.chainId}`);
+        }
+    }
+    async getCode(address, onlyBytecode = false) {
+        const addressStr = address.toString();
+        const payload = this.buildJsonRpcPayload('btc_getCode', [
+            addressStr,
+            onlyBytecode,
+        ]);
+        const rawCode = await this.callPayloadSingle(payload);
+        const result = rawCode.result;
+        if ('contractAddress' in result) {
+            return new ContractData_js_1.ContractData(result);
+        }
+        else {
+            return Buffer.from(result.bytecode, 'base64');
+        }
+    }
+    async getStorageAt(address, rawPointer, proofs = true, height) {
+        const addressStr = address.toString();
+        const pointer = typeof rawPointer === 'string' ? rawPointer : this.bigintToBase64(rawPointer);
+        const params = [addressStr, pointer, proofs];
+        if (height) {
+            params.push(height.toString());
+        }
+        const payload = this.buildJsonRpcPayload('btc_getStorageAt', params);
+        const rawStorage = await this.callPayloadSingle(payload);
+        const result = rawStorage.result;
+        return new StoredValue_js_1.StoredValue(result);
+    }
+    async call(to, data, from, height) {
+        const toStr = to.toString();
+        const fromStr = from ? from.toString() : null;
+        let dataStr = Buffer.isBuffer(data) ? this.bufferToHex(data) : data;
+        if (dataStr.startsWith('0x')) {
+            dataStr = dataStr.slice(2);
+        }
+        const params = [toStr, dataStr];
+        if (fromStr) {
+            params.push(fromStr);
+        }
+        if (height) {
+            params.push(height.toString());
+        }
+        const payload = this.buildJsonRpcPayload('btc_call', params);
+        const rawCall = await this.callPayloadSingle(payload);
+        const result = rawCall.result;
+        if ('error' in result) {
+            return result;
+        }
+        return new CallResult_js_1.CallResult(result);
+    }
+    bufferToHex(buffer) {
+        return buffer.toString('hex');
+    }
+    bigintToBase64(bigint) {
+        return Buffer.from(bsi_binary_1.BufferHelper.pointerToUint8Array(bigint)).toString('base64');
+    }
+    async callPayloadSingle(payload) {
+        const rawData = await this.provider._send(payload);
+        if (rawData.length !== 1) {
+            throw new Error(`Unexpected response length for get block request: ${rawData.length}`);
+        }
+        const data = rawData.shift();
+        if (!data) {
+            throw new Error('Block not found');
+        }
+        if ('error' in data) {
+            throw new Error(`Something went wrong while fetching: ${data.error.message}`);
+        }
+        return data;
+    }
+    buildJsonRpcPayload(method, params) {
+        return {
+            method: method,
+            params: params,
+            id: this.nextId++,
+            jsonrpc: '2.0',
+        };
+    }
+}
+exports.AbstractRpcProvider = AbstractRpcProvider;

package/cjs/providers/JSONRpcProvider.d.ts

@@ -1,12 +1,8 @@
-import { BlockTag } from 'ethers';
-import { Block } from '../block/Block.js';
-export declare class JSONRpcProvider {
-    private readonly provider;
+import { JsonRpcProvider } from 'ethers';
+import { AbstractRpcProvider } from './AbstractRpcProvider.js';
+export declare class JSONRpcProvider extends AbstractRpcProvider {
     private readonly url;
-    private nextId;
+    protected readonly provider: JsonRpcProvider;
     constructor(url: string);
-    private providerUrl;
-    getBlockNumber(): Promise<number>;
-    getBlock(blockNumber: BlockTag | string, prefetchTxs?: boolean): Promise<Block>;
-    private buildJsonRpcPayload;
+    protected providerUrl(url: string): string;
 }

package/cjs/providers/JSONRpcProvider.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONRpcProvider = void 0;
 const ethers_1 = require("ethers");
-const Block_js_1 = require("../block/Block.js");
-class JSONRpcProvider {
-    provider;
+const AbstractRpcProvider_js_1 = require("./AbstractRpcProvider.js");
+class JSONRpcProvider extends AbstractRpcProvider_js_1.AbstractRpcProvider {
     url;
-    nextId = 0;
+    provider;
     constructor(url) {
+        super();
         this.url = this.providerUrl(url);
         this.provider = new ethers_1.JsonRpcProvider(this.url);
     }
@@ -23,30 +23,5 @@ class JSONRpcProvider {
             return `${url}/api/v1/json-rpc`;
         }
     }
-    async getBlockNumber() {
-        return await this.provider.getBlockNumber();
-    }
-    async getBlock(blockNumber, prefetchTxs = false) {
-        const method = typeof blockNumber === 'string' ? 'btc_getBlockByHash' : 'btc_getBlockByNumber';
-        const payload = this.buildJsonRpcPayload(method, [
-            blockNumber,
-            prefetchTxs,
-        ]);
-        const blockData = await this.provider._send(payload);
-        const block = blockData.shift();
-        if (!block) {
-            throw new Error('Block not found');
-        }
-        const result = block.result;
-        return new Block_js_1.Block(result);
-    }
-    buildJsonRpcPayload(method, params) {
-        return {
-            method: method,
-            params: params,
-            id: this.nextId++,
-            jsonrpc: '2.0',
-        };
-    }
 }
 exports.JSONRpcProvider = JSONRpcProvider;

package/cjs/providers/WebsocketRpcProvider.d.ts

@@ -0,0 +1,8 @@
+import { WebSocketProvider } from 'ethers';
+import { AbstractRpcProvider } from './AbstractRpcProvider.js';
+export declare class WebSocketRpcProvider extends AbstractRpcProvider {
+    private readonly wsUrl;
+    protected readonly provider: WebSocketProvider;
+    constructor(url: string);
+    protected providerUrl(url: string): string;
+}

package/cjs/providers/WebsocketRpcProvider.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketRpcProvider = void 0;
+const ethers_1 = require("ethers");
+const AbstractRpcProvider_js_1 = require("./AbstractRpcProvider.js");
+class WebSocketRpcProvider extends AbstractRpcProvider_js_1.AbstractRpcProvider {
+    wsUrl;
+    provider;
+    constructor(url) {
+        super();
+        this.wsUrl = this.providerUrl(url);
+        this.provider = new ethers_1.WebSocketProvider(this.wsUrl);
+    }
+    providerUrl(url) {
+        url = url.trim();
+        if (url.endsWith('/')) {
+            return url.slice(0, -1);
+        }
+        if (url.includes('api/v1/json-rpc-ws')) {
+            return url;
+        }
+        else {
+            return `${url}/api/v1/json-rpc-ws`;
+        }
+    }
+}
+exports.WebSocketRpcProvider = WebSocketRpcProvider;

package/cjs/scripts/testContract.d.ts

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

package/cjs/scripts/testContract.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bsi_binary_1 = require("@btc-vision/bsi-binary");
+const BitcoinAbiTypes_js_1 = require("../abi/BitcoinAbiTypes.js");
+const Contract_js_1 = require("../contracts/Contract.js");
+const JSONRpcProvider_js_1 = require("../providers/JSONRpcProvider.js");
+const provider = new JSONRpcProvider_js_1.JSONRpcProvider('https://testnet.opnet.org');
+(async () => {
+    const abi = [
+        {
+            name: 'balanceOf',
+            inputs: [
+                {
+                    name: 'address',
+                    type: bsi_binary_1.ABIDataTypes.ADDRESS,
+                },
+            ],
+            outputs: [
+                {
+                    name: 'balance',
+                    type: bsi_binary_1.ABIDataTypes.UINT256,
+                },
+            ],
+            type: BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function,
+        },
+    ];
+    const contract = (0, Contract_js_1.getContract)('tb1pth90usc4f528aqphpjrfkkdm4vy8hxnt5gps6aau2nva6pxeshtqqzlt3a', abi, provider);
+    const res = (await contract.balanceOf('bc1p134a291b21a4ef28c961daee77a75e81cd7c0f00733a152930f76746a3e9'));
+    console.log('Balance:', res.decoded);
+})();

package/cjs/scripts/testMethods.d.ts

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

package/cjs/scripts/testMethods.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSONRpcProvider_js_1 = require("../providers/JSONRpcProvider.js");
+const provider = new JSONRpcProvider_js_1.JSONRpcProvider('https://testnet.opnet.org');
+(async () => {
+    const blockNumber = await provider.getBlockNumber();
+    console.log('Current network height:', blockNumber);
+    const block = await provider.getBlock(2810101n, true);
+    console.log('Block ->', block.transactions[2]);
+    const balance = await provider.getBalance('tb1qcfszz8dcvsz9mcp70ezw5zy2r3ydr0cfz60d3t');
+    console.log('Balance out:', balance);
+    const utxos = await provider.getUXTOs('tb1qcfszz8dcvsz9mcp70ezw5zy2r3ydr0cfz60d3t');
+    console.log('UTXOs:', utxos);
+    const transaction = await provider.getTransaction('63e77ba9fa4262b3d4d0d9d97fa8a7359534606c3f3af096284662e3f619f374');
+    console.log('Transaction:', transaction);
+    const receipt = await provider.getTransactionReceipt('63e77ba9fa4262b3d4d0d9d97fa8a7359534606c3f3af096284662e3f619f374');
+    console.log('Receipt:', receipt);
+    const net = await provider.getNetwork();
+    console.log(net);
+    const code = await provider.getCode('tb1pth90usc4f528aqphpjrfkkdm4vy8hxnt5gps6aau2nva6pxeshtqqzlt3a');
+    console.log('Code:', code);
+    const pointerValue = await provider.getStorageAt('tb1pth90usc4f528aqphpjrfkkdm4vy8hxnt5gps6aau2nva6pxeshtqqzlt3a', 'EXLK/QhEQMI5d9DrthLvozT+UcDQ7WuSPaz7g8GV3AQ=', true);
+    console.log('Pointer value:', pointerValue);
+    const callResult = await provider.call('tb1pth90usc4f528aqphpjrfkkdm4vy8hxnt5gps6aau2nva6pxeshtqqzlt3a', '82d62f3d3133734251714a646e416463377635746e583369665971414d6f4658373956664c79000000000000000000000000000000000000000000000000000000000000');
+    console.log('Call result:', callResult);
+})();

package/cjs/serialize/BigInt.d.ts

@@ -0,0 +1,6 @@
+export {};
+declare global {
+    interface BigInt {
+        toJSON(): string;
+    }
+}

package/cjs/serialize/BigInt.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+BigInt.prototype.toJSON = function () {
+    return this.toString();
+};

package/cjs/storage/StoredValue.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { IStorageValue } from './interfaces/IStorageValue.js';
+export declare class StoredValue implements IStorageValue {
+    readonly pointer: bigint;
+    readonly value: Buffer;
+    readonly height: bigint;
+    readonly proofs: string[];
+    constructor(iStoredValue: IStorageValue);
+    private base64ToBigInt;
+}

package/cjs/storage/StoredValue.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoredValue = void 0;
+const bsi_binary_1 = require("@btc-vision/bsi-binary");
+class StoredValue {
+    pointer;
+    value;
+    height;
+    proofs;
+    constructor(iStoredValue) {
+        this.pointer =
+            typeof iStoredValue.pointer === 'string'
+                ? this.base64ToBigInt(iStoredValue.pointer)
+                : iStoredValue.pointer;
+        if (iStoredValue.value instanceof Buffer) {
+            this.value = iStoredValue.value;
+        }
+        else {
+            this.value = Buffer.from(iStoredValue.value, 'base64');
+        }
+        this.height = BigInt(iStoredValue.height);
+        this.proofs = iStoredValue.proofs || [];
+    }
+    base64ToBigInt(base64) {
+        return bsi_binary_1.BufferHelper.uint8ArrayToPointer(Buffer.from(base64, 'base64'));
+    }
+}
+exports.StoredValue = StoredValue;

package/cjs/storage/interfaces/IStorageValue.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { BigNumberish } from 'ethers';
+import { PointerLike } from '../../common/CommonTypes.js';
+export interface IStorageValue {
+    readonly pointer: PointerLike;
+    readonly value: string | Buffer;
+    readonly height: BigNumberish;
+    readonly proofs?: string[];
+}

package/cjs/storage/interfaces/IStorageValue.js

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

package/cjs/transactions/DeploymentTransaction.d.ts

@@ -1,6 +1,15 @@
+/// <reference types="node" />
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
-import { IDeploymentTransaction } from '../interfaces/transactions/ITransaction.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;
     constructor(transaction: IDeploymentTransaction);
 }

package/cjs/transactions/DeploymentTransaction.js

@@ -3,8 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeploymentTransaction = void 0;
 const Transaction_js_1 = require("./Transaction.js");
 class DeploymentTransaction extends Transaction_js_1.TransactionBase {
+    contractAddress;
+    virtualAddress;
+    bytecode;
+    wasCompressed;
+    deployerPubKey;
+    deployerAddress;
+    contractSeed;
+    contractSaltHash;
     constructor(transaction) {
         super(transaction);
+        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');
     }
 }
 exports.DeploymentTransaction = DeploymentTransaction;

package/cjs/transactions/GenericTransaction.d.ts

@@ -1,5 +1,5 @@
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
-import { IGenericTransaction } from '../interfaces/transactions/ITransaction.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/cjs/transactions/InteractionTransaction.d.ts

@@ -2,7 +2,7 @@
 import { NetEvent } from '@btc-vision/bsi-binary';
 import { Buffer } from 'buffer';
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
-import { IInteractionTransaction } from '../interfaces/transactions/ITransaction.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;

package/cjs/transactions/Transaction.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { BigNumberish } from 'ethers';
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
-import { ITransactionBase } from '../interfaces/transactions/ITransaction.js';
+import { ITransactionBase } from './interfaces/ITransaction.js';
 import { TransactionInput } from './TransactionInput.js';
 import { TransactionOutput } from './TransactionOutput.js';
 export declare abstract class TransactionBase<T extends OPNetTransactionTypes> implements ITransactionBase<T> {

package/cjs/transactions/Transaction.js

@@ -16,7 +16,7 @@ class TransactionBase {
         this.id = transaction.id;
         this.hash = transaction.hash;
         this.index = transaction.index;
-        this.burnedBitcoin = transaction.burnedBitcoin;
+        this.burnedBitcoin = BigInt(transaction.burnedBitcoin) || 0n;
         this.inputs = transaction.inputs.map((input) => new TransactionInput_js_1.TransactionInput(input));
         this.outputs = transaction.outputs.map((output) => new TransactionOutput_js_1.TransactionOutput(output));
         this.revert = transaction.revert

package/cjs/transactions/TransactionParser.d.ts

@@ -0,0 +1,7 @@
+import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
+import { ITransaction } from './interfaces/ITransaction.js';
+import { TransactionBase } from './Transaction.js';
+export declare class TransactionParser {
+    static parseTransactions(transactions: ITransaction[]): TransactionBase<OPNetTransactionTypes>[];
+    static parseTransaction(transaction: ITransaction): TransactionBase<OPNetTransactionTypes>;
+}

package/cjs/transactions/TransactionParser.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionParser = void 0;
+const OPNetTransactionTypes_js_1 = require("../interfaces/opnet/OPNetTransactionTypes.js");
+const DeploymentTransaction_js_1 = require("./DeploymentTransaction.js");
+const GenericTransaction_js_1 = require("./GenericTransaction.js");
+const InteractionTransaction_js_1 = require("./InteractionTransaction.js");
+class TransactionParser {
+    static parseTransactions(transactions) {
+        if (!transactions) {
+            return [];
+        }
+        const transactionArray = [];
+        for (let transaction of transactions) {
+            transactionArray.push(this.parseTransaction(transaction));
+        }
+        return transactionArray;
+    }
+    static parseTransaction(transaction) {
+        switch (transaction.OPNetType) {
+            case OPNetTransactionTypes_js_1.OPNetTransactionTypes.Generic:
+                return new GenericTransaction_js_1.GenericTransaction(transaction);
+            case OPNetTransactionTypes_js_1.OPNetTransactionTypes.Interaction:
+                return new InteractionTransaction_js_1.InteractionTransaction(transaction);
+            case OPNetTransactionTypes_js_1.OPNetTransactionTypes.Deployment:
+                return new DeploymentTransaction_js_1.DeploymentTransaction(transaction);
+            default:
+                throw new Error('Unknown transaction type');
+        }
+    }
+}
+exports.TransactionParser = TransactionParser;

package/cjs/transactions/TransactionReceipt.d.ts

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

package/cjs/transactions/TransactionReceipt.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionReceipt = void 0;
+class TransactionReceipt {
+    receipt;
+    receiptProofs;
+    events;
+    revert;
+    constructor(receipt) {
+        this.receipt = receipt.receipt ? Buffer.from(receipt.receipt, 'base64') : null;
+        this.receiptProofs = receipt.receiptProofs || [];
+        this.events = receipt.events || [];
+        this.revert = receipt.revert ? Buffer.from(receipt.revert, 'base64') : undefined;
+    }
+}
+exports.TransactionReceipt = TransactionReceipt;

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

@@ -0,0 +1,39 @@
+/// <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';
+export interface ITransactionBase<T extends OPNetTransactionTypes> {
+    readonly id: string;
+    readonly hash: string;
+    readonly index: number;
+    readonly burnedBitcoin: string | BigNumberish;
+    readonly revert?: string | Buffer;
+    readonly inputs: ITransactionInput[] | TransactionInput[];
+    readonly outputs: ITransactionOutput[] | TransactionOutput[];
+    readonly OPNetType: T;
+}
+export interface IGenericTransaction extends ITransactionBase<OPNetTransactionTypes.Generic> {
+}
+export interface IDeploymentTransaction extends ITransactionBase<OPNetTransactionTypes.Deployment> {
+    readonly contractAddress: string;
+    readonly virtualAddress: string;
+    readonly bytecode: Buffer | string;
+    readonly wasCompressed: boolean;
+    readonly deployerPubKey: Buffer | string;
+    readonly deployerAddress: string;
+    readonly contractSeed: Buffer | string;
+    readonly contractSaltHash: Buffer | string;
+}
+export interface IInteractionTransaction extends ITransactionBase<OPNetTransactionTypes.Interaction> {
+    readonly calldata: string | Buffer;
+    readonly senderPubKeyHash: string | Buffer;
+    readonly contractSecret: string | Buffer;
+    readonly interactionPubKey: string | Buffer;
+    readonly wasCompressed: boolean;
+    readonly events: NetEvent[];
+    readonly receipt?: string | Buffer;
+    readonly receiptProofs?: string[];
+}
+export type ITransaction = IDeploymentTransaction | IInteractionTransaction | IGenericTransaction;

package/cjs/transactions/interfaces/ITransaction.js

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

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

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { NetEvent } from '@btc-vision/bsi-binary';
+export interface ITransactionReceipt {
+    readonly receipt: string | null | Buffer;
+    readonly receiptProofs: string[];
+    readonly events: NetEvent[];
+    readonly revert?: string | Buffer;
+}

package/cjs/transactions/interfaces/ITransactionReceipt.js

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

package/cjs/utils/BitcoinUtils.d.ts

@@ -0,0 +1,4 @@
+import { BigNumberish } from 'ethers';
+export declare class BitcoinUtils {
+    static formatUnits(value: BigNumberish, decimals?: number): string;
+}

package/cjs/utils/BitcoinUtils.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinUtils = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+class BitcoinUtils {
+    static formatUnits(value, decimals = 8) {
+        const bn = new bignumber_js_1.default(value.toString());
+        return bn.dividedBy(new bignumber_js_1.default(10).pow(decimals)).toString();
+    }
+}
+exports.BitcoinUtils = BitcoinUtils;

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "data:application/octet-stream;base64,H4sIAAAAAAAACo3WXW/TMBQG4P/i64qyovHRu65DEDStUVs+JMSF65xRK4kdbKcwof13lLajjn18ktv49aN82G/8/S9z8MexOVvl9+C2hivLhZNabR8bsGzCGu72bM5AtbWdoqEXe1dXbMJKqQo2f/s0+W8udtYZLty6EbnRB1mAuYii4taCnSKhvng1880b6YSWalEUBqyNuf44KVValAjQXabmLXlVrcG2lYsnX8ZIQavjI99yxxHDG6WUW2gq/ViD8r9IzKExyv0ACowUJBpnKDFTDsx5xVAqnqPkT5vVPbm6ggBlbZw2UHzhVQux4w1ShnfbN9wiThAYaWWqaZHVFiZGaqvWDXGnyEgv58Zi7z6KjPTWIEA29A2eM5T4efttFRvdVWrWV9httCiBLi0sRe6AhRBg7Z203mPJbrk/cNGt/Mt4n5ldv8aZzEE9RHUZkgsq0FeQGsQmL3Vd+1s5Ik4BEjqV5q8WrHtvjDa4FqZGkF0P9zs2Bp8zJDdQtb46om4DnOpbXx7q3IAdKl2fHlO8Ab/mv59/VLjpBUioa1b+E4Le9SU/QVLJ9vU1soHTYFDBCRGp4TQZ9nDCxLo4jUblmVDRAg3YfoP6UNyi/an9U9idLL2P4bpD4zROBN7Ld2+urmfhee0j8ALMcg+itG2dG60fIjmRG/Iz7GB3IrPUuQ5R0M12ZtKbK3JyfXzf2KvzhoaU7jvZcP7x4tDMAxjbe4QDN5LvKrDT81BfeDV7+vEPYyErXU4MAAA="
+window.navigationData = "data:application/octet-stream;base64,H4sIAAAAAAAACpXX0W7TMBQG4HfxdUfZYAN613UIgqa16jpAQly4ztlmNYmD7YxVaO8+Je1Wxz4+Mbc5v78mqetf/fWPWXi0bMKm59kFt3y1rcGwEau5vWcTBlVTmrE7e3Nvy4KN2EZWOZt8HDFRcGPYhFmTH0lzBI8WdMUL9jR6tc+lFUpW07VEeW/sfYLjzBdXYFeaV4YLK1WFamgobk7Xxmou7LIWC60eZA76IHbPBmaMhPri8YlrnnMDM1V1S0LMnZLK/rXkuQZjEKc3T5CyyoK+5QKi1msiQbuxsojfVTcllUKJDbK8vUytm/GiWIJpCuTNHmaksH/37ZZGDGdKKRdQF2pbQuXutZBDY5T7BSrQUpBomKHEjN6OWep+7DbH/jdF3R2eo+Rv1/Mr8vfnBSjr2ioN+XdeNMg2d4aU4dx2+3JCxwskWllVN8gX4CcStXljh7hdJNFbcG2wdx9EEr0lCJA1fYP7DCXerH7OQ6O9Sq36AetrJTZAH+tYKvVcX2hVg7bSLSD5cnz2D/lDtI+fnJ6hJeltXlftZxK41xN9upb9vRyyfpbis6kQYMylNBYlnXkik1koh6g2Q3Jeq7gK0izY4pkqS/dUC4hdgIR2PfSnAWM/a600rvmpBLKttn5theBLhuaCOuhBaBt4xEABul5CCXo41YKuPNSEHjtUYS6dUmMev+R/6RfrBEio7Sl+B/GDoJcgqWiXuRrZZ3HQK7SIiJRanPRbLWJizRZHgyqKqGgdeWy/j1wo7CTvRA4rYXuQbPs3BauNrWe+/fTh+PQk+j/hUm4gUINEouk2QgR1I4Nqe35+BZ6Dnt2D2JimXGilbgM6khvyL0CoHHLsL8IODgJDYha3sv9Q0MNmz8QPl8BZqG6/YV+xMxpS2n1q/PXdxaGVD6BN7xEeuJZ8XYAZ70d94Z27+A5seDjeNlX35GbsjPvI2fun38/2HutrpxAAAA=="