Blockchain Notes Blog

钱包和地址生成

2024-01-20T00:00:00.000Z

生成私钥

import { ethers } from 'ethers';

// https://docs.ethers.org/v5/api/signer/#Wallet
async function main() {
	const wallet = ethers.Wallet.createRandom();
	console.log('address     : ', await wallet.getAddress());
	console.log('public	 key : ', wallet.publicKey);
	console.log('compressed  : ', ethers.utils.computePublicKey(wallet.publicKey, true));
	console.log('private key : ', wallet.privateKey);
}

main().catch(console.error);

私钥生成地址

import { privateToAddress, privateToPublic, isValidPrivate, publicToAddress, toChecksumAddress } from 'ethereumjs-util';
import { ec as EC } from 'elliptic';
import 'dotenv/config';

const ec = new EC('secp256k1');
const { PRIVATE_KEY } = process.env;
const privateKey = Buffer.from(PRIVATE_KEY!, 'hex');

const publicKey = privateToPublic(privateKey);
const address = privateToAddress(privateKey);

console.log('isValidPrivate      : ', isValidPrivate(privateKey));
console.log('public key          : ', publicKey.toString('hex'));
console.log('private to address  : ', address.toString('hex'));
console.log('public to address   : ', publicToAddress(publicKey).toString('hex'));
console.log('BIP55 address       : ', toChecksumAddress(publicToAddress(publicKey, true).toString('hex')));

const pair = ec.keyFromPrivate(privateKey);
const compact = pair.getPublic(true, 'hex');
const decompose = pair.getPublic(false, 'hex');
const decomposeBuf = Buffer.from(decompose, 'hex');
const addr = publicToAddress(decomposeBuf, true).toString('hex');
console.log('compact             : ', compact);
console.log('decompose           : ', decompose);
console.log('address             : ', addr);
console.log('bip55 address       : ', toChecksumAddress(addr));

比特币交易构建与签名 - 完整实践指南

2024-01-18T00:00:00.000Z

比特币交易的构建和签名是区块链开发中的核心技能。本文将详细介绍如何使用比特币工具包构建各种类型的比特币交易，包括输入选择、输出创建、签名和广播。

交易构建基础

1. 环境设置

首先需要安装我们的比特币工具包：

import { bech32 } from 'bech32';
import base58 from 'bs58';
import { sha256x2, sha256, ripemd160 } from '../utils/crypto';

export function toBech32Address(pubkey: Buffer, pubKeyHash = 0x00): string {
  // pubKeyHash: Witness version. 0x00 for P2WPKH
  const hash256 = sha256(pubkey);
  const hash160 = ripemd160(hash256);

  const words = bech32.toWords(hash160);
  words.unshift(pubKeyHash);
  return bech32.encode('bc', words);
}

// https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch04_keys.adoc
// pubKeyHash: Version byte. 0x00 for Mainnet P2PKH, 0x6f for Testnet, etc.
export function toBase58Address(pubkey: Buffer, pubKeyHash = 0x00): string {
  const hash256 = sha256(pubkey);
  const hash160 = ripemd160(hash256);

  // version + payload
  const payload = Buffer.allocUnsafe(21);
  payload.writeUInt8(pubKeyHash, 0);
  hash160.copy(payload, 1);

  // checksum, first 4 buffer
  const checksum = sha256x2(payload).slice(0, 4);

  // Buffer.concat([payload, checksum], payload.length + 4);
  const buffer = Buffer.allocUnsafe(25);
  payload.copy(buffer);
  checksum.copy(buffer, 21);

  // version + payload + checksum(first 4 bytes)
  return base58.encode(buffer);
};

2. 密钥管理

import { bech32 } from 'bech32';
import base58 from 'bs58';
import { sha256x2, sha256, ripemd160 } from '../utils/crypto';

export function toBech32Address(pubkey: Buffer, pubKeyHash = 0x00): string {
  // pubKeyHash: Witness version. 0x00 for P2WPKH
  const hash256 = sha256(pubkey);
  const hash160 = ripemd160(hash256);

  const words = bech32.toWords(hash160);
  words.unshift(pubKeyHash);
  return bech32.encode('bc', words);
}

// https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch04_keys.adoc
// pubKeyHash: Version byte. 0x00 for Mainnet P2PKH, 0x6f for Testnet, etc.
export function toBase58Address(pubkey: Buffer, pubKeyHash = 0x00): string {
  const hash256 = sha256(pubkey);
  const hash160 = ripemd160(hash256);

  // version + payload
  const payload = Buffer.allocUnsafe(21);
  payload.writeUInt8(pubKeyHash, 0);
  hash160.copy(payload, 1);

  // checksum, first 4 buffer
  const checksum = sha256x2(payload).slice(0, 4);

  // Buffer.concat([payload, checksum], payload.length + 4);
  const buffer = Buffer.allocUnsafe(25);
  payload.copy(buffer);
  checksum.copy(buffer, 21);

  // version + payload + checksum(first 4 bytes)
  return base58.encode(buffer);
};

PSBT 交易构建

PSBT (Partially Signed Bitcoin Transaction) 是现代比特币交易的标准格式。

require('dotenv').config();
const { ECPair, Psbt, networks, payments } = require('bitcoinjs-lib');
const network = networks.testnet;

var secret = process.env.ECDSA_SECRET;

const signer = ECPair.fromPrivateKey(Buffer.from(secret, 'hex'), network);
const pubkey = signer.publicKey;

const { address } = payments.p2pkh({ pubkey, network });
console.log('pubkey  : ', pubkey.toString('hex'));
console.log('address : ', address);

// https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/test/integration/transactions.spec.ts
function createPsbtTx() {
	const psbt = new Psbt({ network });
	psbt.setVersion(2); // These are defaults. This line is not needed.
	psbt.setLocktime(0)

	psbt.addInput({
		hash: '3b948165cfb707320ccdc9582b5acc7cdad213bc81b7edb37546e1334d802b38',
		index: 0,
		sequence: 0xffffffff, // These are defaults. This line is not needed.
		// tx raw data
		nonWitnessUtxo: Buffer.from('0100000001b2533a7e2329b92b576309969ef39e987f1ce62d76d1a3e714e1f73b830f7404010000006b483045022100e950df33415553a6cdd9665d4d6d3f03568ad0e2feb429efe19f4fc78da66714022059e3ffdf36d300a9352b971f8c48180ec0cef2325f61948488480430bc24d1ed012102ff26c5980685ae12d25312a8df8224c951a68272013425ffa60327d7d4b54231ffffffff0210270000000000001976a914dc6c3c43e5d2c934602095103d3cbf84ddc797f288ace71a0100000000001976a914dc6c3c43e5d2c934602095103d3cbf84ddc797f288ac00000000', 'hex')
	});

	psbt.addOutput({
		address: 'n1cScasu6XVoDki38WYAJH4ZJGRAfG8XRN',
		value: 9800
	});

	psbt.signInput(0, signer);

	psbt.finalizeAllInputs();

	const serialized = psbt.extractTransaction().toHex();
	console.log('serialized : ', serialized);

}

createPsbtTx();

不同类型的交易构建

1. 地址生成

import { bech32 } from 'bech32';
import base58 from 'bs58';
import { sha256x2, sha256, ripemd160 } from '../utils/crypto';

export function toBech32Address(pubkey: Buffer, pubKeyHash = 0x00): string {
  // pubKeyHash: Witness version. 0x00 for P2WPKH
  const hash256 = sha256(pubkey);
  const hash160 = ripemd160(hash256);

  const words = bech32.toWords(hash160);
  words.unshift(pubKeyHash);
  return bech32.encode('bc', words);
}

// https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch04_keys.adoc
// pubKeyHash: Version byte. 0x00 for Mainnet P2PKH, 0x6f for Testnet, etc.
export function toBase58Address(pubkey: Buffer, pubKeyHash = 0x00): string {
  const hash256 = sha256(pubkey);
  const hash160 = ripemd160(hash256);

  // version + payload
  const payload = Buffer.allocUnsafe(21);
  payload.writeUInt8(pubKeyHash, 0);
  hash160.copy(payload, 1);

  // checksum, first 4 buffer
  const checksum = sha256x2(payload).slice(0, 4);

  // Buffer.concat([payload, checksum], payload.length + 4);
  const buffer = Buffer.allocUnsafe(25);
  payload.copy(buffer);
  checksum.copy(buffer, 21);

  // version + payload + checksum(first 4 bytes)
  return base58.encode(buffer);
};

2. 多签名交易

import bitgoV1 from '@bitgo/utxo-lib';
import { payments } from 'bitcoinjs-lib';

const pubKeys = [
  '02f4147da97162a214dbe25828ee4c4acc4dc721cd0c15b2761b43ed0292ed82b5', // 2 -3
  '0377155e520059d3b85c6afc5c617b7eb519afadd0360f1ef03aff3f7e3f5438dd',
  '02f44bce3eecd274e7aa24ec975388d12905dfc670a99b16e1d968e6ab5f69b266',
].map(function (hex) {
  return Buffer.from(hex, 'hex');
});

const threshold = 2;
const network = bitgoV1.networks.testnet

var redeemScript = bitgoV1.script.multisig.output.encode(threshold, pubKeys); // 2 of 3
var scriptPubKey = bitgoV1.script.scriptHash.output.encode(bitgoV1.crypto.hash160(redeemScript));
var address = bitgoV1.address.fromOutputScript(scriptPubKey, network);
console.log('bitgo address  : ', address);

//
var { address } = payments.p2sh({
  redeem: payments.p2ms({ m: threshold, pubkeys: pubKeys, network }),
  network,
});

console.log('bitcoin address: ', address);

交易签名

1. 单签名

require('dotenv').config();
const { ECPair, Psbt, networks, payments } = require('bitcoinjs-lib');
const network = networks.testnet;

var secret = process.env.ECDSA_SECRET;

const signer = ECPair.fromPrivateKey(Buffer.from(secret, 'hex'), network);
const pubkey = signer.publicKey;

const { address } = payments.p2pkh({ pubkey, network });
console.log('pubkey  : ', pubkey.toString('hex'));
console.log('address : ', address);

// https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/test/integration/transactions.spec.ts
function createPsbtTx() {
	const psbt = new Psbt({ network });
	psbt.setVersion(2); // These are defaults. This line is not needed.
	psbt.setLocktime(0)

	psbt.addInput({
		hash: '3b948165cfb707320ccdc9582b5acc7cdad213bc81b7edb37546e1334d802b38',
		index: 0,
		sequence: 0xffffffff, // These are defaults. This line is not needed.
		// tx raw data
		nonWitnessUtxo: Buffer.from('0100000001b2533a7e2329b92b576309969ef39e987f1ce62d76d1a3e714e1f73b830f7404010000006b483045022100e950df33415553a6cdd9665d4d6d3f03568ad0e2feb429efe19f4fc78da66714022059e3ffdf36d300a9352b971f8c48180ec0cef2325f61948488480430bc24d1ed012102ff26c5980685ae12d25312a8df8224c951a68272013425ffa60327d7d4b54231ffffffff0210270000000000001976a914dc6c3c43e5d2c934602095103d3cbf84ddc797f288ace71a0100000000001976a914dc6c3c43e5d2c934602095103d3cbf84ddc797f288ac00000000', 'hex')
	});

	psbt.addOutput({
		address: 'n1cScasu6XVoDki38WYAJH4ZJGRAfG8XRN',
		value: 9800
	});

	psbt.signInput(0, signer);

	psbt.finalizeAllInputs();

	const serialized = psbt.extractTransaction().toHex();
	console.log('serialized : ', serialized);

}

createPsbtTx();

2. 多签名

function createPsbtTx() {
	const psbt = new Psbt({ network });
	psbt.setVersion(2); // These are defaults. This line is not needed.
	psbt.setLocktime(0)

	psbt.addInput({
		hash: '3b948165cfb707320ccdc9582b5acc7cdad213bc81b7edb37546e1334d802b38',
		index: 0,
		sequence: 0xffffffff, // These are defaults. This line is not needed.
		// tx raw data
		nonWitnessUtxo: Buffer.from('0100000001b2533a7e2329b92b576309969ef39e987f1ce62d76d1a3e714e1f73b830f7404010000006b483045022100e950df33415553a6cdd9665d4d6d3f03568ad0e2feb429efe19f4fc78da66714022059e3ffdf36d300a9352b971f8c48180ec0cef2325f61948488480430bc24d1ed012102ff26c5980685ae12d25312a8df8224c951a68272013425ffa60327d7d4b54231ffffffff0210270000000000001976a914dc6c3c43e5d2c934602095103d3cbf84ddc797f288ace71a0100000000001976a914dc6c3c43e5d2c934602095103d3cbf84ddc797f288ac00000000', 'hex')
	});

	psbt.addOutput({
		address: 'n1cScasu6XVoDki38WYAJH4ZJGRAfG8XRN',
		value: 9800
	});

	psbt.signInput(0, signer);

	psbt.finalizeAllInputs();

	const serialized = psbt.extractTransaction().toHex();
	console.log('serialized : ', serialized);

}

createPsbtTx();

RBF (Replace-By-Fee) 交易

RBF 允许用更高手续费的交易替换未确认的交易。

require('dotenv').config();
const { PrivateKey, Networks, Transaction } = require('bitcore-lib');

var secret = process.env.ECDSA_SECRET;
const privkey = new PrivateKey(secret, Networks.testnet);

console.log('address    : ', privkey.toAddress().toString());

var utxo = {
  txid: '5ab958a2a62d2e905128fbe0faebc998a92abf365aaa8db3f319c280dda32bc1',
  outputIndex: 0,
  address: 'n1cScasu6XVoDki38WYAJH4ZJGRAfG8XRN',
  script: '76a914dc6c3c43e5d2c934602095103d3cbf84ddc797f288ac',
  satoshis: 10000,
};

const tx = new Transaction();
tx.from(utxo);
tx.to('mnv5WqA2nw1L5SHepFFVNYZMeHUC9WCfRU', 8000);
tx.change('mnv5WqA2nw1L5SHepFFVNYZMeHUC9WCfRU');
tx.fee(300);
tx.enableRBF();
tx.sign(privkey);
const bl = tx.isRBF();
console.log('bl', bl);

const serialized = tx.serialize();
console.log('serialized', serialized);

const newTx = new Transaction();
console.log(newTx.isRBF());

newTx.from(utxo);
newTx.to('n1cScasu6XVoDki38WYAJH4ZJGRAfG8XRN', 7000);
newTx.change('n1cScasu6XVoDki38WYAJH4ZJGRAfG8XRN');
newTx.fee(1800);
newTx.enableRBF();
newTx.sign(privkey);

const newSerialized = newTx.serialize();
console.log('new serialized : ', newSerialized);

交易验证

交易广播

交易广播通常通过比特币节点或第三方 API 服务进行。你可以使用以下方式之一：

本地比特币节点: 使用 bitcoin-cli sendrawtransaction
第三方 API: 如 Blockstream、BlockCypher 等
测试网: 使用测试网 API 进行开发和测试

完整交易流程示例

安全最佳实践

私钥安全: 永远不要在代码中硬编码私钥
网络选择: 开发时使用测试网，生产时使用主网
手续费计算: 动态计算手续费以确保交易被确认
输入验证: 始终验证 UTXO 的有效性和所有权
错误处理: 实现完善的错误处理和回滚机制

总结

比特币交易构建是一个复杂但重要的过程。通过掌握 PSBT、各种交易类型和签名机制，开发者可以：

构建安全的比特币应用
实现复杂的交易逻辑
支持多种地址格式
优化交易费用和确认时间

在下一篇文章中，我们将探讨比特币工具函数和实用技巧。

比特币交易类型分类详解 - 识别与分析

2024-01-17T00:00:00.000Z

比特币网络支持多种交易类型，每种类型都有其特定的脚本模式和用途。本文将详细介绍如何识别和分类不同的比特币交易类型，这对于理解交易结构和开发相关应用至关重要。

比特币交易类型概述

比特币支持以下主要交易类型：

P2PKH (Pay-to-Public-Key-Hash) - 最传统的交易类型
P2SH (Pay-to-Script-Hash) - 脚本哈希支付
P2WPKH (Pay-to-Witness-Public-Key-Hash) - 原生 SegWit
P2WSH (Pay-to-Witness-Script-Hash) - 见证脚本哈希
P2PK (Pay-to-Public-Key) - 直接支付给公钥
Multisig - 多签名交易
Null Data - 数据存储交易

核心分类函数

1. P2PKH 交易识别

P2PKH 是最常见的交易类型，使用公钥哈希作为锁定条件：

  );
}

// https://en.bitcoinwiki.org/wiki/Pay-to-Pubkey
export function p2pk(script: Buffer) {
  const chunks = decompile(script);
  return (
    chunks?.length === 2 && //
    isCanonicalPubKey(chunks[0]) && //
    chunks[1] === OPS.OP_CHECKSIG
  );

P2PKH 脚本结构：

OP_DUP OP_HASH160 <20-byte-hash> OP_EQUALVERIFY OP_CHECKSIG

2. P2SH 交易识别

P2SH 允许支付给脚本哈希，支持更复杂的脚本：

function p2sh(script) {
  typeforce(typeforce.Buffer, script);
  const buffer = compile(script);
  return (
    buffer.length === 23 && //
    buffer[0] === OPS.OP_HASH160 && // hash160
    buffer[1] === 0x14 && // length is 22
    buffer[22] === OPS.OP_EQUAL // equal
  );
}

P2SH 脚本结构：

OP_HASH160 <20-byte-hash> OP_EQUAL

3. P2WPKH 交易识别

原生 SegWit 交易，使用见证公钥哈希：

function p2wpkh(script) {
  typeforce(typeforce.Buffer, script);
  const buffer = compile(script);

  return (
    buffer.length === 22 && //
    buffer[0] === OPS.OP_0 && // OP_0
    buffer[1] === 0x14
  );
}

P2WPKH 脚本结构：

OP_0 <20-byte-hash>

4. P2WSH 交易识别

见证脚本哈希交易，支持复杂的见证脚本：

function p2wsh(script) {
  typeforce(typeforce.Buffer, script);
  const buffer = compile(script);

  return (
    buffer.length === 34 && //
    buffer[0] === OPS.OP_0 && // OP_0
    buffer[1] === 0x20
  );
}

P2WSH 脚本结构：

OP_0 <32-byte-hash>

5. P2PK 交易识别

直接支付给公钥的交易类型：

function p2pk(script) {
  const chunks = decompile(script);
  return (
    chunks.length === 2 && //
    isCanonicalPubKey(chunks[0]) && //
    chunks[1] === OPS.OP_CHECKSIG
  );
}

P2PK 脚本结构：

 OP_CHECKSIG

6. 多签名交易识别

多签名交易允许多个私钥共同控制资金：

function multisig(script) {
  const chunks = decompile(script);
  const length = chunks.length;
  if (length < 4) return false;
  if (chunks[length - 1] !== OPS.OP_CHECKMULTISIG) return false;
  if (!typeforce.Number(chunks[0])) return false;
  if (!typeforce.Number(chunks[length - 2])) return false;

  const m = chunks[0] - OP_INT_BASE;
  const n = chunks[length - 2] - OP_INT_BASE;

  if (m <= 0) return false;
  if (n > 16) return false;
  if (m > n) return false;
  // m {pubkey}...{pubkey} n OP_CHECKMULTISIG - (m + n + OP_CHECKMULTISIG)
  if (n !== length - 3) return false;

  // pub keys
  const keys = chunks.slice(1, -2);
  return keys.every(isCanonicalPubKey);
}

多签名脚本结构：

   ...   OP_CHECKMULTISIG

7. 见证承诺交易识别

用于 SegWit 的见证承诺交易：

function witness_commitment(script) {
  typeforce(typeforce.Buffer, script);
  const buffer = compile(script);
  return (
    buffer.length === 25 && //
    buffer[0] === OPS.OP_RETURN &&
    buffer[1] === 0x24 && //  Push the following 36 bytes (0x24)
    buffer.slice(2, 6).equals(Buffer.from('0x6a24aa21a9ed', 'hex'))
  );
}

交易类型分类器

创建一个综合的分类函数来识别所有交易类型：

function classifyTransaction(script) {
  if (p2pkh(script)) return types.P2PKH;
  if (p2sh(script)) return types.P2SH;
  if (p2wpkh(script)) return types.P2WPKH;
  if (p2wsh(script)) return types.P2WSH;
  if (p2pk(script)) return types.P2PK;
  if (multisig(script)) return types.P2MS;
  if (witness_commitment(script)) return types.WITNESS_COMMITMENT;
  
  return types.NONSTANDARD;
}

实际应用示例

分析交易输出

// 分析一个交易输出的脚本类型
function analyzeTransactionOutput(scriptHex) {
  const script = Buffer.from(scriptHex, 'hex');
  const type = classifyTransaction(script);
  
  console.log('Script Type:', type);
  console.log('Script ASM:', toASM(script));
  
  return {
    type,
    script,
    asm: toASM(script),
    isValid: type !== types.NONSTANDARD
  };
}

// 使用示例
const p2pkhScript = '76a914a002b6b9a3c3190ca8d9c7262ac6bdd7d4359d4a88ac';
const result = analyzeTransactionOutput(p2pkhScript);
console.log(result);

批量交易分析

function batchAnalyzeTransactions(transactions) {
  return transactions.map(tx => {
    const outputs = tx.outputs.map(output => ({
      ...output,
      scriptType: classifyTransaction(output.script),
      scriptASM: toASM(output.script)
    }));
    
    return {
      txid: tx.txid,
      outputs
    };
  });
}

交易类型统计

function getTransactionTypeStats(transactions) {
  const stats = {};
  
  transactions.forEach(tx => {
    tx.outputs.forEach(output => {
      const type = classifyTransaction(output.script);
      stats[type] = (stats[type] || 0) + 1;
    });
  });
  
  return stats;
}

安全考虑

脚本验证: 始终验证脚本的完整性和有效性
类型检查: 确保交易类型与预期用途匹配
版本兼容: 考虑不同比特币版本的脚本支持
错误处理: 妥善处理无法识别的脚本类型

性能优化

// 缓存编译结果以提高性能
const scriptCache = new Map();

function classifyTransactionCached(script) {
  const scriptHex = script.toString('hex');
  
  if (scriptCache.has(scriptHex)) {
    return scriptCache.get(scriptHex);
  }
  
  const type = classifyTransaction(script);
  scriptCache.set(scriptHex, type);
  
  return type;
}

总结

比特币交易类型分类是理解区块链数据的基础。通过掌握各种交易类型的识别方法，开发者可以：

分析交易模式和趋势
构建智能的区块链浏览器
实现准确的交易验证
开发支持多种交易类型的钱包

在下一篇文章中，我们将探讨比特币交易的构建和签名过程。

比特币地址生成与验证 - 完整指南

2024-01-16T00:00:00.000Z

比特币地址是比特币网络中的关键组件，它们代表公钥的哈希值，用于接收比特币。本文将详细介绍比特币地址的生成过程，包括传统的 Base58 地址和现代的 Bech32 地址。

比特币地址类型

比特币支持多种地址格式：

Legacy 地址 (P2PKH) - 以 "1" 开头的 Base58 地址
P2SH 地址 - 以 "3" 开头的 Base58 地址
Native SegWit 地址 (P2WPKH) - 以 "bc1" 开头的 Bech32 地址
Taproot 地址 (P2TR) - 以 "bc1p" 开头的 Bech32m 地址

地址生成核心算法

1. 公钥哈希计算

所有比特币地址都基于公钥的哈希值生成：

const { sha256x2, sha256, ripemd160 } = require('../utils/crypto');

// 计算公钥哈希的标准流程
function calculatePubKeyHash(pubkey) {
  const hash256 = sha256(pubkey);        // SHA256
  const hash160 = ripemd160(hash256);    // RIPEMD160
  return hash160;
}

2. Base58 地址生成

传统的 Base58 地址生成过程：

// https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch04_keys.adoc
// pubKeyHash: Version byte. 0x00 for Mainnet P2PKH, 0x6f for Testnet, etc.
export function toBase58Address(pubkey: Buffer, pubKeyHash = 0x00): string {
  const hash256 = sha256(pubkey);
  const hash160 = ripemd160(hash256);

  // version + payload
  const payload = Buffer.allocUnsafe(21);
  payload.writeUInt8(pubKeyHash, 0);
  hash160.copy(payload, 1);

  // checksum, first 4 buffer
  const checksum = sha256x2(payload).slice(0, 4);

  // Buffer.concat([payload, checksum], payload.length + 4);
  const buffer = Buffer.allocUnsafe(25);
  payload.copy(buffer);
  checksum.copy(buffer, 21);

  // version + payload + checksum(first 4 bytes)

详细步骤说明：

版本字节: 添加网络标识符（主网为 0x00，测试网为 0x6f）
公钥哈希: 将 RIPEMD160(SHA256(公钥)) 添加到版本字节后
校验和: 计算双重 SHA256 哈希的前 4 字节作为校验和
Base58 编码: 将整个 25 字节数据编码为 Base58 字符串

3. Bech32 地址生成

现代的 Bech32 地址（SegWit）生成过程：

export function toBech32Address(pubkey: Buffer, pubKeyHash = 0x00): string {
  // pubKeyHash: Witness version. 0x00 for P2WPKH
  const hash256 = sha256(pubkey);
  const hash160 = ripemd160(hash256);

  const words = bech32.toWords(hash160);
  words.unshift(pubKeyHash);
  return bech32.encode('bc', words);

地址验证

function validateBase58Address(address) {
  try {
    const decoded = base58.decode(address);
    if (decoded.length !== 25) return false;
    
    const version = decoded[0];
    const payload = decoded.slice(0, 21);
    const checksum = decoded.slice(21);
    
    const calculatedChecksum = sha256x2(payload).slice(0, 4);
    return checksum.equals(calculatedChecksum);
  } catch (error) {
    return false;
  }
}

function validateBech32Address(address) {
  try {
    const decoded = bech32.decode(address);
    return decoded.prefix === 'bc' && decoded.words.length > 0;
  } catch (error) {
    return false;
  }
}

多签名地址

多签名地址允许多个私钥共同控制资金：

import bitgoV1 from '@bitgo/utxo-lib';
import { payments } from 'bitcoinjs-lib';

const pubKeys = [
  '02f4147da97162a214dbe25828ee4c4acc4dc721cd0c15b2761b43ed0292ed82b5', // 2 -3
  '0377155e520059d3b85c6afc5c617b7eb519afadd0360f1ef03aff3f7e3f5438dd',
  '02f44bce3eecd274e7aa24ec975388d12905dfc670a99b16e1d968e6ab5f69b266',
].map(function (hex) {
  return Buffer.from(hex, 'hex');
});

const threshold = 2;
const network = bitgoV1.networks.testnet

var redeemScript = bitgoV1.script.multisig.output.encode(threshold, pubKeys); // 2 of 3
var scriptPubKey = bitgoV1.script.scriptHash.output.encode(bitgoV1.crypto.hash160(redeemScript));
var address = bitgoV1.address.fromOutputScript(scriptPubKey, network);
console.log('bitgo address  : ', address);

//
var { address } = payments.p2sh({
  redeem: payments.p2ms({ m: threshold, pubkeys: pubKeys, network }),
  network,
});

console.log('bitcoin address: ', address);

网络标识符

不同网络使用不同的版本字节：

网络	Legacy	P2SH	Bech32
主网	0x00	0x05	bc1
测试网	0x6f	0xc4	tb1
回归测试	0x6f	0xc4	bcrt1

安全考虑

私钥安全: 永远不要暴露私钥
地址重用: 避免重复使用地址以保护隐私
网络验证: 确保在正确的网络上生成地址
校验和验证: 始终验证地址的校验和

总结

比特币地址生成是一个多步骤的过程，涉及密码学哈希函数、校验和计算和编码转换。理解这个过程对于：

开发比特币钱包应用
验证交易地址的有效性
实现安全的密钥管理
支持多种地址格式

在下一篇文章中，我们将探讨比特币交易类型的分类和识别。

比特币脚本系统详解 - 从理论到实践

2024-01-15T00:00:00.000Z

比特币脚本系统是比特币网络的核心组件之一，它定义了如何验证交易的有效性。本文将深入探讨比特币脚本的工作原理，并通过实际代码示例来展示如何操作脚本。

以下代码参考 bitcoinjs-lib 的实现, 并进行了一些修改. 请参考 bitcoinjs-lib 了解更多信息.

什么是比特币脚本？

比特币脚本是一种基于栈的编程语言，用于定义比特币交易的解锁和锁定条件。每个比特币交易都包含输入脚本（scriptSig）和输出脚本（scriptPubKey），通过执行这些脚本来验证交易的有效性。

核心功能模块

1. 脚本编译 (compile)

脚本编译是将脚本块（chunks）转换为字节码的过程：

export function compile(chunks: Uint8Array[]): Buffer {
  if (Buffer.isBuffer(chunks)) return chunks;
  typeforce(typeforce.Array, chunks);

  const bufferSize = chunks.reduce((accum, chunk) => {
    // data chunk
    if (Buffer.isBuffer(chunk)) {
      // adhere to BIP62.3, minimal push policy
      if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {
        return accum + 1;
      }

      return accum + pushdata.encodingLength(chunk.length) + chunk.length;
    }

    // opcode
    return accum + 1;
  }, 0.0);

  const buffer = Buffer.allocUnsafe(bufferSize);
  let offset = 0;
  chunks.forEach((chunk) => {
    // data chunk
    if (Buffer.isBuffer(chunk)) {
      // adhere to BIP62.3, minimal push policy
      const opcode = asMinimalOP(chunk);
      if (opcode !== undefined) {
        buffer.writeUInt8(opcode, offset);
        offset += 1;
        return;
      }

      offset += pushdata.encode(buffer, chunk.length, offset);
      chunk.copy(buffer, offset);
      offset += chunk.length;

      // opcode
    } else {
      buffer.writeUInt8(chunk, offset);
      offset += 1;
    }
  });

  if (offset !== buffer.length) throw new Error('Could not decode chunks');
  return buffer;
}

2. 脚本反编译 (decompile)

反编译是将字节码转换回脚本块的过程：

export function decompile(buffer: Buffer) {
  if (typeforce.Array(buffer)) return buffer;

  typeforce(typeforce.Buffer, buffer);

  const chunks = [];
  let i = 0;
  while (i < buffer.length) {
    const opcode = buffer[i];

    // data chunk
    if (opcode > OPS.OP_0 && opcode <= OPS.OP_PUSHDATA4) {
      const d = pushdata.decode(buffer, i);

      if (d === null) return null;

      i += d.size;
      if (i + d.number > buffer.length) return null;

      const data = buffer.slice(i, i + d.number);
      i += d.number;

      const op = asMinimalOP(data);
      if (op !== undefined) {
        chunks.push(op);
      } else {
        chunks.push(data);
      }
    } else {
      chunks.push(opcode);
      i += 1;
    }
  }

  return chunks;
}

3. ASM 格式转换

比特币脚本支持人类可读的 ASM（Assembly）格式：

export function fromASM(asm: string) {
  const separator = ' ';
  typeforce(typeforce.String, asm);
  const chunks = asm.split(separator).map((str) => {
    // opcode
    if (OPS[str] !== undefined) return OPS[str];

    typeforce(typeforce.Hex, str);

    return Buffer.from(str, 'hex');
  });
  return compile(chunks);
}

export function toASM(chunks: Uint8Array[]) {
  const separator = ' ';
  if (Buffer.isBuffer(chunks)) {
    chunks = decompile(chunks);
  }

  return chunks
    .map((chunk) => {
      if (Buffer.isBuffer(chunk)) {
        const op = asMinimalOP(chunk);
        if (op === undefined) return chunk.toString('hex');

        chunk = op;
      }

      return REVERSE_OPS[chunk];
    })
    .join(separator);
}

实际应用示例

创建 P2PKH 脚本

// 创建一个标准的 P2PKH 脚本
const pubkeyHash = Buffer.from('1234567890abcdef1234567890abcdef12345678', 'hex');
const p2pkhScript = [
  OPS.OP_DUP,
  OPS.OP_HASH160,
  pubkeyHash,
  OPS.OP_EQUALVERIFY,
  OPS.OP_CHECKSIG
];

const compiledScript = compile(p2pkhScript);
console.log('Compiled script:', compiledScript.toString('hex'));

验证公钥格式

const pubkey = Buffer.from('02...', 'hex'); // 你的公钥
if (isCanonicalPubKey(pubkey)) {
  console.log('Valid canonical public key');
} else {
  console.log('Invalid public key format');
}

最小推送策略 (BIP62.3)

比特币脚本遵循最小推送策略，确保数据以最紧凑的方式表示：

export function asMinimalOP(buffer: Uint8Array) {
  if (buffer.length === 0) return OPS.OP_0;
  if (buffer.length !== 1) return;
  if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0];
  if (buffer[0] === 0x81) return OPS.OP_1NEGATE;
}

总结

比特币脚本系统提供了强大的灵活性来定义各种交易条件。通过理解脚本的编译、反编译和 ASM 格式转换，开发者可以：

创建自定义的交易类型
验证交易脚本的有效性
调试和优化脚本性能
实现复杂的智能合约逻辑

在下一篇文章中，我们将探讨比特币地址的生成和验证机制。

Blockchain Notes Blog

钱包和地址生成

生成私钥​

私钥生成地址​

比特币交易构建与签名 - 完整实践指南

交易构建基础​

1. 环境设置​

2. 密钥管理​

PSBT 交易构建​

不同类型的交易构建​

1. 地址生成​

2. 多签名交易​

交易签名​

1. 单签名​

2. 多签名​

RBF (Replace-By-Fee) 交易​

交易验证​

交易广播​

完整交易流程示例​

安全最佳实践​

总结​

比特币交易类型分类详解 - 识别与分析

比特币交易类型概述​

核心分类函数​

1. P2PKH 交易识别​

2. P2SH 交易识别​

3. P2WPKH 交易识别​

4. P2WSH 交易识别​

5. P2PK 交易识别​

6. 多签名交易识别​

7. 见证承诺交易识别​

交易类型分类器​

实际应用示例​

分析交易输出​

批量交易分析​

交易类型统计​

安全考虑​

性能优化​

总结​

比特币地址生成与验证 - 完整指南

比特币地址类型​

地址生成核心算法​

1. 公钥哈希计算​

2. Base58 地址生成​

3. Bech32 地址生成​

地址验证​

多签名地址​

网络标识符​

安全考虑​

总结​

比特币脚本系统详解 - 从理论到实践

什么是比特币脚本？​

核心功能模块​

1. 脚本编译 (compile)​

2. 脚本反编译 (decompile)​

3. ASM 格式转换​

实际应用示例​

创建 P2PKH 脚本​

验证公钥格式​

最小推送策略 (BIP62.3)​

总结​

生成私钥

私钥生成地址

交易构建基础

1. 环境设置

2. 密钥管理

PSBT 交易构建

不同类型的交易构建

1. 地址生成

2. 多签名交易

交易签名

1. 单签名

2. 多签名

RBF (Replace-By-Fee) 交易

交易验证

交易广播

完整交易流程示例

安全最佳实践

总结

比特币交易类型概述

核心分类函数

1. P2PKH 交易识别

2. P2SH 交易识别

3. P2WPKH 交易识别

4. P2WSH 交易识别

5. P2PK 交易识别

6. 多签名交易识别

7. 见证承诺交易识别

交易类型分类器

实际应用示例

分析交易输出

批量交易分析

交易类型统计

安全考虑

性能优化

总结

比特币地址类型

地址生成核心算法

1. 公钥哈希计算

2. Base58 地址生成

3. Bech32 地址生成

地址验证

多签名地址

网络标识符

安全考虑

总结

什么是比特币脚本？

核心功能模块

1. 脚本编译 (compile)

2. 脚本反编译 (decompile)

3. ASM 格式转换

实际应用示例

创建 P2PKH 脚本

验证公钥格式

最小推送策略 (BIP62.3)

总结