opnet 1.0.13 → 1.0.15

package/cjs/contracts/Contract.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContract = exports.BaseContract = exports.IBaseContract = void 0;
+const bsi_binary_1 = require("@btc-vision/bsi-binary");
+const BitcoinAbiTypes_js_1 = require("../abi/BitcoinAbiTypes.js");
+const BitcoinInterface_js_1 = require("../abi/BitcoinInterface.js");
+const internal = Symbol.for('_btc_internal');
+const bitcoinAbiCoder = new bsi_binary_1.ABICoder();
+class IBaseContract {
+    address;
+    interface;
+    provider;
+    [internal];
+    events = [];
+    constructor(address, abi, provider) {
+        this.address = address;
+        this.provider = provider;
+        this.interface = BitcoinInterface_js_1.BitcoinInterface.from(abi);
+        Object.defineProperty(this, internal, { value: {} });
+        this.defineInternalFunctions();
+    }
+    getFunction(name) {
+        const key = name;
+        return this[key];
+    }
+    defineInternalFunctions() {
+        for (const element of this.interface.abi) {
+            switch (element.type) {
+                case BitcoinAbiTypes_js_1.BitcoinAbiTypes.Function:
+                    Object.defineProperty(this, element.name, {
+                        value: this.callFunction(element).bind(this),
+                    });
+                    break;
+                case BitcoinAbiTypes_js_1.BitcoinAbiTypes.Event:
+                    this.events.push(element);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    encodeFunctionData(element, args) {
+        const writer = new bsi_binary_1.BinaryWriter();
+        const selector = Number('0x' + bitcoinAbiCoder.encodeSelector(element.name));
+        writer.writeSelector(selector);
+        if (args.length !== element.inputs.length) {
+            throw new Error('Invalid number of arguments provided');
+        }
+        if (!element.inputs || (element.inputs && element.inputs.length === 0)) {
+            return writer;
+        }
+        for (let i = 0; i < element.inputs.length; i++) {
+            this.encodeInput(writer, element.inputs[i], args[i]);
+        }
+        return writer;
+    }
+    encodeInput(writer, abi, value) {
+        const type = abi.type;
+        const name = abi.name;
+        switch (type) {
+            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:
+                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:
+                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:
+                const address = value;
+                writer.writeAddress(address.toString());
+                break;
+            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:
+                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:
+                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:
+                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:
+                if (!(value instanceof Uint8Array)) {
+                    throw new Error(`Expected value to be of type Uint8Array (${name})`);
+                }
+                writer.writeBytes(value);
+                break;
+            default:
+                throw new Error(`Unsupported type: ${type} (${name})`);
+        }
+    }
+    decodeOutput(abi, reader) {
+        const result = [];
+        for (let i = 0; i < abi.length; i++) {
+            const type = abi[i].type;
+            const name = abi[i].name;
+            switch (type) {
+                case bsi_binary_1.ABIDataTypes.UINT256:
+                    result.push(reader.readU256());
+                    break;
+                case bsi_binary_1.ABIDataTypes.BOOL:
+                    result.push(reader.readBoolean());
+                    break;
+                case bsi_binary_1.ABIDataTypes.STRING:
+                    result.push(reader.readStringWithLength());
+                    break;
+                case bsi_binary_1.ABIDataTypes.ADDRESS:
+                    result.push(reader.readAddress());
+                    break;
+                case bsi_binary_1.ABIDataTypes.TUPLE:
+                    result.push(reader.readTuple());
+                    break;
+                case bsi_binary_1.ABIDataTypes.UINT8:
+                    result.push(reader.readU8());
+                    break;
+                case bsi_binary_1.ABIDataTypes.UINT16:
+                    result.push(reader.readU16());
+                    break;
+                case bsi_binary_1.ABIDataTypes.UINT32:
+                    result.push(reader.readU32());
+                    break;
+                case bsi_binary_1.ABIDataTypes.BYTES32:
+                    result.push(reader.readBytes(32));
+                    break;
+                default:
+                    throw new Error(`Unsupported type: ${type} (${name})`);
+            }
+        }
+        return result;
+    }
+    callFunction(element) {
+        return async (...args) => {
+            const data = this.encodeFunctionData(element, args);
+            const response = await this.provider.call(this.address, Buffer.from(data.getBuffer()));
+            if ('error' in response) {
+                return response;
+            }
+            const decoded = element.outputs
+                ? this.decodeOutput(element.outputs, response.result)
+                : [];
+            response.setDecoded(decoded);
+            return response;
+        };
+    }
+}
+exports.IBaseContract = IBaseContract;
+class BaseContract extends IBaseContract {
+    constructor(address, abi, provider) {
+        super(address, abi, provider);
+        return this.proxify();
+    }
+    proxify() {
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (typeof prop === 'symbol' || prop in target) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                try {
+                    return this.getFunction(prop);
+                }
+                catch (error) {
+                    if (!(error instanceof Error)) {
+                        throw new Error(`Something went wrong when trying to get the function: ${error}`);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            },
+            has: (target, prop) => {
+                if (typeof prop === 'symbol' || prop in target) {
+                    return Reflect.has(target, prop);
+                }
+                return target.interface.hasFunction(prop);
+            },
+        });
+    }
+}
+exports.BaseContract = BaseContract;
+function contractBase() {
+    return BaseContract;
+}
+function getContract(address, abi, provider) {
+    const base = contractBase();
+    return new base(address, abi, provider);
+}
+exports.getContract = getContract;

package/cjs/contracts/ContractData.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IRawContract } from './interfaces/IRawContract.js';
+export declare class ContractData implements IRawContract {
+    readonly contractAddress: string;
+    readonly virtualAddress: string;
+    readonly bytecode: Buffer;
+    readonly wasCompressed: boolean;
+    readonly deployedTransactionId: string;
+    readonly deployedTransactionHash: string;
+    readonly deployerPubKey: Buffer;
+    readonly contractSeed: Buffer;
+    readonly contractSaltHash: Buffer;
+    readonly deployerAddress: string;
+    constructor(raw: IRawContract);
+}

package/cjs/contracts/ContractData.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractData = void 0;
+class ContractData {
+    contractAddress;
+    virtualAddress;
+    bytecode;
+    wasCompressed;
+    deployedTransactionId;
+    deployedTransactionHash;
+    deployerPubKey;
+    contractSeed;
+    contractSaltHash;
+    deployerAddress;
+    constructor(raw) {
+        this.contractAddress = raw.contractAddress;
+        this.virtualAddress = raw.virtualAddress;
+        this.bytecode = Buffer.isBuffer(raw.bytecode)
+            ? raw.bytecode
+            : Buffer.from(raw.bytecode, 'base64');
+        this.wasCompressed = raw.wasCompressed;
+        this.deployedTransactionId = raw.deployedTransactionId;
+        this.deployedTransactionHash = raw.deployedTransactionHash;
+        this.deployerPubKey = Buffer.isBuffer(raw.deployerPubKey)
+            ? raw.deployerPubKey
+            : Buffer.from(raw.deployerPubKey, 'base64');
+        this.contractSeed = Buffer.isBuffer(raw.contractSeed)
+            ? raw.contractSeed
+            : Buffer.from(raw.contractSeed, 'base64');
+        this.contractSaltHash = Buffer.isBuffer(raw.contractSaltHash)
+            ? raw.contractSaltHash
+            : Buffer.from(raw.contractSaltHash, 'base64');
+        this.deployerAddress = raw.deployerAddress;
+    }
+}
+exports.ContractData = ContractData;

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

@@ -0,0 +1,6 @@
+export interface IAccessListItem {
+    [key: string]: string;
+}
+export interface IAccessList {
+    [key: string]: IAccessListItem;
+}

package/cjs/contracts/interfaces/IAccessList.js

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

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

@@ -0,0 +1,11 @@
+import { BinaryReader, NetEvent } from '@btc-vision/bsi-binary';
+import { IAccessList } from './IAccessList.js';
+export interface ICallRequestError {
+    readonly error: string;
+}
+export interface ICallResultData {
+    readonly result: string | BinaryReader;
+    readonly events: NetEvent[];
+    readonly accessList: IAccessList;
+}
+export type ICallResult = ICallRequestError | ICallResultData;

package/cjs/contracts/interfaces/ICallResult.js

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

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

@@ -0,0 +1,4 @@
+import { BitcoinAddressLike } from '../../common/CommonTypes.js';
+export interface IContract {
+    readonly address: BitcoinAddressLike;
+}

package/cjs/contracts/interfaces/IContract.js

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

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+export interface IRawContract {
+    readonly contractAddress: string;
+    readonly virtualAddress: string;
+    readonly bytecode: Buffer | string;
+    readonly wasCompressed: boolean;
+    readonly deployedTransactionId: string;
+    readonly deployedTransactionHash: string;
+    readonly deployerPubKey: Buffer | string;
+    readonly contractSeed: Buffer | string;
+    readonly contractSaltHash: Buffer | string;
+    readonly deployerAddress: string;
+}

package/cjs/contracts/interfaces/IRawContract.js

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

package/cjs/crypto/crypto.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export { createHash, createHmac, pbkdf2Sync, randomBytes } from 'crypto';

package/cjs/crypto/crypto.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomBytes = exports.pbkdf2Sync = exports.createHmac = exports.createHash = void 0;
+var crypto_1 = require("crypto");
+Object.defineProperty(exports, "createHash", { enumerable: true, get: function () { return crypto_1.createHash; } });
+Object.defineProperty(exports, "createHmac", { enumerable: true, get: function () { return crypto_1.createHmac; } });
+Object.defineProperty(exports, "pbkdf2Sync", { enumerable: true, get: function () { return crypto_1.pbkdf2Sync; } });
+Object.defineProperty(exports, "randomBytes", { enumerable: true, get: function () { return crypto_1.randomBytes; } });

package/cjs/index.d.ts

@@ -1,11 +1,3 @@
-export * from './interfaces/opnet/OPNetTransactionTypes.js';
-export * from './interfaces/transactions/ITransaction.js';
-export * from './transactions/DeploymentTransaction.js';
-export * from './transactions/GenericTransaction.js';
-export * from './transactions/InteractionTransaction.js';
-export * from './transactions/Transaction.js';
-export * from './transactions/TransactionInput.js';
-export * from './transactions/TransactionOutput.js';
-export * from './providers/JSONRpcProvider.js';
-export * from './block/Block.js';
-export * from './interfaces/blocks/IBlock.js';
+import * as opnet from './opnet.js';
+export { opnet };
+export * from './opnet.js';

package/cjs/index.js

@@ -10,18 +10,23 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./interfaces/opnet/OPNetTransactionTypes.js"), exports);
-__exportStar(require("./interfaces/transactions/ITransaction.js"), exports);
-__exportStar(require("./transactions/DeploymentTransaction.js"), exports);
-__exportStar(require("./transactions/GenericTransaction.js"), exports);
-__exportStar(require("./transactions/InteractionTransaction.js"), exports);
-__exportStar(require("./transactions/Transaction.js"), exports);
-__exportStar(require("./transactions/TransactionInput.js"), exports);
-__exportStar(require("./transactions/TransactionOutput.js"), exports);
-__exportStar(require("./providers/JSONRpcProvider.js"), exports);
-__exportStar(require("./block/Block.js"), exports);
-__exportStar(require("./interfaces/blocks/IBlock.js"), exports);
+exports.opnet = void 0;
+const opnet = __importStar(require("./opnet.js"));
+exports.opnet = opnet;
+__exportStar(require("./opnet.js"), exports);

package/cjs/opnet.d.ts

@@ -0,0 +1,36 @@
+export { version } from './_version.js';
+export * from './interfaces/opnet/OPNetTransactionTypes.js';
+export * from './transactions/DeploymentTransaction.js';
+export * from './transactions/GenericTransaction.js';
+export * from './transactions/InteractionTransaction.js';
+export * from './transactions/Transaction.js';
+export * from './transactions/TransactionInput.js';
+export * from './transactions/TransactionOutput.js';
+export * from './providers/JSONRpcProvider.js';
+export * from './providers/AbstractRpcProvider.js';
+export * from './providers/WebsocketRpcProvider.js';
+export * from './block/Block.js';
+export * from './transactions/TransactionParser.js';
+export * from './contracts/ContractData.js';
+export * from './contracts/CallResult.js';
+export * from './contracts/Contract.js';
+export * from './contracts/interfaces/IContract.js';
+export * from './contracts/interfaces/ICallResult.js';
+export * from './contracts/interfaces/IAccessList.js';
+export * from './abi/BitcoinInterface.js';
+export * from './abi/interfaces/BitcoinInterfaceAbi.js';
+export * from './abi/interfaces/BitcoinAbiValue.js';
+export * from './abi/BitcoinAbiTypes.js';
+export * from './abi/interfaces/BaseContractProperties.js';
+export * from './abi/BaseContractProperty.js';
+export * from './utils/BitcoinUtils.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 './common/CommonTypes.js';
+export * from './bitcoin/BitcoinAddress.js';
+export * from './bitcoin/UTXOs.js';

package/cjs/opnet.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+var _version_js_1 = require("./_version.js");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return _version_js_1.version; } });
+__exportStar(require("./interfaces/opnet/OPNetTransactionTypes.js"), exports);
+__exportStar(require("./transactions/DeploymentTransaction.js"), exports);
+__exportStar(require("./transactions/GenericTransaction.js"), exports);
+__exportStar(require("./transactions/InteractionTransaction.js"), exports);
+__exportStar(require("./transactions/Transaction.js"), exports);
+__exportStar(require("./transactions/TransactionInput.js"), exports);
+__exportStar(require("./transactions/TransactionOutput.js"), exports);
+__exportStar(require("./providers/JSONRpcProvider.js"), exports);
+__exportStar(require("./providers/AbstractRpcProvider.js"), exports);
+__exportStar(require("./providers/WebsocketRpcProvider.js"), exports);
+__exportStar(require("./block/Block.js"), exports);
+__exportStar(require("./transactions/TransactionParser.js"), exports);
+__exportStar(require("./contracts/ContractData.js"), exports);
+__exportStar(require("./contracts/CallResult.js"), exports);
+__exportStar(require("./contracts/Contract.js"), exports);
+__exportStar(require("./contracts/interfaces/IContract.js"), exports);
+__exportStar(require("./contracts/interfaces/ICallResult.js"), exports);
+__exportStar(require("./contracts/interfaces/IAccessList.js"), exports);
+__exportStar(require("./abi/BitcoinInterface.js"), exports);
+__exportStar(require("./abi/interfaces/BitcoinInterfaceAbi.js"), exports);
+__exportStar(require("./abi/interfaces/BitcoinAbiValue.js"), exports);
+__exportStar(require("./abi/BitcoinAbiTypes.js"), exports);
+__exportStar(require("./abi/interfaces/BaseContractProperties.js"), exports);
+__exportStar(require("./abi/BaseContractProperty.js"), exports);
+__exportStar(require("./utils/BitcoinUtils.js"), exports);
+__exportStar(require("./storage/StoredValue.js"), exports);
+__exportStar(require("./storage/interfaces/IStorageValue.js"), exports);
+__exportStar(require("./block/interfaces/IBlock.js"), exports);
+__exportStar(require("./transactions/interfaces/ITransaction.js"), exports);
+__exportStar(require("./transactions/interfaces/ITransactionReceipt.js"), exports);
+__exportStar(require("./transactions/TransactionReceipt.js"), exports);
+__exportStar(require("./contracts/interfaces/IRawContract.js"), exports);
+__exportStar(require("./common/CommonTypes.js"), exports);
+__exportStar(require("./bitcoin/BitcoinAddress.js"), exports);
+__exportStar(require("./bitcoin/UTXOs.js"), exports);

package/cjs/providers/AbstractRpcProvider.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import '../serialize/BigInt.js';
+import { Network } from 'bitcoinjs-lib';
+import { BigNumberish, BlockTag, JsonRpcApiProvider } from 'ethers';
+import { Block } from '../block/Block.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 { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
+import { StoredValue } from '../storage/StoredValue.js';
+import { ITransactionReceipt } from '../transactions/interfaces/ITransactionReceipt.js';
+import { TransactionBase } from '../transactions/Transaction.js';
+export declare abstract class AbstractRpcProvider {
+    protected abstract readonly provider: JsonRpcApiProvider;
+    private nextId;
+    protected constructor();
+    getBlockNumber(): Promise<number>;
+    getBlock(blockNumberOrHash: BlockTag, prefetchTxs?: boolean): Promise<Block>;
+    getBlockByHash(blockHash: string): Promise<Block>;
+    getBalance(addressLike: BitcoinAddressLike): Promise<bigint>;
+    getUXTOs(address: BitcoinAddressLike, optimize?: boolean): Promise<unknown>;
+    getTransaction(txHash: string): Promise<TransactionBase<OPNetTransactionTypes>>;
+    getTransactionReceipt(txHash: string): Promise<ITransactionReceipt>;
+    getNetwork(): Promise<Network>;
+    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>;
+    protected abstract providerUrl(url: string): string;
+    private bufferToHex;
+    private bigintToBase64;
+    private callPayloadSingle;
+    private buildJsonRpcPayload;
+}