367 lines
11 KiB
TypeScript
367 lines
11 KiB
TypeScript
import { BaseBlockchain } from './base-blockchain.js';
|
|
import {
|
|
type BlockchainCallback,
|
|
type BlockchainTransaction,
|
|
type BlockchainTransactions,
|
|
type BlockchainUTXO,
|
|
type BlockchainUTXOs,
|
|
} from './types.js';
|
|
|
|
import {
|
|
Address,
|
|
ExtMap,
|
|
Outpoint,
|
|
Transaction,
|
|
UTXO,
|
|
} from '@xocash/primitives';
|
|
|
|
import {
|
|
type Output,
|
|
binToHex,
|
|
createVirtualMachineBCH,
|
|
} from '@bitauth/libauth';
|
|
|
|
// Local Blockchain Adapter.
|
|
// This simulates the BCH Blockchain.
|
|
export class BlockchainInMemory extends BaseBlockchain {
|
|
static from() {
|
|
return new BlockchainInMemory();
|
|
}
|
|
|
|
private transactions: BlockchainTransactions;
|
|
private addressSubscriptions: Map<string, Set<BlockchainCallback>>;
|
|
private transactionSubscriptions: Map<string, Set<BlockchainCallback>>;
|
|
|
|
constructor() {
|
|
super();
|
|
|
|
this.transactions = new ExtMap<BlockchainTransaction>();
|
|
this.addressSubscriptions = new Map();
|
|
this.transactionSubscriptions = new Map();
|
|
}
|
|
|
|
async start() {}
|
|
|
|
async stop() {}
|
|
|
|
async fetchUnspents(address: string) {
|
|
// Derive the current UTXO set.
|
|
const utxoSet = this.deriveUtxoSet().filter((blockchainUTXO) => {
|
|
// Decode the address and locking bytecode.
|
|
const utxoAddress = Address.fromLockscriptBytes(
|
|
blockchainUTXO.utxo.output.lockingBytecode,
|
|
);
|
|
const needleAddress = Address.from(address);
|
|
|
|
// Compare the lockscript hex.
|
|
return utxoAddress.toLockscriptHex() === needleAddress.toLockscriptHex();
|
|
});
|
|
|
|
return utxoSet;
|
|
}
|
|
|
|
async fetchTransaction(txHash: string) {
|
|
const tx = this.transactions.get(txHash);
|
|
|
|
if (!tx) {
|
|
throw new Error(`Transaction "${txHash}" does not exist`);
|
|
}
|
|
|
|
return tx.transaction;
|
|
}
|
|
|
|
async fetchAddressHistory(address: string) {
|
|
return this.transactions.filter((tx) => {
|
|
// Check if any input or output involves the address
|
|
// This is a simplified check and might need to be more sophisticated in a real implementation
|
|
return (
|
|
tx.transaction
|
|
.getInputs()
|
|
.some((input) =>
|
|
binToHex(input.unlockingBytecode).includes(address),
|
|
) ||
|
|
tx.transaction
|
|
.getOutputs()
|
|
.some((output) => binToHex(output.lockingBytecode).includes(address))
|
|
);
|
|
});
|
|
}
|
|
|
|
async broadcastTransaction(
|
|
tx: Transaction | Uint8Array | string,
|
|
opts: { skipValidation: boolean } = { skipValidation: false },
|
|
) {
|
|
// Cast to transaction object.
|
|
if (!(tx instanceof Transaction)) {
|
|
tx = Transaction.from(tx);
|
|
}
|
|
|
|
// Derive the UTXO set so that we can find source outputs.
|
|
const utxoSet = this.deriveUtxoSet();
|
|
|
|
if (!opts.skipValidation) {
|
|
// Find the source outputs from our UTXO set so that we can make sure the transaction is valid.
|
|
const sourceOutputs = tx.getInputs().map((input) => {
|
|
const utxoId = `${binToHex(input.outpointTransactionHash)}:${
|
|
input.outpointIndex
|
|
}`;
|
|
|
|
const blockchainUTXO = utxoSet.get(utxoId);
|
|
|
|
if (!blockchainUTXO) {
|
|
throw new Error(`BlockchainUTXO "${utxoId}" does not exist`);
|
|
}
|
|
|
|
return blockchainUTXO.utxo;
|
|
});
|
|
|
|
// Validate the transaction.
|
|
BlockchainInMemory.validateTransaction(
|
|
tx,
|
|
sourceOutputs.map((utxo) => utxo.output),
|
|
);
|
|
}
|
|
|
|
// Add the transaction.
|
|
this.addTransaction({
|
|
hash: tx.toHash(),
|
|
transaction: tx,
|
|
height: 0,
|
|
});
|
|
|
|
// Notify our address and transaction subscribers.
|
|
this.notifyAddressSubscribers(tx);
|
|
this.notifyTransactionSubscribers(tx);
|
|
}
|
|
|
|
async subscribeLockscript(
|
|
lockscript: string | Uint8Array,
|
|
callback: BlockchainCallback,
|
|
) {
|
|
// Fulcrum does not support subscribing to lockscripts, so we cast it to an address.
|
|
const address = Address.fromLockscript(lockscript);
|
|
|
|
// TODO: Refactor to work around ScriptHash for Fulcrum.
|
|
// Otherwise, we may get issues with CashAddr/Legacy Addresses.
|
|
|
|
// Use our subscribeAddress function.
|
|
return await this.subscribeAddress(address.toCashAddr(), callback);
|
|
}
|
|
|
|
async unsubscribeLockscript(
|
|
lockscript: string | Uint8Array,
|
|
callback: BlockchainCallback,
|
|
): Promise<boolean> {
|
|
// Fulcrum does not support subscribing to lockscripts, so we cast it to an address.
|
|
const address = Address.fromLockscript(lockscript);
|
|
|
|
// TODO: Refactor to work around ScriptHash for Fulcrum.
|
|
// Otherwise, we may get issues with CashAddr/Legacy Addresses.
|
|
|
|
// Use our unsubscribeAddress function.
|
|
return await this.unsubscribeAddress(address.toCashAddr(), callback);
|
|
}
|
|
|
|
async subscribeAddress(address: string, callback: BlockchainCallback) {
|
|
// Convert the address to it's lockscript hex so that it's consistently represented.
|
|
const lockscriptHex = Address.from(address).toLockscriptHex();
|
|
|
|
// If no subscriptions exist yet on this lockscript, create a new Set.
|
|
if (!this.addressSubscriptions.has(lockscriptHex)) {
|
|
this.addressSubscriptions.set(lockscriptHex, new Set());
|
|
}
|
|
|
|
// Add the address notification callback.
|
|
this.addressSubscriptions.get(lockscriptHex)!.add(callback);
|
|
|
|
// Return an unsubscribe callback.
|
|
return async () => await this.unsubscribeAddress(address, callback);
|
|
}
|
|
|
|
async unsubscribeAddress(address: string, callback: BlockchainCallback) {
|
|
// Convert the address to it's lockscript hex so that it's consistently represented.
|
|
const lockscriptHex = Address.from(address).toLockscriptHex();
|
|
|
|
// Find all callbacks this lockscript is subscribed to.
|
|
const callbacks = this.addressSubscriptions.get(lockscriptHex);
|
|
if (callbacks) {
|
|
if (callbacks.has(callback)) {
|
|
return false;
|
|
}
|
|
|
|
callbacks.delete(callback);
|
|
|
|
if (callbacks.size === 0) {
|
|
this.addressSubscriptions.delete(address);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
async subscribeTransaction(
|
|
transactionHash: string,
|
|
callback: BlockchainCallback,
|
|
) {
|
|
if (!this.transactionSubscriptions.has(transactionHash)) {
|
|
this.transactionSubscriptions.set(transactionHash, new Set());
|
|
}
|
|
this.transactionSubscriptions.get(transactionHash)!.add(callback);
|
|
|
|
// Return an unsubscribe callback.
|
|
return async () =>
|
|
await this.unsubscribeTransaction(transactionHash, callback);
|
|
}
|
|
|
|
async unsubscribeTransaction(
|
|
transactionHash: string,
|
|
callback: BlockchainCallback,
|
|
) {
|
|
const callbacks = this.transactionSubscriptions.get(transactionHash);
|
|
if (callbacks) {
|
|
if (!callbacks.has(callback)) {
|
|
return false;
|
|
}
|
|
|
|
callbacks.delete(callback);
|
|
if (callbacks.size === 0) {
|
|
this.transactionSubscriptions.delete(transactionHash);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private notifyAddressSubscribers(tx: Transaction) {
|
|
// Derive the UTXO state so that we can lookup source outputs.
|
|
const utxoState = this.deriveUtxoSet();
|
|
|
|
// First, notify all source output listeners.
|
|
tx.getInputs().forEach((input) => {
|
|
const sourceOutput = utxoState.get(
|
|
`${input.outpointTransactionHash};${input.outpointIndex}`,
|
|
);
|
|
|
|
// If there is no corresponding source output, skip this notification.
|
|
// NOTE: This can occur if skipValidation is set to true in broadcast (which would be used for "coinbase" transactions).
|
|
if (!sourceOutput) {
|
|
return;
|
|
}
|
|
|
|
const address = Address.fromLockscriptBytes(
|
|
sourceOutput.utxo.output.lockingBytecode,
|
|
).toLockscriptHex();
|
|
|
|
const callbacks = this.addressSubscriptions.get(address);
|
|
|
|
if (callbacks) {
|
|
callbacks.forEach((callback) => callback(address));
|
|
}
|
|
});
|
|
|
|
// Then notify all output listeners.
|
|
tx.getOutputs().forEach((output) => {
|
|
const address = Address.fromLockscriptBytes(
|
|
output.lockingBytecode,
|
|
).toLockscriptHex();
|
|
|
|
const callbacks = this.addressSubscriptions.get(address);
|
|
|
|
if (callbacks) {
|
|
callbacks.forEach((callback) => callback(address));
|
|
}
|
|
});
|
|
}
|
|
|
|
private notifyTransactionSubscribers(tx: Transaction) {
|
|
const txHash = tx.toHashHex();
|
|
const callbacks = this.transactionSubscriptions.get(txHash);
|
|
if (callbacks) {
|
|
// In this local simulation, we're not tracking block height, so we'll use null
|
|
callbacks.forEach((callback) => callback(txHash));
|
|
}
|
|
}
|
|
|
|
addTransaction(tx: BlockchainTransaction) {
|
|
this.transactions.set(tx.hash.toHex(), tx);
|
|
}
|
|
|
|
removeTransaction(txHash: string) {
|
|
this.transactions.delete(txHash);
|
|
}
|
|
|
|
deriveUtxoSet(): BlockchainUTXOs {
|
|
const utxoMap: BlockchainUTXOs = new ExtMap();
|
|
|
|
// First, add all outputs as potential UTXOs
|
|
for (const tx of this.transactions.values()) {
|
|
tx.transaction.getOutputs().forEach((output, outpointIndex) => {
|
|
const utxo: BlockchainUTXO = {
|
|
height: 0,
|
|
utxo: UTXO.from(new Outpoint(tx.hash.toBytes(), outpointIndex), {
|
|
valueSatoshis: output.valueSatoshis,
|
|
lockingBytecode: output.lockingBytecode,
|
|
}),
|
|
};
|
|
utxoMap.set(`${tx.hash.toHex()}:${outpointIndex}`, utxo);
|
|
});
|
|
}
|
|
|
|
// Then, remove all spent outputs
|
|
for (const tx of this.transactions.values()) {
|
|
tx.transaction.getInputs().forEach((input) => {
|
|
const outpointTransactionHashHex = binToHex(
|
|
input.outpointTransactionHash,
|
|
);
|
|
|
|
utxoMap.delete(`${outpointTransactionHashHex}:${input.outpointIndex}`);
|
|
});
|
|
}
|
|
|
|
return utxoMap;
|
|
}
|
|
|
|
async mineBlock(outputs: Array<Output>): Promise<void> {
|
|
// Create a transaction that pays to our subscribed address.
|
|
const transaction = Transaction.fromRaw({
|
|
version: 2,
|
|
locktime: 0,
|
|
inputs: [
|
|
{
|
|
outpointIndex: 0,
|
|
outpointTransactionHash: new Uint8Array(),
|
|
unlockingBytecode: new Uint8Array(),
|
|
sequenceNumber: 0,
|
|
},
|
|
],
|
|
outputs,
|
|
});
|
|
|
|
// Broadcast that transaction.
|
|
await this.broadcastTransaction(transaction, { skipValidation: true });
|
|
}
|
|
|
|
/**
|
|
* @remarks Consider moving this to Transaction Primitive. Trade-off is that it's probably big. Maybe standalone util?
|
|
*/
|
|
static validateTransaction(tx: Transaction, sourceOutputs: Array<Output>) {
|
|
const virtualMachine = createVirtualMachineBCH();
|
|
const virtualMachineResult = virtualMachine.verify({
|
|
transaction: {
|
|
version: tx.getVersion(),
|
|
locktime: tx.getLocktime(),
|
|
inputs: tx.getInputs(),
|
|
outputs: tx.getOutputs(),
|
|
},
|
|
sourceOutputs,
|
|
});
|
|
|
|
// If simulation of the transaction fails...
|
|
if (typeof virtualMachineResult === 'string') {
|
|
throw new Error(virtualMachineResult);
|
|
}
|
|
}
|
|
}
|