opnet 1.0.13 → 1.0.15

package/build/scripts/test.js

@@ -1,6 +1,18 @@
 import { JSONRpcProvider } from '../providers/JSONRpcProvider.js';
 const provider = new 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');

package/build/scripts/testContract.d.ts

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

package/build/scripts/testContract.js

@@ -0,0 +1,28 @@
+import { ABIDataTypes } from '@btc-vision/bsi-binary';
+import { BitcoinAbiTypes } from '../abi/BitcoinAbiTypes.js';
+import { getContract } from '../contracts/Contract.js';
+import { JSONRpcProvider } from '../providers/JSONRpcProvider.js';
+const provider = new JSONRpcProvider('https://testnet.opnet.org');
+(async () => {
+    const abi = [
+        {
+            name: 'balanceOf',
+            inputs: [
+                {
+                    name: 'address',
+                    type: ABIDataTypes.ADDRESS,
+                },
+            ],
+            outputs: [
+                {
+                    name: 'balance',
+                    type: ABIDataTypes.UINT256,
+                },
+            ],
+            type: BitcoinAbiTypes.Function,
+        },
+    ];
+    const contract = getContract('tb1pth90usc4f528aqphpjrfkkdm4vy8hxnt5gps6aau2nva6pxeshtqqzlt3a', abi, provider);
+    const res = (await contract.balanceOf('bc1p134a291b21a4ef28c961daee77a75e81cd7c0f00733a152930f76746a3e9'));
+    console.log('Balance:', res.decoded);
+})();

package/build/scripts/testMethods.d.ts

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

package/build/scripts/testMethods.js

@@ -0,0 +1,24 @@
+import { JSONRpcProvider } from '../providers/JSONRpcProvider.js';
+const provider = new 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/build/utils/BitcoinUtils.d.ts

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

package/build/utils/BitcoinUtils.js

@@ -0,0 +1,7 @@
+import BigNumber from 'bignumber.js';
+export class BitcoinUtils {
+    static formatUnits(value, decimals = 8) {
+        const bn = new BigNumber(value.toString());
+        return bn.dividedBy(new BigNumber(10).pow(decimals)).toString();
+    }
+}

package/cjs/_version.d.ts

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

package/cjs/_version.js

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

package/cjs/abi/BaseContractProperty.d.ts

@@ -0,0 +1,3 @@
+import { CallResult } from '../contracts/CallResult.js';
+import { ICallRequestError } from '../contracts/interfaces/ICallResult.js';
+export type BaseContractProperty = CallResult | ICallRequestError;

package/cjs/abi/BaseContractProperty.js

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

package/cjs/abi/BitcoinAbiTypes.d.ts

@@ -0,0 +1,4 @@
+export declare enum BitcoinAbiTypes {
+    Function = "function",
+    Event = "event"
+}

package/cjs/abi/BitcoinAbiTypes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinAbiTypes = void 0;
+var BitcoinAbiTypes;
+(function (BitcoinAbiTypes) {
+    BitcoinAbiTypes["Function"] = "function";
+    BitcoinAbiTypes["Event"] = "event";
+})(BitcoinAbiTypes || (exports.BitcoinAbiTypes = BitcoinAbiTypes = {}));

package/cjs/abi/BitcoinInterface.d.ts

@@ -0,0 +1,9 @@
+import { BitcoinInterfaceAbi } from './interfaces/BitcoinInterfaceAbi.js';
+export declare class BitcoinInterface {
+    readonly abi: BitcoinInterfaceAbi;
+    constructor(abi: BitcoinInterfaceAbi);
+    static from(abi: BitcoinInterface | BitcoinInterfaceAbi): BitcoinInterface;
+    hasFunction(name: string): boolean;
+    private verifyAbi;
+    private verifyAbiValues;
+}

package/cjs/abi/BitcoinInterface.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinInterface = void 0;
+class BitcoinInterface {
+    abi;
+    constructor(abi) {
+        this.verifyAbi(abi);
+        this.abi = abi;
+    }
+    static from(abi) {
+        if (abi instanceof BitcoinInterface) {
+            return abi;
+        }
+        return new BitcoinInterface(abi);
+    }
+    hasFunction(name) {
+        return this.abi.some((element) => element.name === name && element.type === 'function');
+    }
+    verifyAbi(abi) {
+        if (abi.length === 0) {
+            throw new Error('The ABI provided is empty.');
+        }
+        for (let i = 0; i < abi.length; i++) {
+            const element = abi[i];
+            if (!element.name) {
+                throw new Error('The ABI provided is missing a name.');
+            }
+            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);
+        }
+    }
+    verifyAbiValues(inputs) {
+        for (let j = 0; j < inputs.length; j++) {
+            const input = inputs[j];
+            if (!input.name) {
+                throw new Error('The ABI provided is missing an input name.');
+            }
+            if (!input.type) {
+                throw new Error('The ABI provided is missing an input type.');
+            }
+        }
+    }
+}
+exports.BitcoinInterface = BitcoinInterface;

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

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

package/cjs/abi/interfaces/BaseContractProperties.js

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

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

@@ -0,0 +1,5 @@
+import { ABIDataTypes } from '@btc-vision/bsi-binary';
+export interface BitcoinAbiValue {
+    name: string;
+    type: ABIDataTypes;
+}

package/cjs/abi/interfaces/BitcoinAbiValue.js

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

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

@@ -0,0 +1,11 @@
+import { BitcoinAbiTypes } from '../BitcoinAbiTypes.js';
+import { BitcoinAbiValue } from './BitcoinAbiValue.js';
+export interface BitcoinInterfaceAbiBase {
+    readonly constant?: boolean;
+    readonly name: string;
+    readonly inputs?: BitcoinAbiValue[];
+    readonly outputs?: BitcoinAbiValue[];
+    readonly type: BitcoinAbiTypes;
+    readonly payable?: boolean;
+}
+export type BitcoinInterfaceAbi = BitcoinInterfaceAbiBase[];

package/cjs/abi/interfaces/BitcoinInterfaceAbi.js

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

package/cjs/bitcoin/BitcoinAddress.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { Network } from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
+import { BitcoinAddressLike } from '../common/CommonTypes.js';
+export declare class BitcoinAddress {
+    #private;
+    private readonly network;
+    constructor(keypair: ECPairInterface, network?: Network);
+    get taprootAddress(): string;
+    get p2wpkhAddress(): string;
+    get publicKey(): Buffer;
+    get privateKey(): Buffer | undefined;
+    static isValidTaprootAddress(_addr: BitcoinAddressLike, network?: Network): boolean;
+    static fromPublicKey(publicKey: Buffer, network?: Network): BitcoinAddress;
+    static fromPrivateKey(privateKey: Buffer, network?: Network): BitcoinAddress;
+    static fromWif(wif: string, network?: Network): BitcoinAddress;
+    [Symbol.toStringTag](): string;
+    private getP2WPKHAddress;
+    private getTaprootAddress;
+}

package/cjs/bitcoin/BitcoinAddress.js

@@ -0,0 +1,116 @@
+"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 __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinAddress = void 0;
+const ecc = __importStar(require("@bitcoinerlab/secp256k1"));
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const ecpair_1 = require("ecpair");
+(0, bitcoinjs_lib_1.initEccLib)(ecc);
+const ECPair = (0, ecpair_1.ECPairFactory)(ecc);
+class BitcoinAddress {
+    #keyPair;
+    #taprootAddress;
+    #p2wpkhAddress;
+    network;
+    constructor(keypair, network = bitcoinjs_lib_1.networks.bitcoin) {
+        this.#keyPair = keypair;
+        this.network = network;
+        this.#taprootAddress = this.getTaprootAddress();
+        this.#p2wpkhAddress = this.getP2WPKHAddress();
+    }
+    get taprootAddress() {
+        if (!this.#taprootAddress) {
+            throw new Error('Address not set');
+        }
+        return this.#taprootAddress;
+    }
+    get p2wpkhAddress() {
+        if (!this.#p2wpkhAddress) {
+            throw new Error('Address not set');
+        }
+        return this.#p2wpkhAddress;
+    }
+    get publicKey() {
+        if (!this.#keyPair) {
+            throw new Error('KeyPair not set');
+        }
+        return this.#keyPair.publicKey;
+    }
+    get privateKey() {
+        if (!this.#keyPair) {
+            throw new Error('KeyPair not set');
+        }
+        return this.#keyPair.privateKey;
+    }
+    static isValidTaprootAddress(_addr, network = bitcoinjs_lib_1.networks.bitcoin) {
+        try {
+            let addr;
+            if (typeof _addr === 'string') {
+                addr = _addr;
+            }
+            else {
+                addr = _addr.taprootAddress;
+            }
+            return !!bitcoinjs_lib_1.address.toOutputScript(addr, network);
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    static fromPublicKey(publicKey, network = bitcoinjs_lib_1.networks.bitcoin) {
+        const keyPair = ECPair.fromPublicKey(publicKey, { network });
+        return new BitcoinAddress(keyPair, network);
+    }
+    static fromPrivateKey(privateKey, network = bitcoinjs_lib_1.networks.bitcoin) {
+        const keyPair = ECPair.fromPrivateKey(privateKey, { network });
+        return new BitcoinAddress(keyPair, network);
+    }
+    static fromWif(wif, network = bitcoinjs_lib_1.networks.bitcoin) {
+        const keyPair = ECPair.fromWIF(wif, network);
+        return new BitcoinAddress(keyPair, network);
+    }
+    [Symbol.toStringTag]() {
+        return this.taprootAddress;
+    }
+    getP2WPKHAddress() {
+        const res = bitcoinjs_lib_1.payments.p2wpkh({ pubkey: this.#keyPair.publicKey, network: this.network });
+        if (!res.address) {
+            throw new Error('Failed to generate wallet');
+        }
+        return res.address;
+    }
+    getTaprootAddress() {
+        if (!this.#keyPair) {
+            throw new Error('KeyPair not set');
+        }
+        const myXOnlyPubkey = this.#keyPair.publicKey.slice(1, 33);
+        const output = Buffer.concat([
+            Buffer.from([0x51, 0x20]),
+            myXOnlyPubkey,
+        ]);
+        return bitcoinjs_lib_1.address.fromOutputScript(output, this.network);
+    }
+}
+exports.BitcoinAddress = BitcoinAddress;

package/cjs/bitcoin/UTXOs.d.ts

@@ -0,0 +1,15 @@
+import { ScriptPubKey } from '@btc-vision/bsi-bitcoin-rpc';
+export interface IUTXO {
+    readonly transactionId: string;
+    readonly outputIndex: number;
+    readonly value: bigint | string;
+    readonly scriptPubKey: ScriptPubKey;
+}
+export declare class UTXO implements IUTXO {
+    readonly transactionId: string;
+    readonly outputIndex: number;
+    readonly value: bigint;
+    readonly scriptPubKey: ScriptPubKey;
+    constructor(iUTXO: IUTXO);
+}
+export type UTXOs = UTXO[];

package/cjs/bitcoin/UTXOs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UTXO = void 0;
+class UTXO {
+    transactionId;
+    outputIndex;
+    value;
+    scriptPubKey;
+    constructor(iUTXO) {
+        this.transactionId = iUTXO.transactionId;
+        this.outputIndex = iUTXO.outputIndex;
+        this.value = BigInt(iUTXO.value);
+        this.scriptPubKey = iUTXO.scriptPubKey;
+    }
+}
+exports.UTXO = UTXO;

package/cjs/block/Block.d.ts

@@ -1,7 +1,7 @@
 import { BigNumberish } from 'ethers';
-import { BlockHeaderChecksumProof, IBlock } from '../interfaces/blocks/IBlock.js';
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
 import { TransactionBase } from '../transactions/Transaction.js';
+import { BlockHeaderChecksumProof, IBlock } from './interfaces/IBlock.js';
 export declare class Block implements IBlock {
     readonly height: BigNumberish;
     readonly hash: string;
@@ -21,7 +21,6 @@ export declare class Block implements IBlock {
     readonly storageRoot: string;
     readonly receiptRoot: string;
     readonly checksumProofs: BlockHeaderChecksumProof;
-    readonly transactions?: TransactionBase<OPNetTransactionTypes>[];
+    readonly transactions: TransactionBase<OPNetTransactionTypes>[];
     constructor(block: IBlock);
-    private getTransactions;
 }

package/cjs/block/Block.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Block = void 0;
-const OPNetTransactionTypes_js_1 = require("../interfaces/opnet/OPNetTransactionTypes.js");
-const DeploymentTransaction_js_1 = require("../transactions/DeploymentTransaction.js");
-const GenericTransaction_js_1 = require("../transactions/GenericTransaction.js");
-const InteractionTransaction_js_1 = require("../transactions/InteractionTransaction.js");
+const TransactionParser_js_1 = require("../transactions/TransactionParser.js");
 class Block {
     height;
     hash;
@@ -24,7 +21,7 @@ class Block {
     storageRoot;
     receiptRoot;
     checksumProofs;
-    transactions;
+    transactions = [];
     constructor(block) {
         this.height = BigInt(block.height.toString());
         this.hash = block.hash;
@@ -44,29 +41,7 @@ class Block {
         this.storageRoot = block.storageRoot;
         this.receiptRoot = block.receiptRoot;
         this.checksumProofs = block.checksumProofs;
-        this.transactions = this.getTransactions(block.transactions);
-    }
-    getTransactions(transactions) {
-        if (!transactions) {
-            return [];
-        }
-        const transactionArray = [];
-        for (let transaction of transactions) {
-            switch (transaction.OPNetType) {
-                case OPNetTransactionTypes_js_1.OPNetTransactionTypes.Generic:
-                    transactionArray.push(new GenericTransaction_js_1.GenericTransaction(transaction));
-                    break;
-                case OPNetTransactionTypes_js_1.OPNetTransactionTypes.Interaction:
-                    transactionArray.push(new InteractionTransaction_js_1.InteractionTransaction(transaction));
-                    break;
-                case OPNetTransactionTypes_js_1.OPNetTransactionTypes.Deployment:
-                    transactionArray.push(new DeploymentTransaction_js_1.DeploymentTransaction(transaction));
-                    break;
-                default:
-                    throw new Error('Unknown transaction type');
-            }
-        }
-        return transactionArray;
+        this.transactions = TransactionParser_js_1.TransactionParser.parseTransactions(block.transactions);
     }
 }
 exports.Block = Block;

package/cjs/block/interfaces/IBlock.d.ts

@@ -0,0 +1,28 @@
+import { BigNumberish } from 'ethers';
+import { OPNetTransactionTypes } from '../../interfaces/opnet/OPNetTransactionTypes.js';
+import { ITransaction } from '../../transactions/interfaces/ITransaction.js';
+import { TransactionBase } from '../../transactions/Transaction.js';
+export type BlockHeaderChecksumProof = Array<[number, string[]]>;
+export interface IBlockCommon {
+    height: string | BigNumberish;
+    hash: string;
+    previousBlockHash: string;
+    previousBlockChecksum: string;
+    bits: string;
+    nonce: number;
+    version: number;
+    size: number;
+    txCount: number;
+    weight: number;
+    strippedSize: number;
+    time: number;
+    medianTime: number;
+    checksumRoot: string;
+    merkleRoot: string;
+    storageRoot: string;
+    receiptRoot: string;
+    checksumProofs: BlockHeaderChecksumProof;
+}
+export interface IBlock extends IBlockCommon {
+    transactions?: ITransaction[] | TransactionBase<OPNetTransactionTypes>[];
+}

package/cjs/block/interfaces/IBlock.js

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

package/cjs/common/CommonTypes.d.ts

@@ -0,0 +1,4 @@
+import { BitcoinAddress } from '../bitcoin/BitcoinAddress.js';
+export type BitcoinAddressLike = string | BitcoinAddress;
+export type PointerLike = bigint | string;
+export type DecodedCallResult = bigint | string | boolean | number | Uint8Array | Array<bigint> | Array<string> | Array<boolean> | Array<number> | Array<Uint8Array>;

package/cjs/common/CommonTypes.js

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

package/cjs/contracts/CallResult.d.ts

@@ -0,0 +1,13 @@
+import { BinaryReader, NetEvent } from '@btc-vision/bsi-binary';
+import { DecodedCallResult } from '../common/CommonTypes.js';
+import { IAccessList } from './interfaces/IAccessList.js';
+import { ICallResultData } from './interfaces/ICallResult.js';
+export declare class CallResult implements ICallResultData {
+    readonly result: BinaryReader;
+    readonly events: NetEvent[];
+    readonly accessList: IAccessList;
+    readonly decoded: Array<DecodedCallResult>;
+    constructor(iCallResult: ICallResultData);
+    setDecoded(decoded: Array<DecodedCallResult>): void;
+    private base64ToUint8Array;
+}

package/cjs/contracts/CallResult.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallResult = void 0;
+const bsi_binary_1 = require("@btc-vision/bsi-binary");
+class CallResult {
+    result;
+    events;
+    accessList;
+    decoded = [];
+    constructor(iCallResult) {
+        this.events = iCallResult.events;
+        this.accessList = iCallResult.accessList;
+        this.result =
+            typeof iCallResult.result === 'string'
+                ? new bsi_binary_1.BinaryReader(this.base64ToUint8Array(iCallResult.result))
+                : iCallResult.result;
+    }
+    setDecoded(decoded) {
+        this.decoded.push(...decoded);
+    }
+    base64ToUint8Array(base64) {
+        return bsi_binary_1.BufferHelper.bufferToUint8Array(Buffer.from(base64, 'base64'));
+    }
+}
+exports.CallResult = CallResult;

package/cjs/contracts/Contract.d.ts

@@ -0,0 +1,28 @@
+import { BaseContractProperty } from '../abi/BaseContractProperty.js';
+import { BitcoinInterface } from '../abi/BitcoinInterface.js';
+import { BaseContractProperties } from '../abi/interfaces/BaseContractProperties.js';
+import { BitcoinInterfaceAbi } from '../abi/interfaces/BitcoinInterfaceAbi.js';
+import { BitcoinAddressLike } from '../common/CommonTypes.js';
+import { AbstractRpcProvider } from '../providers/AbstractRpcProvider.js';
+import { IContract } from './interfaces/IContract.js';
+declare const internal: unique symbol;
+export declare class IBaseContract<T extends BaseContractProperties> implements IContract {
+    readonly address: BitcoinAddressLike;
+    readonly interface: BitcoinInterface;
+    readonly provider: AbstractRpcProvider;
+    readonly [internal]: keyof T | undefined;
+    private events;
+    constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider);
+    protected getFunction(name: symbol): BaseContractProperty | undefined | string | number | symbol;
+    private defineInternalFunctions;
+    private encodeFunctionData;
+    private encodeInput;
+    private decodeOutput;
+    private callFunction;
+}
+export declare class BaseContract<T extends BaseContractProperties> extends IBaseContract<T> {
+    constructor(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider);
+    private proxify;
+}
+export declare function getContract<T extends BaseContractProperties>(address: BitcoinAddressLike, abi: BitcoinInterface | BitcoinInterfaceAbi, provider: AbstractRpcProvider): BaseContract<T> & Omit<T, keyof BaseContract<T>>;
+export {};