@teleportdao/bitcoin 1.4.3 → 1.4.6

package/dist/bitcoin-utils.d.ts

@@ -1,48 +1,43 @@
-export function parseRawTransaction(rawTransaction: any): {
-    version: any;
-    flag: any;
+/// <reference types="node" />
+import networks from "./utils/networks";
+import * as bitcoin from "bitcoinjs-lib";
+export { networks };
+export declare function generateMnemonic(): string;
+export declare function parseRawTransaction(rawTransaction: string): {
+    version: string;
+    flag: string;
     vin: string;
     vout: string;
     witness: string;
     locktime: string;
 };
-export function calculateMerkleProof(blockTransactions: any, txId: any, blockMerkleRoot?: undefined): {
-    intermediateNodes: any;
-    transactionIndex: any;
+export declare function reverseBytes(hexInput: string): string;
+export declare function getPublicKeyHexByXpubAndIndex(xpub: string, index?: number, isChange?: boolean, network?: bitcoin.networks.Network): string;
+export declare function getPubKeyFromPrivateKeyWIF(privateKeyWIF: string, network?: bitcoin.networks.Network): Buffer;
+export declare function getPubKeyFromPrivateKeyHex(privateKeyHex: string, network?: bitcoin.networks.Network): Buffer;
+export declare function getPrivateKeyHexFromWIF(privateKeyWIF: string, network?: bitcoin.networks.Network): string;
+export declare function calculateMerkleProof(blockTransactions: string[], txId: string, blockMerkleRoot?: string): {
+    intermediateNodes: string;
+    transactionIndex: number;
 };
-export function createAddressObjectByHash({ addressType, hash }: {
-    addressType: any;
-    hash: any;
-}, network?: bitcoin.networks.Network): bitcoin.payments.Payment;
-export function createAddressObjectByPublicKey({ addressType, publicKey }: {
-    addressType: any;
-    publicKey: any;
-}, network?: bitcoin.networks.Network): bitcoin.payments.Payment;
-export function createAddressObjectByAddress(address: any, network?: bitcoin.networks.Network): {
-    addressObject: bitcoin.payments.Payment;
-    addressType: "p2wpkh" | "p2sh" | "p2pkh";
+export declare function parseBlockHeader(headerHex: string): {
+    version: string;
+    previousBlockHash: string;
+    merkleRoot: string;
+    timestamp: string;
+    difficulty: string;
+    nonce: string;
 };
-export function createAddressObjectByScript({ addressType, script }: {
-    addressType: any;
-    script: any;
-}, network?: bitcoin.networks.Network): bitcoin.payments.Payment;
-export function getAddressType(address: any, network?: bitcoin.networks.Network): "p2wpkh" | "p2sh" | "p2pkh";
-export function getPubKeyFromPrivateKeyWIF(privateKeyWIF: any, network?: bitcoin.networks.Network): Buffer;
-export function getPubKeyFromPrivateKeyHex(privateKeyHex: any, network?: bitcoin.networks.Network): Buffer;
-export function getPublicKeyHexByXpubAndIndex(xpub: any, index?: number, isChange?: boolean, network?: bitcoin.networks.Network): string;
-export function getPrivateKeyHexFromWIF(privateKeyWIF: any, network?: bitcoin.networks.Network): string;
-export function reverseBytes(hexInput: any): string;
-export function parseBlockHeader(headerHex: any): {};
-export function generateMnemonic(): string;
-export function parseRawBlock(rawBlockHex: any, blockNumber?: undefined, network?: any): {
-    blockNumber: undefined;
+export declare function convertBitcoinScriptToAddress(script: Buffer, network?: bitcoin.networks.Network): string | null;
+export declare function parseRawBlock(rawBlockHex: string, blockNumber?: number, network?: bitcoin.networks.Network): {
+    blockNumber: number | undefined;
     merkleRoot: string;
     prvBlockHash: string;
     transactions: {
         txId: string;
         version: number;
         locktime: number;
-        blockNumber: undefined;
+        blockNumber: number | undefined;
         blockHash: string;
         vout: {
             address: string | null;
@@ -54,20 +49,95 @@ export function parseRawBlock(rawBlockHex: any, blockNumber?: undefined, network
             txId: string;
             index: number;
         }[];
-    }[];
+    }[] | undefined;
 };
-export function extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex: any, blockNumber: any, addresses?: any[], inputTxIds?: any[], network?: bitcoin.networks.Network): {
+export declare function extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex: string, blockNumber: number, addresses?: string[], inputTxIds?: {
+    txId: string;
+    index: number;
+    address?: string;
+    script?: string;
+    value?: number;
+}[], network?: bitcoin.networks.Network): {
     blockInfo: {
-        blockNumber: any;
+        blockNumber: number;
         blockHash: string;
         merkleRoot: string;
         prvBlockHash: string;
     };
-    withdrawTxs: any[];
-    depositTxs: any[];
+    withdrawTxs: {
+        txId: string;
+        version: number;
+        locktime: number;
+        blockNumber: number;
+        blockHash: string;
+        merkleProof: {
+            intermediateNodes: string;
+            transactionIndex: number;
+        };
+        vout: {
+            address: string | null;
+            script: string;
+            value: number;
+        }[];
+        vin: {
+            txId: string;
+            index: number;
+            address?: string | null;
+            script?: string | null;
+            value?: number | null;
+        }[];
+        address: string;
+        addressScript: string;
+    }[];
+    depositTxs: {
+        txId: string;
+        version: number;
+        locktime: number;
+        blockNumber: number;
+        blockHash: string;
+        merkleProof: {
+            intermediateNodes: string;
+            transactionIndex: number;
+        };
+        vout: {
+            address: string | null;
+            script: string;
+            value: number;
+        }[];
+        vin: {
+            txId: string;
+            index: number;
+            address?: string | null;
+            script?: string | null;
+            value?: number | null;
+        }[];
+        address: string;
+        addressScript: string;
+    }[];
+};
+export declare function validateAddress(address: string, network?: bitcoin.networks.Network): boolean;
+export declare function getAddressType(address: string, network?: bitcoin.networks.Network): "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
+export declare function createAddressObjectByScript({ addressType, script }: {
+    addressType: string;
+    script: Buffer;
+}, network?: bitcoin.Network): bitcoin.payments.Payment;
+export declare function createAddressObjectByHash({ addressType, hash }: {
+    addressType: string;
+    hash: Buffer;
+}, network?: bitcoin.Network): bitcoin.payments.Payment;
+export declare function createAddressObjectByPublicKey({ addressType, publicKey }: {
+    addressType: string;
+    publicKey: Buffer;
+}, network?: bitcoin.Network): bitcoin.payments.Payment;
+export declare function createAddressObjectByAddress(address: string, network?: bitcoin.networks.Network): {
+    addressObject: bitcoin.payments.Payment;
+    addressType: "p2wpkh" | "p2sh" | "p2pkh";
+};
+export declare function publicKeyConvertor(publicKeyHex: string, compressed?: boolean): string;
+export declare const addressTypeHelper: {
+    addressTypesNumber: {
+        [key: string]: number;
+    };
+    addressTypes: string[];
 };
-export function validateAddress(address: any, network?: bitcoin.networks.Network): boolean;
-import networks = require("./utils/networks");
-import bitcoin = require("bitcoinjs-lib");
-export { networks };
 //# sourceMappingURL=bitcoin-utils.d.ts.map

package/dist/bitcoin-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitcoin-utils.d.ts","sourceRoot":"","sources":["../src/bitcoin-utils.js"],"names":[],"mappings":"AAcA;;;;;;;EAsDC;AAqKD;;;EA2BC;AA1KD;;;iEAyBC;AA6BD;;;iEA+BC;AAED;;;EA0BC;AAtFD;;;iEAyBC;AApED,8GAcC;AAkID,2GAGC;AAED,2GAGC;AArBD,yIAWC;AAYD,wGAGC;AAjKD,oDAEC;AA8LD,qDAgBC;AA7QD,2CAGC;AAoRD;;;;;;;;;;;;;;;;;;;;;EA2BC;AAED;;;;;;;;;EAsHC;AAED,2FAiBC"}
+{"version":3,"file":"bitcoin-utils.d.ts","sourceRoot":"","sources":["../src/bitcoin-utils.ts"],"names":[],"mappings":"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"}

package/dist/bitcoin-utils.js

@@ -1,16 +1,47 @@
 "use strict";
-const bip39 = require("bip39");
-const bip32 = require("bip32");
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressTypeHelper = exports.publicKeyConvertor = exports.createAddressObjectByAddress = exports.createAddressObjectByPublicKey = exports.createAddressObjectByHash = exports.createAddressObjectByScript = exports.getAddressType = exports.validateAddress = exports.extractTransactionsAndBlockInfoFromRawBlock = exports.parseRawBlock = exports.convertBitcoinScriptToAddress = exports.parseBlockHeader = exports.calculateMerkleProof = exports.getPrivateKeyHexFromWIF = exports.getPubKeyFromPrivateKeyHex = exports.getPubKeyFromPrivateKeyWIF = exports.getPublicKeyHexByXpubAndIndex = exports.reverseBytes = exports.parseRawTransaction = exports.generateMnemonic = exports.networks = void 0;
+const bip39 = __importStar(require("bip39"));
+const bip32 = __importStar(require("bip32"));
+const networks_1 = __importDefault(require("./utils/networks"));
+exports.networks = networks_1.default;
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+const ECPair = bitcoin.ECPair;
 let varUnit = require("varuint-bitcoin");
 const fastRoot = require("merkle-lib/fastRoot");
 const merkle = require("merkle-lib");
 const merkleProof = require("merkle-lib/proof");
-const bitcoin = require("bitcoinjs-lib");
-const networks = require("./utils/networks");
 function generateMnemonic() {
     const mnemonic = bip39.generateMnemonic(256);
     return mnemonic;
 }
+exports.generateMnemonic = generateMnemonic;
 function parseRawTransaction(rawTransaction) {
     const size = {
         version: 4,
@@ -59,156 +90,42 @@ function parseRawTransaction(rawTransaction) {
     let locktime = `0x${rawTransaction.slice(rawTransaction.length - 8, rawTransaction.length)}`;
     return { version, flag, vin, vout, witness, locktime };
 }
+exports.parseRawTransaction = parseRawTransaction;
 function reverseBytes(hexInput) {
     return Buffer.from(hexInput, "hex").reverse().toString("hex");
 }
-function getAddressType(address, network = bitcoin.networks.bitcoin) {
-    if (address.startsWith(network.bech32)) {
-        return "p2wpkh";
-    }
-    let base58Data = bitcoin.address.fromBase58Check(address);
-    if (base58Data.version === Number(network.scriptHash)) {
-        return "p2sh";
-    }
-    if (base58Data.version === Number(network.pubKeyHash)) {
-        return "p2pkh";
-    }
-    throw new Error("invalid address");
-}
-function createAddressObjectByHash({ addressType, hash }, network = bitcoin.networks.bitcoin) {
-    let addressObject;
-    switch (addressType) {
-        case "p2pkh":
-            addressObject = bitcoin.payments.p2pkh({
-                hash,
-                network,
-            });
-            break;
-        case "p2wpkh":
-            addressObject = bitcoin.payments.p2wpkh({
-                hash,
-                network,
-            });
-            break;
-        case "p2sh":
-            addressObject = bitcoin.payments.p2sh({
-                hash,
-                network,
-            });
-            break;
-        default:
-            throw new Error("address type is incorrect");
-    }
-    return addressObject;
-}
-function createAddressObjectByScript({ addressType, script }, network = bitcoin.networks.bitcoin) {
-    let addressObject;
-    switch (addressType) {
-        case "p2pkh":
-            addressObject = bitcoin.payments.p2pkh({
-                output: script,
-                network,
-            });
-            break;
-        case "p2wpkh":
-            addressObject = bitcoin.payments.p2wpkh({
-                output: script,
-                network,
-            });
-            break;
-        case "p2sh":
-            addressObject = bitcoin.payments.p2sh({
-                output: script,
-                network,
-            });
-            break;
-        default:
-            throw new Error("address type is incorrect");
-    }
-    return addressObject;
-}
-function createAddressObjectByPublicKey({ addressType, publicKey }, network = bitcoin.networks.bitcoin) {
-    let addressObject;
-    switch (addressType) {
-        case "p2pkh":
-            addressObject = bitcoin.payments.p2pkh({
-                pubkey: publicKey,
-                network,
-            });
-            break;
-        case "p2wpkh":
-            addressObject = bitcoin.payments.p2wpkh({
-                pubkey: publicKey,
-                network,
-            });
-            break;
-        case "p2sh-p2wpkh":
-            addressObject = bitcoin.payments.p2sh({
-                redeem: bitcoin.payments.p2wpkh({
-                    pubkey: publicKey,
-                    network,
-                }),
-            });
-            break;
-        default:
-            throw new Error("address type is incorrect");
-    }
-    return addressObject;
-}
-function createAddressObjectByAddress(address, network = bitcoin.networks.bitcoin) {
-    let addressType = getAddressType(address, network);
-    let addressObject;
-    switch (addressType) {
-        case "p2pkh":
-            addressObject = bitcoin.payments.p2pkh({
-                address,
-                network,
-            });
-            break;
-        case "p2wpkh":
-            addressObject = bitcoin.payments.p2wpkh({
-                address,
-                network,
-            });
-            break;
-        case "p2sh":
-            addressObject = bitcoin.payments.p2sh({
-                address,
-                network,
-            });
-            break;
-        default:
-            throw new Error("address type is incorrect");
-    }
-    return { addressObject, addressType };
-}
-function getPublicKeyHexByXpubAndIndex(xpub, index = 0, isChange = false, network = networks.bitcoin) {
+exports.reverseBytes = reverseBytes;
+function getPublicKeyHexByXpubAndIndex(xpub, index = 0, isChange = false, network = networks_1.default.bitcoin) {
     const node = bip32.fromBase58(xpub, network);
     return node
         .derive(isChange ? 1 : 0)
         .derive(index)
         .publicKey.toString("hex");
 }
+exports.getPublicKeyHexByXpubAndIndex = getPublicKeyHexByXpubAndIndex;
 function getPubKeyFromPrivateKeyWIF(privateKeyWIF, network = bitcoin.networks.bitcoin) {
     let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network);
     return key.publicKey;
 }
+exports.getPubKeyFromPrivateKeyWIF = getPubKeyFromPrivateKeyWIF;
 function getPubKeyFromPrivateKeyHex(privateKeyHex, network = bitcoin.networks.bitcoin) {
-    let key = bitcoin.ECPair.fromPrivateKey(Buffer.from(privateKeyHex, "hex"), network);
+    let key = bitcoin.ECPair.fromPrivateKey(Buffer.from(privateKeyHex, "hex"), { network });
     return key.publicKey;
 }
+exports.getPubKeyFromPrivateKeyHex = getPubKeyFromPrivateKeyHex;
 function getPrivateKeyHexFromWIF(privateKeyWIF, network = bitcoin.networks.bitcoin) {
     let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network);
     return key.privateKey.toString("hex");
 }
-function calculateMerkleProof(blockTransactions, txId, blockMerkleRoot = undefined) {
+exports.getPrivateKeyHexFromWIF = getPrivateKeyHexFromWIF;
+function calculateMerkleProof(blockTransactions, txId, blockMerkleRoot) {
     let transactionIndex = blockTransactions.findIndex((tx) => tx === txId);
     if (transactionIndex < 0)
         throw new Error("txId is not in this tree");
     let data = blockTransactions.map((a) => Buffer.from(a, "hex").reverse());
     if (blockMerkleRoot &&
         blockMerkleRoot !== fastRoot(data, bitcoin.crypto.hash256).toString("hex")) {
-        throw new Error("calculated anf block merkleRoot not matched");
+        throw new Error("calculated merkleRoot and block merkleRoot not matched");
     }
     let tree = merkle(data, bitcoin.crypto.hash256);
     let proof = merkleProof(tree, data[transactionIndex]);
@@ -221,6 +138,7 @@ function calculateMerkleProof(blockTransactions, txId, blockMerkleRoot = undefin
         transactionIndex,
     };
 }
+exports.calculateMerkleProof = calculateMerkleProof;
 function parseBlockHeader(headerHex) {
     const size = {
         version: 4,
@@ -238,16 +156,18 @@ function parseBlockHeader(headerHex) {
     }
     return result;
 }
+exports.parseBlockHeader = parseBlockHeader;
 function convertBitcoinScriptToAddress(script, network = bitcoin.networks.bitcoin) {
-    var _a;
     try {
-        return (_a = bitcoin.address) === null || _a === void 0 ? void 0 : _a.fromOutputScript(script, network);
+        return bitcoin.address.fromOutputScript(script, network);
     }
     catch (error) {
         return null;
     }
 }
-function parseRawBlock(rawBlockHex, blockNumber = undefined, network = bitcoin.networks.network) {
+exports.convertBitcoinScriptToAddress = convertBitcoinScriptToAddress;
+function parseRawBlock(rawBlockHex, blockNumber, network = bitcoin.networks.bitcoin) {
+    var _a;
     let block = bitcoin.Block.fromBuffer(Buffer.from(rawBlockHex, "hex"));
     let blockHash = block.getHash().toString("hex");
     let merkleRoot = block.merkleRoot.toString("hex");
@@ -256,7 +176,7 @@ function parseRawBlock(rawBlockHex, blockNumber = undefined, network = bitcoin.n
         blockNumber,
         merkleRoot,
         prvBlockHash,
-        transactions: block.transactions.map((tx) => ({
+        transactions: (_a = block.transactions) === null || _a === void 0 ? void 0 : _a.map((tx) => ({
             txId: tx.getId(),
             version: tx.version,
             locktime: tx.locktime,
@@ -275,7 +195,9 @@ function parseRawBlock(rawBlockHex, blockNumber = undefined, network = bitcoin.n
         })),
     };
 }
+exports.parseRawBlock = parseRawBlock;
 function extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex, blockNumber, addresses = [], inputTxIds = [], network = bitcoin.networks.bitcoin) {
+    var _a;
     let block = bitcoin.Block.fromBuffer(Buffer.from(rawBlockHex, "hex"));
     let blockHash = block.getHash().reverse().toString("hex");
     let merkleRoot = block.merkleRoot.toString("hex");
@@ -290,7 +212,7 @@ function extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex, blockNumber, a
     let blockTxIds = block.transactions.map((tx) => tx.getId());
     let withdrawTxs = [];
     let depositTxs = [];
-    block.transactions.forEach((tx) => {
+    (_a = block.transactions) === null || _a === void 0 ? void 0 : _a.forEach((tx) => {
         let txId = tx.getId();
         let inputTxAddress;
         let isWithdraw = tx.ins.find((vi) => {
@@ -319,16 +241,16 @@ function extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex, blockNumber, a
                     return {
                         txId: Buffer.from(vi.hash).reverse().toString("hex"),
                         index: vi.index,
-                        address: viInput.address || null,
-                        script: viInput.script || null,
-                        value: viInput.value || null,
+                        address: (viInput === null || viInput === void 0 ? void 0 : viInput.address) || null,
+                        script: (viInput === null || viInput === void 0 ? void 0 : viInput.script) || null,
+                        value: (viInput === null || viInput === void 0 ? void 0 : viInput.value) || null,
                     };
                 }),
                 address: inputTxAddress,
                 addressScript: createAddressObjectByAddress(inputTxAddress, network).addressObject.output.toString("hex"),
             });
         }
-        let addressIndex;
+        let addressIndex = -1;
         let isDeposit = tx.outs.find((blockTxVo) => {
             let sIndex = addressScript.findIndex((addScript) => addScript === blockTxVo.script.toString("hex"));
             if (sIndex >= 0) {
@@ -366,6 +288,7 @@ function extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex, blockNumber, a
         depositTxs,
     };
 }
+exports.extractTransactionsAndBlockInfoFromRawBlock = extractTransactionsAndBlockInfoFromRawBlock;
 function validateAddress(address, network = bitcoin.networks.bitcoin) {
     try {
         let isValid = false;
@@ -386,24 +309,160 @@ function validateAddress(address, network = bitcoin.networks.bitcoin) {
         return false;
     }
 }
-module.exports = {
-    parseRawTransaction,
-    calculateMerkleProof,
-    createAddressObjectByHash,
-    createAddressObjectByPublicKey,
-    createAddressObjectByAddress,
-    createAddressObjectByScript,
-    getAddressType,
-    getPubKeyFromPrivateKeyWIF,
-    getPubKeyFromPrivateKeyHex,
-    getPublicKeyHexByXpubAndIndex,
-    getPrivateKeyHexFromWIF,
-    reverseBytes,
-    parseBlockHeader,
-    generateMnemonic,
-    parseRawBlock,
-    extractTransactionsAndBlockInfoFromRawBlock,
-    validateAddress,
-    networks,
+exports.validateAddress = validateAddress;
+function toXOnlyPublicKey(pubKey) {
+    return pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);
+}
+function getAddressType(address, network = bitcoin.networks.bitcoin) {
+    if (address.startsWith(`${network.bech32}1p`)) {
+        return "p2tr";
+    }
+    if (address.startsWith(network.bech32)) {
+        return "p2wpkh";
+    }
+    let base58Data = bitcoin.address.fromBase58Check(address);
+    if (base58Data.version === Number(network.scriptHash)) {
+        return "p2sh";
+    }
+    if (base58Data.version === Number(network.pubKeyHash)) {
+        return "p2pkh";
+    }
+    throw new Error("invalid address");
+}
+exports.getAddressType = getAddressType;
+function createAddressObjectByScript({ addressType, script }, network = bitcoin.networks.bitcoin) {
+    let addressObject;
+    switch (addressType) {
+        case "p2pkh":
+            addressObject = bitcoin.payments.p2pkh({
+                output: script,
+                network,
+            });
+            break;
+        case "p2wpkh":
+            addressObject = bitcoin.payments.p2wpkh({
+                output: script,
+                network,
+            });
+            break;
+        case "p2sh":
+            addressObject = bitcoin.payments.p2sh({
+                output: script,
+                network,
+            });
+            break;
+        case "p2wsh":
+            addressObject = bitcoin.payments.p2wsh({
+                output: script,
+                network,
+            });
+            break;
+        default:
+            throw new Error("address type is incorrect");
+    }
+    return addressObject;
+}
+exports.createAddressObjectByScript = createAddressObjectByScript;
+function createAddressObjectByHash({ addressType, hash }, network = bitcoin.networks.bitcoin) {
+    let addressObject;
+    switch (addressType) {
+        case "p2pkh":
+            addressObject = bitcoin.payments.p2pkh({
+                hash,
+                network,
+            });
+            break;
+        case "p2wpkh":
+            addressObject = bitcoin.payments.p2wpkh({
+                hash,
+                network,
+            });
+            break;
+        case "p2sh":
+            addressObject = bitcoin.payments.p2sh({
+                hash,
+                network,
+            });
+            break;
+        case "p2wsh":
+            addressObject = bitcoin.payments.p2wsh({
+                hash,
+                network,
+            });
+            break;
+        default:
+            throw new Error("address type is incorrect");
+    }
+    return addressObject;
+}
+exports.createAddressObjectByHash = createAddressObjectByHash;
+function createAddressObjectByPublicKey({ addressType, publicKey }, network = bitcoin.networks.bitcoin) {
+    let addressObject;
+    switch (addressType) {
+        case "p2pkh":
+            addressObject = bitcoin.payments.p2pkh({
+                pubkey: publicKey,
+                network,
+            });
+            break;
+        case "p2wpkh":
+            addressObject = bitcoin.payments.p2wpkh({
+                pubkey: publicKey,
+                network,
+            });
+            break;
+        case "p2sh-p2wpkh":
+            addressObject = bitcoin.payments.p2sh({
+                redeem: bitcoin.payments.p2wpkh({
+                    pubkey: publicKey,
+                    network,
+                }),
+            });
+            break;
+        case "p2tr":
+        default:
+            throw new Error("address type is incorrect");
+    }
+    return addressObject;
+}
+exports.createAddressObjectByPublicKey = createAddressObjectByPublicKey;
+function createAddressObjectByAddress(address, network = bitcoin.networks.bitcoin) {
+    let addressType = getAddressType(address, network);
+    let addressObject;
+    switch (addressType) {
+        case "p2pkh":
+            addressObject = bitcoin.payments.p2pkh({
+                address,
+                network,
+            });
+            break;
+        case "p2wpkh":
+            addressObject = bitcoin.payments.p2wpkh({
+                address,
+                network,
+            });
+            break;
+        case "p2sh":
+            addressObject = bitcoin.payments.p2sh({
+                address,
+                network,
+            });
+            break;
+        default:
+            throw new Error("address type is incorrect");
+    }
+    return { addressObject, addressType };
+}
+exports.createAddressObjectByAddress = createAddressObjectByAddress;
+function publicKeyConvertor(publicKeyHex, compressed = true) {
+    let pubkey = ECPair.fromPublicKey(Buffer.from(publicKeyHex, "hex"), {
+        compressed,
+    });
+    return pubkey.publicKey.toString("hex");
+}
+exports.publicKeyConvertor = publicKeyConvertor;
+exports.addressTypeHelper = {
+    addressTypesNumber: { p2pk: 0, p2pkh: 1, p2sh: 2, p2wpkh: 3, p2wsh: 4, p2tr: 5 },
+    addressTypes: ["p2pk", "p2pkh", "p2sh", "p2wpkh", "p2wsh", "p2tr"],
 };
 //# sourceMappingURL=bitcoin-utils.js.map