@multiplechain/bitcoin 0.1.18 → 0.4.0

package/dist/models/CoinTransaction.d.ts

@@ -0,0 +1,24 @@
+import { TransactionStatusEnum, AssetDirectionEnum, WalletAddress, CoinTransactionInterface, TransferAmount } from '@multiplechain/types';
+import { Transaction } from './Transaction.ts';
+
+export declare class CoinTransaction extends Transaction implements CoinTransactionInterface {
+    /**
+     * @returns {Promise<WalletAddress>} Wallet address of the receiver of transaction
+     */
+    getReceiver(): Promise<WalletAddress>;
+    /**
+     * @returns {Promise<WalletAddress>} Wallet address of the sender of transaction
+     */
+    getSender(): Promise<WalletAddress>;
+    /**
+     * @returns {Promise<TransferAmount>} Amount of coin that will be transferred
+     */
+    getAmount(): Promise<TransferAmount>;
+    /**
+     * @param {AssetDirectionEnum} direction - Direction of the transaction (asset)
+     * @param {WalletAddress} address - Wallet address of the receiver or sender of the transaction, dependant on direction
+     * @param {TransferAmount} amount Amount of assets that will be transferred
+     * @returns {Promise<TransactionStatusEnum>} Status of the transaction
+     */
+    verifyTransfer(direction: AssetDirectionEnum, address: WalletAddress, amount: TransferAmount): Promise<TransactionStatusEnum>;
+}

package/dist/models/Transaction.d.ts

@@ -0,0 +1,106 @@
+import { TransactionStatusEnum, TransactionTypeEnum, BlockConfirmationCount, BlockNumber, BlockTimestamp, TransactionFee, TransactionId, TransactionInterface, WalletAddress } from '@multiplechain/types';
+import { Provider } from '../services/Provider.ts';
+
+export interface VinObject {
+    txid: string;
+    vout: number;
+    prevout: {
+        scriptpubkey: string;
+        scriptpubkey_asm: string;
+        scriptpubkey_type: string;
+        scriptpubkey_address: string;
+        value: number;
+    };
+    scriptsig: string;
+    scriptsig_asm: string;
+    witness: string[];
+    is_coinbase: boolean;
+    sequence: number;
+}
+export interface VoutObject {
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_type: string;
+    scriptpubkey_address: string;
+    value: number;
+}
+export interface TransactionData {
+    txid: string;
+    version: number;
+    locktime: number;
+    vin: VinObject[];
+    vout: VoutObject[];
+    size: number;
+    weight: number;
+    fee: number;
+    status: {
+        confirmed: boolean;
+        block_height: number;
+        block_hash: string;
+        block_time: number;
+    };
+}
+export declare class Transaction implements TransactionInterface<TransactionData> {
+    /**
+     * Each transaction has its own unique ID defined by the user
+     */
+    id: TransactionId;
+    /**
+     * Blockchain network provider
+     */
+    provider: Provider;
+    /**
+     * Transaction data
+     */
+    data: TransactionData | null;
+    /**
+     * @param {TransactionId} id Transaction id
+     * @param {Provider} provider Blockchain network provider
+     */
+    constructor(id: TransactionId, provider?: Provider);
+    /**
+     * @returns {Promise<TransactionData | null>} Transaction data
+     */
+    getData(): Promise<TransactionData | null>;
+    /**
+     * @param {number} ms - Milliseconds to wait for the transaction to be confirmed. Default is 4000ms
+     * @returns {Promise<TransactionStatusEnum>} Status of the transaction
+     */
+    wait(ms?: number): Promise<TransactionStatusEnum>;
+    /**
+     * @returns {TransactionId} Transaction ID
+     */
+    getId(): TransactionId;
+    /**
+     * @returns {Promise<TransactionTypeEnum>} Transaction type
+     */
+    getType(): Promise<TransactionTypeEnum>;
+    /**
+     * @returns {string} Transaction URL
+     */
+    getUrl(): string;
+    /**
+     * @returns {Promise<WalletAddress>} Wallet address of the sender of transaction
+     */
+    getSigner(): Promise<WalletAddress>;
+    /**
+     * @returns {Promise<TransactionFee>} Transaction fee
+     */
+    getFee(): Promise<TransactionFee>;
+    /**
+     * @returns {Promise<BlockNumber>} Block number that transaction
+     */
+    getBlockNumber(): Promise<BlockNumber>;
+    /**
+     * @returns {Promise<BlockTimestamp>} Block timestamp that transaction
+     */
+    getBlockTimestamp(): Promise<BlockTimestamp>;
+    /**
+     * @returns {Promise<BlockConfirmationCount>} Confirmation count of the block
+     */
+    getBlockConfirmationCount(): Promise<BlockConfirmationCount>;
+    /**
+     * @returns {Promise<TransactionStatusEnum>} Status of the transaction
+     */
+    getStatus(): Promise<TransactionStatusEnum>;
+}

package/dist/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Transaction.ts';
+export * from './CoinTransaction.ts';

package/dist/services/Provider.d.ts

@@ -0,0 +1,80 @@
+import { ProviderInterface } from '@multiplechain/types';
+
+export interface BitcoinNetworkConfigInterface {
+    testnet: boolean;
+    blockCypherToken?: string;
+}
+export declare class Provider implements ProviderInterface<BitcoinNetworkConfigInterface> {
+    /**
+     * Network configuration of the provider
+     */
+    network: BitcoinNetworkConfigInterface;
+    /**
+     * API URL
+     */
+    api: string;
+    /**
+     * Explorer URL
+     */
+    explorer: string;
+    /**
+     * Websocket URL
+     */
+    wsUrl: string;
+    /**
+     * BlockCypher token
+     */
+    blockCypherToken?: string;
+    /**
+     * Default BlockCypher token
+     */
+    defaultBlockCypherToken: string;
+    /**
+     * Static instance of the provider
+     */
+    private static _instance;
+    /**
+     * @param network - Network configuration of the provider
+     */
+    constructor(network: BitcoinNetworkConfigInterface);
+    /**
+     * Get the static instance of the provider
+     * @returns {Provider} Provider
+     */
+    static get instance(): Provider;
+    /**
+     * Initialize the static instance of the provider
+     * @param {BitcoinNetworkConfigInterface} network - Network configuration of the provider
+     * @returns {void}
+     */
+    static initialize(network: BitcoinNetworkConfigInterface): void;
+    /**
+     * Check RPC connection
+     * @param {string} url - RPC URL
+     * @returns {Promise<boolean | Error>}
+     */
+    checkRpcConnection(url?: string): Promise<boolean | Error>;
+    /**
+     * Check WS connection
+     * @param {string} url - Websocket URL
+     * @returns {Promise<boolean | Error>}
+     */
+    checkWsConnection(url?: string): Promise<boolean | Error>;
+    /**
+     * Update network configuration of the provider
+     * @param {BitcoinNetworkConfigInterface} network - Network configuration
+     * @returns {void}
+     */
+    update(network: BitcoinNetworkConfigInterface): void;
+    /**
+     * Create a new endpoint
+     * @param {string} endpoint - Endpoint
+     * @returns {string} Endpoint
+     */
+    createEndpoint(endpoint: string): string;
+    /**
+     * Get the current network configuration is testnet or not
+     * @returns {boolean} Testnet or not
+     */
+    isTestnet(): boolean;
+}

package/dist/services/TransactionListener.d.ts

@@ -0,0 +1,120 @@
+import { CoinTransaction } from '../models/CoinTransaction.ts';
+import { Transaction } from '../models/Transaction.ts';
+import { Provider } from './Provider.ts';
+import { default as WebSocket } from 'ws';
+import { TransactionTypeEnum, DynamicTransactionType, TransactionListenerInterface, DynamicTransactionListenerFilterType, TransactionId } from '@multiplechain/types';
+
+interface Values {
+    txId: string;
+    amount?: number;
+    sender?: string;
+    receiver?: string;
+}
+type TransactionListenerTriggerType<T extends TransactionTypeEnum> = DynamicTransactionType<T, Transaction, Transaction, CoinTransaction, Transaction, Transaction>;
+type TransactionListenerCallbackType<T extends TransactionTypeEnum, Transaction = TransactionListenerTriggerType<T>> = (transaction: Transaction) => void;
+export declare class TransactionListener<T extends TransactionTypeEnum, DTransaction extends TransactionListenerTriggerType<T>, CallBackType extends TransactionListenerCallbackType<T>> implements TransactionListenerInterface<T, DTransaction, CallBackType> {
+    /**
+     * Transaction type
+     */
+    type: T;
+    /**
+     * Provider
+     */
+    provider: Provider;
+    /**
+     * Listener status
+     */
+    status: boolean;
+    /**
+     * Transaction listener callback
+     */
+    callbacks: CallBackType[];
+    /**
+     * Triggered transactions
+     */
+    triggeredTransactions: TransactionId[];
+    /**
+     * Transaction listener filter
+     */
+    filter?: DynamicTransactionListenerFilterType<T> | Record<string, never>;
+    /**
+     * WebSocket
+     */
+    webSocket: WebSocket;
+    /**
+     * Dynamic stop method
+     */
+    dynamicStop: () => void;
+    /**
+     * @param {T} type - Transaction type
+     * @param {DynamicTransactionListenerFilterType<T>} filter - Transaction listener filter
+     * @param {Provider} provider - Provider
+     */
+    constructor(type: T, filter?: DynamicTransactionListenerFilterType<T>, provider?: Provider);
+    /**
+     * Close the listener
+     * @returns {void}
+     */
+    stop(): void;
+    /**
+     * Start the listener
+     * @returns {void}
+     */
+    start(): void;
+    /**
+     * Get the listener status
+     * @returns {boolean} Listener status
+     */
+    getStatus(): boolean;
+    /**
+     * Listen to the transaction events
+     * @param {CallBackType} callback - Transaction listener callback
+     * @returns {Promise<boolean>}
+     */
+    on(callback: CallBackType): Promise<boolean>;
+    /**
+     * Trigger the event when a transaction is detected
+     * @param {TransactionListenerTriggerType<T>} transaction - Transaction data
+     * @returns {void}
+     */
+    trigger<T extends TransactionTypeEnum>(transaction: TransactionListenerTriggerType<T>): void;
+    isBlockCypherProcess(): boolean;
+    /**
+     * Create message for the listener
+     * @param {string} receiver - Receiver address
+     * @returns {string} Message
+     */
+    createMessage(receiver?: string): string;
+    /**
+     * Parse the data
+     * @param {any} data - Data
+     * @returns {Values} Parsed data
+     */
+    getValues(data: any): Values;
+    /**
+     * General transaction process
+     * @returns {void}
+     */
+    generalProcess(): void;
+    /**
+     * Contract transaction process
+     * @returns {void}
+     */
+    contractProcess(): void;
+    /**
+     * Coin transaction process
+     * @returns {void}
+     */
+    coinProcess(): void;
+    /**
+     * Token transaction process
+     * @returns {void}
+     */
+    tokenProcess(): void;
+    /**
+     * NFT transaction process
+     * @returns {void}
+     */
+    nftProcess(): void;
+}
+export {};

package/dist/services/TransactionSigner.d.ts

@@ -0,0 +1,50 @@
+import { PrivateKey, TransactionId, TransactionSignerInterface } from '@multiplechain/types';
+import { Transaction as BitcoreLibTransactionData } from 'bitcore-lib';
+import { Provider } from '../services/Provider.ts';
+
+export interface TransactionData {
+    sender: string;
+    receiver: string;
+    amount: number;
+    bitcoreLib: BitcoreLibTransactionData;
+}
+export declare class TransactionSigner implements TransactionSignerInterface<TransactionData, string> {
+    /**
+     * Transaction data from the blockchain network
+     */
+    rawData: TransactionData;
+    /**
+     * Signed transaction data
+     */
+    signedData?: string;
+    /**
+     * Blockchain network provider
+     */
+    provider: Provider;
+    /**
+     * @param {TransactionData} rawData - Transaction data
+     * @param {Provider} provider - Blockchain network provider
+     */
+    constructor(rawData: TransactionData, provider?: Provider);
+    /**
+     * Sign the transaction
+     * @param {PrivateKey} privateKey - Transaction data
+     * @returns {Promise<this>} Signed transaction data
+     */
+    sign(privateKey: PrivateKey): Promise<this>;
+    /**
+     * Send the transaction to the blockchain network
+     * @returns {Promise<TransactionId>}
+     */
+    send(): Promise<TransactionId>;
+    /**
+     * Get the raw transaction data
+     * @returns {TransactionData}
+     */
+    getRawData(): TransactionData;
+    /**
+     * Get the signed transaction data
+     * @returns {string}
+     */
+    getSignedData(): string;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './TransactionSigner.ts';
+export * from './TransactionListener.ts';

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export * from '@multiplechain/utils';
+export declare const fromSatoshi: (amount: number) => number;
+export declare const toSatoshi: (amount: number) => number;

package/package.json

@@ -1,50 +1,85 @@
-{
-  "namespace": "multiplechain",
-  "name": "@multiplechain/bitcoin",
-  "version": "0.1.18",
-  "description": "Bitcoin JS provider",
-  "scripts": {
-    "serve": "parcel test.html --no-cache --dist-dir test",
-    "build": "webpack"
-  },
-  "files": [
-    "src",
-    "dist"
-  ],
-  "main": "src/bitcoin-provider.js",
-  "types": "index.d.ts",
-  "typings": "index.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MultipleChain/bitcoin.git"
-  },
-  "keywords": [
-    "Blockchain",
-    "Bitcoin",
-    "Cryptocurrency"
-  ],
-  "author": "MultipleChain",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/MultipleChain/bitcoin/issues"
-  },
-  "homepage": "https://github.com/MultipleChain/bitcoin",
-  "dependencies": {
-    "@multiplechain/utils": "^0.1.1",
-    "bignumber.js": "^9.1.1",
-    "install": "^0.13.0",
-    "npm": "^9.7.2",
-    "sats-connect": "^1.1.1",
-    "web3-utils": "^1.8.1",
-    "ws": "^8.13.0"
-  },
-  "devDependencies": {
-    "assert": "^2.0.0",
-    "buffer": "^5.7.1",
-    "events": "^3.3.0",
-    "process": "^0.11.10",
-    "stream-browserify": "^3.0.0",
-    "webpack": "^5.76.0",
-    "webpack-cli": "^5.0.1"
-  }
-}
+{
+    "name": "@multiplechain/bitcoin",
+    "version": "0.4.0",
+    "type": "module",
+    "main": "dist/index.cjs",
+    "module": "dist/index.es.js",
+    "unpkg": "dist/index.umd.js",
+    "browser": "dist/index.umd.js",
+    "jsdelivr": "dist/index.umd.js",
+    "exports": {
+        ".": {
+            "import": {
+                "default": "./dist/index.es.js",
+                "types": "./dist/browser/index.d.ts"
+            },
+            "require": {
+                "default": "./dist/index.cjs",
+                "types": "./dist/index.d.ts"
+            }
+        },
+        "./node": {
+            "default": "./dist/index.cjs",
+            "types": "./dist/index.d.ts"
+        },
+        "./browser": {
+            "default": "./dist/index.es.js",
+            "types": "./dist/browser/index.d.ts"
+        }
+    },
+    "typesVersions": {
+        "*": {
+            "node": [
+                "./dist/index.d.ts"
+            ],
+            "browser": [
+                "./dist/browser/index.d.ts"
+            ]
+        }
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "!tsconfig.tsbuildinfo"
+    ],
+    "scripts": {
+        "dev": "vite",
+        "clean": "rm -rf dist",
+        "watch": "tsc --watch",
+        "build:vite": "vite build",
+        "build:node": "tsx esbuild.ts",
+        "typecheck": "tsc --noEmit",
+        "lint": "eslint . --ext .ts",
+        "test": "vitest run --dir tests",
+        "test-ui": "vitest watch --ui",
+        "prepublishOnly": "pnpm run build",
+        "build": "pnpm run build:vite && pnpm run build:node"
+    },
+    "keywords": [
+        "web3",
+        "crypto",
+        "blockchain",
+        "multiple-chain"
+    ],
+    "author": "MultipleChain",
+    "license": "MIT",
+    "homepage": "https://github.com/MultipleChain/js/tree/master/packages/networks/network-name",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/MultipleChain/js.git"
+    },
+    "bugs": {
+        "url": "https://github.com/MultipleChain/js/issues"
+    },
+    "dependencies": {
+        "@multiplechain/types": "^0.1.63",
+        "@multiplechain/utils": "^0.1.21",
+        "axios": "^1.6.8",
+        "bitcore-lib": "^10.0.28",
+        "sats-connect": "^2.3.1",
+        "ws": "^8.17.0"
+    },
+    "devDependencies": {
+        "@types/bitcore-lib": "^0.15.6"
+    }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 MultipleChain
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.