区链

与区块链数据合作的通用方法

方法

• 压缩输入数
• 交易组件
• 解码Base58
• 解码Base58 地址
• 解码Bech32 地址
• 解码Wif
• 编码Base58 地址
• 编码Bech32 地址
• hashForP2pkh 维基百科中的相关条目: 花生花
• hashForP2wpkh 页面存档备份,存于互联网档案馆
• idForBlock 数据
• 用于交易
• idFor 交易组件
• 无锁定时间Id用于交易
• 非WitnessHashto 签名
• 数字AsCompactInt
• 输出脚本格式
• p2ms 脚本
• p2pkh 输出脚本
• p2sh 输出脚本
• p2tr 输出脚本
• p2wpkh 输出脚本
• p2wsh 输出脚本
• 上一个块
• 查询
• 脚本脚本元素
• 脚本元素
• 交易大小
• 来自组件的交易
• 未签名的Tx 从 Psbt
• v0Hashto 签名

压缩输入数

将整数转换为正则数

{
  encoded: <Compact Integer Encoded Number Buffer Object>
  [start]: <Buffer Offset Start Index Number>
}

@returns
{
  bytes: <Byte Count Number>
  number: <Integer Number>
}

示例

const {compactIntAsNumber} = require('@alexbosworth/blockchain');

// Decode the plain number from the encoded compact int bytes
const {number} = compactIntAsNumber({encoded: Buffer.from('fdfd00', 'hex')});

交易组件

获取十六进制编码交易的组件

{
  transaction: <Hex Encoded Transaction String>
}

@throws
<Error>

@returns
{
  inputs: [{
    id: <Spending Transaction Id Hex String>
    script: <ScriptSig Script Hex String>
    sequence: <Sequence Number>
    vout: <Spending Transaction Output Index Number>
    [witness]: [<Script Stack Element Hex String>]
  }]
  locktime: <Timelock nLockTime Number>
  outputs: [{
    script: <ScriptPub Script Hex String>
    tokens: <Tokens Count Number>
  }]
  version: <Version Number>
}

解码Base58

解码一个已编码的字符串进入其有效载荷

{
  encoded: <Base58Check Encoded String>
}

@throws
<Error> when the string has invalid characters or a bad checksum

@returns
{
  payload: <Decoded Payload Buffer Object>
}

解码Base58 地址

来自基数58地址字符串的衍生输出散列和版本数据

{
  address: <Base58 Encoded Address String>
}

@throws
<Error>

@returns
{
  hash: <Output Hash Buffer Object>
  version: <Script Version Byte Number>
}

解码Bech32 地址

解码 Bech32 地址字符串以获取地址细节

{
  address: <Bech32 Encoded Address String>
}

@throws
<Error>

@returns
{
  prefix: <Human Readable Prefix String>
  program: <Output Data Buffer Object>
  version: <Witness Version Number>
}

解码Wif

解码 WIF 编码的私钥

以压缩形式生成公钥 is_compressed 真实

未指定网络时, 接受任何已知网络的WIF

所支持的网络: btc, btcregtest, btcsignet, btctestnet4

{
  [network]: <Network Name String>
  wif: <WIF Encoded Private Key String>
}

@throws
<Error>

@returns
{
  is_compressed: <Public Key Is Compressed Bool>
  private_key: <Private Key Buffer Object>
}

示例

const {createECDH} = require('node:crypto');

const {decodeWif} = require('@alexbosworth/blockchain');

// Decode the private key and the public key compression from a mainnet WIF
const {is_compressed, private_key} = decodeWif({
  network: 'btc',
  wif: 'KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617',
});

// The WIF signals if the public key is compressed or uncompressed
const format = is_compressed ? 'compressed' : 'uncompressed';

const ecdh = createECDH('secp256k1');

// Derive the public key from the private key
ecdh.setPrivateKey(private_key);

const publicKey = ecdh.getPublicKey(null, format);

编码Base58 地址

将输出散列和版本数据编码为基数58地址字符串

{
  hash: <Output Hash Buffer Object>
  version: <Script Version Byte Number>
}

@throws
<Error>

@returns
{
  address: <Base58 Encoded Address String>
}

示例

const {encodeBase58Address, hashForP2pkh} = require('@alexbosworth/blockchain');

// The P2PKH output hash is the hash160 of the compressed public key
const {hash} = hashForP2pkh({key: publicKey});

// Encode the P2PKH address paying to the public key hash
const {address} = encodeBase58Address({hash, version: 0});

编码Bech32 地址

作为 Bech32 地址字符串编码地址细节

{
  prefix: <Human Readable Prefix String>
  program: <Output Data Buffer Object>
  version: <Witness Version Number>
}

@throws
<Error>

@returns
{
  address: <Bech32 Encoded Address String>
}

示例

const {encodeBech32Address, hashForP2wpkh} = require('@alexbosworth/blockchain');

// The P2WPKH witness program is the hash160 of the compressed public key
const {hash} = hashForP2wpkh({key: publicKey});

// Encode the P2WPKH address paying to the public key hash
const {address} = encodeBech32Address({
  prefix: 'bc',
  program: hash,
  version: 0,
});

hashForP2pkh 维基百科中的相关条目: 花生花

通过 P2PKH 获得公用钥匙的散列160

使用 hash 与 p2pkhOutputScript p2PKH 输出脚本

{
  key: <Public Key Buffer Object>
}

@throws
<Error>

@returns
{
  hash: <Public Key Hash160 Buffer Object>
}

hashForP2wpkh 页面存档备份,存于互联网档案馆

通过 P2WPKH 获得公用钥匙的大麻花序160

使用 hash 与 p2wpkhOutputScript p2WPKH 输出脚本

{
  key: <Public Key Buffer Object>
}

@throws
<Error>

@returns
{
  hash: <Public Key Hash160 Buffer Object>
}

idForBlock 数据

获得一个区块的ID:区块头的双沙256散列

{
  block: <Hex Encoded Block Data String>
}

@throws
<Error>

@returns
{
  id: <Block Id Hex Encoded String>
}

用于交易

为生序式 tx 设定标准交易ID

{
  transaction: <Hex Encoded Transaction String>
}

@throws
<Error>

@returns
{
  id: <Transaction Id Hex Encoded String>
}

idFor 交易组件

从交易组件中确定交易编号

注意: 记住输入的散列是正常 tx id 的倒转字节顺序

{
  inputs: [{
    hash: <Spending Internal Byte Order Transaction Id Buffer Object>
    script: <Script Buffer Object>
    sequence: <Sequence Number>
    vout: <Spending Transaction Output Index Number>
  }]
  locktime: <Timelock nLockTime Number>
  outputs: [{
    script: <Output Script Buffer Object>
    tokens: <Tokens Count Number>
  }]
  version: <Version Number>
}

@throws
<Error>

@returns
{
  id: <Transaction Id Hex String>
}

无锁定时间Id用于交易

获取有目击数据的交易的ID, 以及未包含的时间

{
  buffer: <Data Buffer Object>
  [start]: <Starting Offset Index Number>
}

@throws
<Error>

@returns
{
  id: <No nLockTime Transaction Id Hex String>
}

非WitnessHashto 签名

计算要签名的 SegWit 交易散列

对于 P2PK, P2PKH, 或赤色多相格, 脚本是正在花费的输出脚本

P2SH 的脚本是将脚本混入输出脚本的赎回脚本

当代码分隔符被执行时, 只通过它后面的脚本, 任何 散开前从脚本中去除剩余的代码分隔符

单一输出的签名需要匹配输入索引的输出

{
  script: <Signing Input Script Hex String>
  [sighash]: <Signature Hash Type Number>
  transaction: <Raw Transaction Hex String>
  vin: <Signing Transaction Input Index Number>
}

@throws
<Error>

@returns
{
  hash: <Hash to Sign Hex String>
}

数字AsCompactInt

将数字转换为紧凑的大小整数序列化

{
  number: <Amount to Convert to Compact Integer Serialization Number>
}

@throws
<Error>

@returns
{
  encoded: <Serialized Compact Integer Buffer Object>
}

输出脚本格式

获取地址的输出脚本

支持地址: P2PKH, P2SH, P2WPKH, P2WSH, P2TR, 未来 segwit 版本

所支持的网络: btc, btcregtest, btcsignet, btctestnet4

{
  address: <Address String>
  network: <Network Name String>
}

@throws
<Error>

@returns
{
  script: <Output Script Hex String>
}

示例

const {outputScriptForAddress} = require('@alexbosworth/blockchain');

// Get the output script to pay to an address
const {script} = outputScriptForAddress({
  address: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
  network: 'btc',
});

p2ms 脚本

获取多相脚本和脚本散列来支付脚本

使用 hash 与 p2wshOutputScript p2WSH 输出脚本

{
  keys: [<Public Key Buffer Object>]
  required: <Signatures Required Count Number>
}

@throws
<Error>

@returns
{
  hash: <Witness Script SHA256 Hash Buffer Object>
  script: <Multisig Script Buffer Object>
}

示例

const {p2msScript, p2wshOutputScript} = require('@alexbosworth/blockchain');

// Derive the 2-of-3 multisig script and its witness script hash
const {hash} = p2msScript({keys: publicKeys, required: 2});

// Get the P2WSH output script paying to the multisig script
const {script} = p2wshOutputScript({hash});

p2pkh 输出脚本

获得公钥 Hash 输出脚本

{
  hash: <Public Key Hash Buffer Object>
}

@throws
<Error>

@returns
{
  script: <Output Script Buffer Object>
}

p2sh 输出脚本

获取对脚本的付费 Hash 输出脚本

{
  hash: <Script Hash Buffer Object>
}

@throws
<Error>

@returns
{
  script: <Output Script Buffer Object>
}

p2tr 输出脚本

获取报酬到磁带输出脚本

{
  hash: <Taproot Hash Buffer Object>
}

@throws
<Error>

@returns
{
  script: <Output Script Buffer Object>
}

p2wpkh 输出脚本

获取给目击公钥 Hash 输出脚本

{
  hash: <Witness Public Key Hash Buffer Object>
}

@throws
<Error>

@returns
{
  script: <Output Script Buffer Object>
}

p2wsh 输出脚本

获取给目击脚本 Hash 输出脚本

{
  hash: <Witness Script Hash Buffer Object>
}

@throws
<Error>

@returns
{
  script: <Output Script Buffer Object>
}

上一个块

鉴于一个生块, 返回上一个块 ID

{
  block: <Hex Encoded Block String>
}

@throws
<Error>

@returns
{
  previous: <Previous Block Id Hex String>
}

查询

在块内查找匹配的交易

{
  block: <Hex Encoded Raw Block String>
  [ids]: [<Transaction Id Hex String>]
  [outputs]: [<Output Script Hex String>]
}

@throws
<Error>

@returns
{
  outputs: [{
    script: <Output Script Hex String>
    tokens: <Output Value Number>
    transaction_id: <Transaction Id Hex String>
    transaction_vout: <Transaction Output Index Number>
  }]
  transactions: [{
    id: <Transaction Id Hex String>
    transaction: <Hex Encoded Raw Transaction String>
  }]
}

脚本脚本元素

将序列化的脚本映射到脚本元素阵列

{
  script: <Script Hex String>
}

@throws
<Error>

@returns
{
  [elements]: [<Data Buffer>, <Script OP_CODE Number>]
}

脚本元素

将脚本缓冲元素的阵列映射到一个完全成形的脚本

{
  elements: [<Data Buffer>, <Script OP_CODE Number>]
}

@throws
<Error>

@returns
{
  script: <Script Hex String>
}

交易大小

获取六进制编码交易的重量和虚拟大小

{
  transaction: <Hex Encoded Transaction String>
}

@throws
<Error>

@returns
{
  vsize: <Transaction Virtual Size Number>
  weight: <Transaction Weight Units Number>
}

来自组件的交易

从其组成部分中形成六进制编码交易

{
  inputs: [{
    id: <Spending Transaction Id Hex String>
    script: <ScriptSig Script Hex String>
    sequence: <Sequence Number>
    vout: <Spending Transaction Output Index Number>
    [witness]: [<Script Stack Element Hex String>]
  }]
  locktime: <Timelock nLockTime Number>
  outputs: [{
    script: <ScriptPub Script Hex String>
    tokens: <Tokens Count Number>
  }]
  version: <Version Number>
}

@throws
<Error>

@returns
{
  transaction: <Hex Encoded Transaction String>
}

未签名的Tx 从 Psbt

从 PSBT 获取未签名的交易

{
  psbt: <PSBT Hex String>
}

@throws
<Error>

@returns
{
  transaction: <Unsigned Transaction Buffer Object>
}

v0Hashto 签名

计算要签名的 v0 证人交易散列

脚本是用于输出的 BIP 143 脚本代码

P2WPKH的脚本代码是公钥散列的P2PKH脚本h

P2WSH 的脚本代码是目击脚本

{
  script: <Signing Input Script Hex String>
  [sighash]: <Signature Hash Type Number>
  tokens: <Spending Output Tokens Number>
  transaction: <Raw Transaction Hex String>
  vin: <Signing Transaction Input Index Number>
}

@throws
<Error>

@returns
{
  hash: <Hash to Sign Hex String>
}