Jonathan Underwood
6 years ago
committed by
GitHub
GitHub
51 changed files with 2636 additions and 2270 deletions
@ -0,0 +1,4 @@ |
|||
{ |
|||
"singleQuote": true, |
|||
"trailingComma": "all" |
|||
} |
|||
@ -1,101 +1,119 @@ |
|||
import { Network } from './networks' |
|||
import * as types from './types' |
|||
import * as bscript from './script' |
|||
import * as networks from './networks' |
|||
import * as payments from './payments' |
|||
import { Network } from './networks'; |
|||
import * as types from './types'; |
|||
import * as bscript from './script'; |
|||
import * as networks from './networks'; |
|||
import * as payments from './payments'; |
|||
|
|||
const bech32 = require('bech32') |
|||
const bs58check = require('bs58check') |
|||
const typeforce = require('typeforce') |
|||
const bech32 = require('bech32'); |
|||
const bs58check = require('bs58check'); |
|||
const typeforce = require('typeforce'); |
|||
|
|||
export type Base58CheckResult = { |
|||
hash: Buffer; |
|||
version: number; |
|||
} |
|||
}; |
|||
|
|||
export type Bech32Result = { |
|||
version: number; |
|||
prefix: string; |
|||
data: Buffer; |
|||
} |
|||
}; |
|||
|
|||
export function fromBase58Check (address: string): Base58CheckResult { |
|||
const payload = bs58check.decode(address) |
|||
export function fromBase58Check(address: string): Base58CheckResult { |
|||
const payload = bs58check.decode(address); |
|||
|
|||
// TODO: 4.0.0, move to "toOutputScript"
|
|||
if (payload.length < 21) throw new TypeError(address + ' is too short') |
|||
if (payload.length > 21) throw new TypeError(address + ' is too long') |
|||
if (payload.length < 21) throw new TypeError(address + ' is too short'); |
|||
if (payload.length > 21) throw new TypeError(address + ' is too long'); |
|||
|
|||
const version = payload.readUInt8(0) |
|||
const hash = payload.slice(1) |
|||
const version = payload.readUInt8(0); |
|||
const hash = payload.slice(1); |
|||
|
|||
return { version: version, hash: hash } |
|||
return { version: version, hash: hash }; |
|||
} |
|||
|
|||
export function fromBech32 (address: string): Bech32Result { |
|||
const result = bech32.decode(address) |
|||
const data = bech32.fromWords(result.words.slice(1)) |
|||
export function fromBech32(address: string): Bech32Result { |
|||
const result = bech32.decode(address); |
|||
const data = bech32.fromWords(result.words.slice(1)); |
|||
|
|||
return { |
|||
version: result.words[0], |
|||
prefix: result.prefix, |
|||
data: Buffer.from(data) |
|||
} |
|||
data: Buffer.from(data), |
|||
}; |
|||
} |
|||
|
|||
export function toBase58Check (hash: Buffer, version: number): string { |
|||
typeforce(types.tuple(types.Hash160bit, types.UInt8), arguments) |
|||
export function toBase58Check(hash: Buffer, version: number): string { |
|||
typeforce(types.tuple(types.Hash160bit, types.UInt8), arguments); |
|||
|
|||
const payload = Buffer.allocUnsafe(21) |
|||
payload.writeUInt8(version, 0) |
|||
hash.copy(payload, 1) |
|||
const payload = Buffer.allocUnsafe(21); |
|||
payload.writeUInt8(version, 0); |
|||
hash.copy(payload, 1); |
|||
|
|||
return bs58check.encode(payload) |
|||
return bs58check.encode(payload); |
|||
} |
|||
|
|||
export function toBech32 (data: Buffer, version: number, prefix: string): string { |
|||
const words = bech32.toWords(data) |
|||
words.unshift(version) |
|||
export function toBech32( |
|||
data: Buffer, |
|||
version: number, |
|||
prefix: string, |
|||
): string { |
|||
const words = bech32.toWords(data); |
|||
words.unshift(version); |
|||
|
|||
return bech32.encode(prefix, words) |
|||
return bech32.encode(prefix, words); |
|||
} |
|||
|
|||
export function fromOutputScript (output: Buffer, network: Network): string { //TODO: Network
|
|||
network = network || networks.bitcoin |
|||
export function fromOutputScript(output: Buffer, network: Network): string { |
|||
//TODO: Network
|
|||
network = network || networks.bitcoin; |
|||
|
|||
try { return <string>payments.p2pkh({ output, network }).address } catch (e) {} |
|||
try { return <string>payments.p2sh({ output, network }).address } catch (e) {} |
|||
try { return <string>payments.p2wpkh({ output, network }).address } catch (e) {} |
|||
try { return <string>payments.p2wsh({ output, network }).address } catch (e) {} |
|||
try { |
|||
return <string>payments.p2pkh({ output, network }).address; |
|||
} catch (e) {} |
|||
try { |
|||
return <string>payments.p2sh({ output, network }).address; |
|||
} catch (e) {} |
|||
try { |
|||
return <string>payments.p2wpkh({ output, network }).address; |
|||
} catch (e) {} |
|||
try { |
|||
return <string>payments.p2wsh({ output, network }).address; |
|||
} catch (e) {} |
|||
|
|||
throw new Error(bscript.toASM(output) + ' has no matching Address') |
|||
throw new Error(bscript.toASM(output) + ' has no matching Address'); |
|||
} |
|||
|
|||
export function toOutputScript (address: string, network: Network): Buffer { |
|||
network = network || networks.bitcoin |
|||
export function toOutputScript(address: string, network: Network): Buffer { |
|||
network = network || networks.bitcoin; |
|||
|
|||
let decodeBase58: Base58CheckResult | undefined = undefined |
|||
let decodeBech32: Bech32Result | undefined = undefined |
|||
let decodeBase58: Base58CheckResult | undefined = undefined; |
|||
let decodeBech32: Bech32Result | undefined = undefined; |
|||
try { |
|||
decodeBase58 = fromBase58Check(address) |
|||
decodeBase58 = fromBase58Check(address); |
|||
} catch (e) {} |
|||
|
|||
if (decodeBase58) { |
|||
if (decodeBase58.version === network.pubKeyHash) return <Buffer>payments.p2pkh({ hash: decodeBase58.hash }).output |
|||
if (decodeBase58.version === network.scriptHash) return <Buffer>payments.p2sh({ hash: decodeBase58.hash }).output |
|||
if (decodeBase58.version === network.pubKeyHash) |
|||
return <Buffer>payments.p2pkh({ hash: decodeBase58.hash }).output; |
|||
if (decodeBase58.version === network.scriptHash) |
|||
return <Buffer>payments.p2sh({ hash: decodeBase58.hash }).output; |
|||
} else { |
|||
try { |
|||
decodeBech32 = fromBech32(address) |
|||
decodeBech32 = fromBech32(address); |
|||
} catch (e) {} |
|||
|
|||
if (decodeBech32) { |
|||
if (decodeBech32.prefix !== network.bech32) throw new Error(address + ' has an invalid prefix') |
|||
if (decodeBech32.prefix !== network.bech32) |
|||
throw new Error(address + ' has an invalid prefix'); |
|||
if (decodeBech32.version === 0) { |
|||
if (decodeBech32.data.length === 20) return <Buffer>payments.p2wpkh({ hash: decodeBech32.data }).output |
|||
if (decodeBech32.data.length === 32) return <Buffer>payments.p2wsh({ hash: decodeBech32.data }).output |
|||
if (decodeBech32.data.length === 20) |
|||
return <Buffer>payments.p2wpkh({ hash: decodeBech32.data }).output; |
|||
if (decodeBech32.data.length === 32) |
|||
return <Buffer>payments.p2wsh({ hash: decodeBech32.data }).output; |
|||
} |
|||
} |
|||
} |
|||
|
|||
throw new Error(address + ' has no matching Script') |
|||
throw new Error(address + ' has no matching Script'); |
|||
} |
|||
|
|||
@ -1,37 +1,44 @@ |
|||
// https://github.com/feross/buffer/blob/master/index.js#L1127
|
|||
function verifuint (value: number, max: number): void { |
|||
if (typeof value !== 'number') throw new Error('cannot write a non-number as a number') |
|||
if (value < 0) throw new Error('specified a negative value for writing an unsigned value') |
|||
if (value > max) throw new Error('RangeError: value out of range') |
|||
if (Math.floor(value) !== value) throw new Error('value has a fractional component') |
|||
function verifuint(value: number, max: number): void { |
|||
if (typeof value !== 'number') |
|||
throw new Error('cannot write a non-number as a number'); |
|||
if (value < 0) |
|||
throw new Error('specified a negative value for writing an unsigned value'); |
|||
if (value > max) throw new Error('RangeError: value out of range'); |
|||
if (Math.floor(value) !== value) |
|||
throw new Error('value has a fractional component'); |
|||
} |
|||
|
|||
export function readUInt64LE (buffer: Buffer, offset: number): number { |
|||
const a = buffer.readUInt32LE(offset) |
|||
let b = buffer.readUInt32LE(offset + 4) |
|||
b *= 0x100000000 |
|||
export function readUInt64LE(buffer: Buffer, offset: number): number { |
|||
const a = buffer.readUInt32LE(offset); |
|||
let b = buffer.readUInt32LE(offset + 4); |
|||
b *= 0x100000000; |
|||
|
|||
verifuint(b + a, 0x001fffffffffffff) |
|||
return b + a |
|||
verifuint(b + a, 0x001fffffffffffff); |
|||
return b + a; |
|||
} |
|||
|
|||
export function writeUInt64LE (buffer: Buffer, value: number, offset: number): number { |
|||
verifuint(value, 0x001fffffffffffff) |
|||
export function writeUInt64LE( |
|||
buffer: Buffer, |
|||
value: number, |
|||
offset: number, |
|||
): number { |
|||
verifuint(value, 0x001fffffffffffff); |
|||
|
|||
buffer.writeInt32LE(value & -1, offset) |
|||
buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4) |
|||
return offset + 8 |
|||
buffer.writeInt32LE(value & -1, offset); |
|||
buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4); |
|||
return offset + 8; |
|||
} |
|||
|
|||
export function reverseBuffer (buffer: Buffer): Buffer { |
|||
if (buffer.length < 1) return buffer |
|||
let j = buffer.length - 1 |
|||
let tmp = 0 |
|||
export function reverseBuffer(buffer: Buffer): Buffer { |
|||
if (buffer.length < 1) return buffer; |
|||
let j = buffer.length - 1; |
|||
let tmp = 0; |
|||
for (let i = 0; i < buffer.length / 2; i++) { |
|||
tmp = buffer[i] |
|||
buffer[i] = buffer[j] |
|||
buffer[j] = tmp |
|||
j-- |
|||
tmp = buffer[i]; |
|||
buffer[i] = buffer[j]; |
|||
buffer[j] = tmp; |
|||
j--; |
|||
} |
|||
return buffer |
|||
return buffer; |
|||
} |
|||
|
|||
@ -1,21 +1,27 @@ |
|||
const createHash = require('create-hash') |
|||
const createHash = require('create-hash'); |
|||
|
|||
export function ripemd160 (buffer: Buffer): Buffer { |
|||
return createHash('rmd160').update(buffer).digest() |
|||
export function ripemd160(buffer: Buffer): Buffer { |
|||
return createHash('rmd160') |
|||
.update(buffer) |
|||
.digest(); |
|||
} |
|||
|
|||
export function sha1 (buffer: Buffer): Buffer { |
|||
return createHash('sha1').update(buffer).digest() |
|||
export function sha1(buffer: Buffer): Buffer { |
|||
return createHash('sha1') |
|||
.update(buffer) |
|||
.digest(); |
|||
} |
|||
|
|||
export function sha256 (buffer: Buffer): Buffer { |
|||
return createHash('sha256').update(buffer).digest() |
|||
export function sha256(buffer: Buffer): Buffer { |
|||
return createHash('sha256') |
|||
.update(buffer) |
|||
.digest(); |
|||
} |
|||
|
|||
export function hash160 (buffer: Buffer): Buffer { |
|||
return ripemd160(sha256(buffer)) |
|||
export function hash160(buffer: Buffer): Buffer { |
|||
return ripemd160(sha256(buffer)); |
|||
} |
|||
|
|||
export function hash256 (buffer: Buffer): Buffer { |
|||
return sha256(sha256(buffer)) |
|||
export function hash256(buffer: Buffer): Buffer { |
|||
return sha256(sha256(buffer)); |
|||
} |
|||
|
|||
@ -1,130 +1,132 @@ |
|||
import { Network } from './networks' |
|||
import * as NETWORKS from './networks' |
|||
import * as types from './types' |
|||
const ecc = require('tiny-secp256k1') |
|||
const randomBytes = require('randombytes') |
|||
const typeforce = require('typeforce') |
|||
const wif = require('wif') |
|||
|
|||
const isOptions = typeforce.maybe(typeforce.compile({ |
|||
compressed: types.maybe(types.Boolean), |
|||
network: types.maybe(types.Network) |
|||
})) |
|||
import { Network } from './networks'; |
|||
import * as NETWORKS from './networks'; |
|||
import * as types from './types'; |
|||
const ecc = require('tiny-secp256k1'); |
|||
const randomBytes = require('randombytes'); |
|||
const typeforce = require('typeforce'); |
|||
const wif = require('wif'); |
|||
|
|||
const isOptions = typeforce.maybe( |
|||
typeforce.compile({ |
|||
compressed: types.maybe(types.Boolean), |
|||
network: types.maybe(types.Network), |
|||
}), |
|||
); |
|||
|
|||
interface ECPairOptions { |
|||
compressed?: boolean |
|||
network?: Network |
|||
rng?(arg0: Buffer): Buffer |
|||
compressed?: boolean; |
|||
network?: Network; |
|||
rng?(arg0: Buffer): Buffer; |
|||
} |
|||
|
|||
export interface ECPairInterface { |
|||
compressed: boolean |
|||
network: Network |
|||
privateKey?: Buffer |
|||
publicKey?: Buffer |
|||
toWIF(): string |
|||
sign(hash: Buffer): Buffer |
|||
verify(hash: Buffer, signature: Buffer): Buffer |
|||
getPublicKey?(): Buffer |
|||
compressed: boolean; |
|||
network: Network; |
|||
privateKey?: Buffer; |
|||
publicKey?: Buffer; |
|||
toWIF(): string; |
|||
sign(hash: Buffer): Buffer; |
|||
verify(hash: Buffer, signature: Buffer): Buffer; |
|||
getPublicKey?(): Buffer; |
|||
} |
|||
|
|||
class ECPair implements ECPairInterface { |
|||
compressed: boolean |
|||
network: Network |
|||
private __d?: Buffer |
|||
private __Q?: Buffer |
|||
|
|||
constructor (d?: Buffer, Q?: Buffer, options?: ECPairOptions) { |
|||
if (options === undefined) options = {} |
|||
this.compressed = options.compressed === undefined ? true : options.compressed |
|||
this.network = options.network || NETWORKS.bitcoin |
|||
|
|||
this.__d = undefined |
|||
this.__Q = undefined |
|||
if (d !== undefined) this.__d = d |
|||
if (Q !== undefined) this.__Q = ecc.pointCompress(Q, this.compressed) |
|||
compressed: boolean; |
|||
network: Network; |
|||
private __d?: Buffer; |
|||
private __Q?: Buffer; |
|||
|
|||
constructor(d?: Buffer, Q?: Buffer, options?: ECPairOptions) { |
|||
if (options === undefined) options = {}; |
|||
this.compressed = |
|||
options.compressed === undefined ? true : options.compressed; |
|||
this.network = options.network || NETWORKS.bitcoin; |
|||
|
|||
this.__d = undefined; |
|||
this.__Q = undefined; |
|||
if (d !== undefined) this.__d = d; |
|||
if (Q !== undefined) this.__Q = ecc.pointCompress(Q, this.compressed); |
|||
} |
|||
|
|||
get privateKey (): Buffer | undefined { |
|||
return this.__d |
|||
get privateKey(): Buffer | undefined { |
|||
return this.__d; |
|||
} |
|||
|
|||
get publicKey (): Buffer | undefined { |
|||
if (!this.__Q) this.__Q = ecc.pointFromScalar(this.__d, this.compressed) |
|||
return this.__Q |
|||
get publicKey(): Buffer | undefined { |
|||
if (!this.__Q) this.__Q = ecc.pointFromScalar(this.__d, this.compressed); |
|||
return this.__Q; |
|||
} |
|||
|
|||
toWIF (): string { |
|||
if (!this.__d) throw new Error('Missing private key') |
|||
return wif.encode(this.network.wif, this.__d, this.compressed) |
|||
toWIF(): string { |
|||
if (!this.__d) throw new Error('Missing private key'); |
|||
return wif.encode(this.network.wif, this.__d, this.compressed); |
|||
} |
|||
|
|||
sign (hash: Buffer): Buffer { |
|||
if (!this.__d) throw new Error('Missing private key') |
|||
return ecc.sign(hash, this.__d) |
|||
sign(hash: Buffer): Buffer { |
|||
if (!this.__d) throw new Error('Missing private key'); |
|||
return ecc.sign(hash, this.__d); |
|||
} |
|||
|
|||
verify (hash: Buffer, signature: Buffer): Buffer { |
|||
return ecc.verify(hash, this.publicKey, signature) |
|||
verify(hash: Buffer, signature: Buffer): Buffer { |
|||
return ecc.verify(hash, this.publicKey, signature); |
|||
} |
|||
} |
|||
|
|||
function fromPrivateKey (buffer: Buffer, options?: ECPairOptions): ECPair { |
|||
typeforce(types.Buffer256bit, buffer) |
|||
if (!ecc.isPrivate(buffer)) throw new TypeError('Private key not in range [1, n)') |
|||
typeforce(isOptions, options) |
|||
function fromPrivateKey(buffer: Buffer, options?: ECPairOptions): ECPair { |
|||
typeforce(types.Buffer256bit, buffer); |
|||
if (!ecc.isPrivate(buffer)) |
|||
throw new TypeError('Private key not in range [1, n)'); |
|||
typeforce(isOptions, options); |
|||
|
|||
return new ECPair(buffer, undefined, <ECPairOptions>options) |
|||
return new ECPair(buffer, undefined, <ECPairOptions>options); |
|||
} |
|||
|
|||
function fromPublicKey (buffer: Buffer, options?: ECPairOptions): ECPair { |
|||
typeforce(ecc.isPoint, buffer) |
|||
typeforce(isOptions, options) |
|||
return new ECPair(undefined, buffer, <ECPairOptions>options) |
|||
function fromPublicKey(buffer: Buffer, options?: ECPairOptions): ECPair { |
|||
typeforce(ecc.isPoint, buffer); |
|||
typeforce(isOptions, options); |
|||
return new ECPair(undefined, buffer, <ECPairOptions>options); |
|||
} |
|||
|
|||
function fromWIF (string: string, network?: Network | Array<Network>): ECPair { |
|||
const decoded = wif.decode(string) |
|||
const version = decoded.version |
|||
function fromWIF(string: string, network?: Network | Array<Network>): ECPair { |
|||
const decoded = wif.decode(string); |
|||
const version = decoded.version; |
|||
|
|||
// list of networks?
|
|||
if (types.Array(network)) { |
|||
network = <Network>(<Array<Network>>network).filter(function (x: Network) { |
|||
return version === x.wif |
|||
}).pop() |
|||
network = <Network>(<Array<Network>>network) |
|||
.filter(function(x: Network) { |
|||
return version === x.wif; |
|||
}) |
|||
.pop(); |
|||
|
|||
if (!network) throw new Error('Unknown network version') |
|||
if (!network) throw new Error('Unknown network version'); |
|||
|
|||
// otherwise, assume a network object (or default to bitcoin)
|
|||
// otherwise, assume a network object (or default to bitcoin)
|
|||
} else { |
|||
network = network || NETWORKS.bitcoin |
|||
network = network || NETWORKS.bitcoin; |
|||
|
|||
if (version !== (<Network>network).wif) throw new Error('Invalid network version') |
|||
if (version !== (<Network>network).wif) |
|||
throw new Error('Invalid network version'); |
|||
} |
|||
|
|||
return fromPrivateKey(decoded.privateKey, { |
|||
compressed: decoded.compressed, |
|||
network: <Network>network |
|||
}) |
|||
network: <Network>network, |
|||
}); |
|||
} |
|||
|
|||
function makeRandom (options?: ECPairOptions): ECPair { |
|||
typeforce(isOptions, options) |
|||
if (options === undefined) options = {} |
|||
const rng = options.rng || randomBytes |
|||
function makeRandom(options?: ECPairOptions): ECPair { |
|||
typeforce(isOptions, options); |
|||
if (options === undefined) options = {}; |
|||
const rng = options.rng || randomBytes; |
|||
|
|||
let d |
|||
let d; |
|||
do { |
|||
d = rng(32) |
|||
typeforce(types.Buffer256bit, d) |
|||
} while (!ecc.isPrivate(d)) |
|||
d = rng(32); |
|||
typeforce(types.Buffer256bit, d); |
|||
} while (!ecc.isPrivate(d)); |
|||
|
|||
return fromPrivateKey(d, options) |
|||
return fromPrivateKey(d, options); |
|||
} |
|||
|
|||
export { |
|||
makeRandom, |
|||
fromPrivateKey, |
|||
fromPublicKey, |
|||
fromWIF |
|||
} |
|||
export { makeRandom, fromPrivateKey, fromPublicKey, fromWIF }; |
|||
|
|||
@ -1,28 +1,20 @@ |
|||
import * as bip32 from 'bip32' |
|||
import * as ECPair from './ecpair' |
|||
import * as address from './address' |
|||
import * as crypto from './crypto' |
|||
import * as networks from './networks' |
|||
import * as payments from './payments' |
|||
import * as script from './script' |
|||
import * as bip32 from 'bip32'; |
|||
import * as ECPair from './ecpair'; |
|||
import * as address from './address'; |
|||
import * as crypto from './crypto'; |
|||
import * as networks from './networks'; |
|||
import * as payments from './payments'; |
|||
import * as script from './script'; |
|||
|
|||
export { |
|||
ECPair, |
|||
address, |
|||
bip32, |
|||
crypto, |
|||
networks, |
|||
payments, |
|||
script, |
|||
} |
|||
export { ECPair, address, bip32, crypto, networks, payments, script }; |
|||
|
|||
export { Block } from './block' |
|||
export { Transaction } from './transaction' |
|||
export { TransactionBuilder } from './transaction_builder' |
|||
export { OPS as opcodes } from './script' |
|||
export { Block } from './block'; |
|||
export { Transaction } from './transaction'; |
|||
export { TransactionBuilder } from './transaction_builder'; |
|||
export { OPS as opcodes } from './script'; |
|||
|
|||
export { Payment, PaymentOpts } from './payments' |
|||
export { Input as TxInput, Output as TxOutput } from './transaction' |
|||
export { Network } from './networks' |
|||
export { OpCode } from './script' |
|||
export { BIP32Interface } from 'bip32' |
|||
export { Payment, PaymentOpts } from './payments'; |
|||
export { Input as TxInput, Output as TxOutput } from './transaction'; |
|||
export { Network } from './networks'; |
|||
export { OpCode } from './script'; |
|||
export { BIP32Interface } from 'bip32'; |
|||
|
|||
@ -1,54 +1,59 @@ |
|||
import { Payment, PaymentOpts } from './index' // eslint-disable-line
|
|||
import * as bscript from '../script' |
|||
import * as lazy from './lazy' |
|||
import { bitcoin as BITCOIN_NETWORK } from '../networks' |
|||
const typef = require('typeforce') |
|||
const OPS = bscript.OPS |
|||
|
|||
function stacksEqual (a: Array<Buffer>, b: Array<Buffer>): boolean { |
|||
if (a.length !== b.length) return false |
|||
|
|||
return a.every(function (x, i) { |
|||
return x.equals(b[i]) |
|||
}) |
|||
import { Payment, PaymentOpts } from './index'; |
|||
import * as bscript from '../script'; |
|||
import * as lazy from './lazy'; |
|||
import { bitcoin as BITCOIN_NETWORK } from '../networks'; |
|||
const typef = require('typeforce'); |
|||
const OPS = bscript.OPS; |
|||
|
|||
function stacksEqual(a: Array<Buffer>, b: Array<Buffer>): boolean { |
|||
if (a.length !== b.length) return false; |
|||
|
|||
return a.every(function(x, i) { |
|||
return x.equals(b[i]); |
|||
}); |
|||
} |
|||
|
|||
// output: OP_RETURN ...
|
|||
export function p2data (a: Payment, opts?: PaymentOpts): Payment { |
|||
if ( |
|||
!a.data && |
|||
!a.output |
|||
) throw new TypeError('Not enough data') |
|||
opts = Object.assign({ validate: true }, opts || {}) |
|||
|
|||
typef({ |
|||
network: typef.maybe(typef.Object), |
|||
output: typef.maybe(typef.Buffer), |
|||
data: typef.maybe(typef.arrayOf(typef.Buffer)) |
|||
}, a) |
|||
|
|||
const network = a.network || BITCOIN_NETWORK |
|||
const o = <Payment>{ network } |
|||
|
|||
lazy.prop(o, 'output', function () { |
|||
if (!a.data) return |
|||
return bscript.compile((<Array<Buffer | number>>[OPS.OP_RETURN]).concat(a.data)) |
|||
}) |
|||
lazy.prop(o, 'data', function () { |
|||
if (!a.output) return |
|||
return bscript.decompile(a.output)!.slice(1) |
|||
}) |
|||
export function p2data(a: Payment, opts?: PaymentOpts): Payment { |
|||
if (!a.data && !a.output) throw new TypeError('Not enough data'); |
|||
opts = Object.assign({ validate: true }, opts || {}); |
|||
|
|||
typef( |
|||
{ |
|||
network: typef.maybe(typef.Object), |
|||
output: typef.maybe(typef.Buffer), |
|||
data: typef.maybe(typef.arrayOf(typef.Buffer)), |
|||
}, |
|||
a, |
|||
); |
|||
|
|||
const network = a.network || BITCOIN_NETWORK; |
|||
const o = <Payment>{ network }; |
|||
|
|||
lazy.prop(o, 'output', function() { |
|||
if (!a.data) return; |
|||
return bscript.compile( |
|||
(<Array<Buffer | number>>[OPS.OP_RETURN]).concat(a.data), |
|||
); |
|||
}); |
|||
lazy.prop(o, 'data', function() { |
|||
if (!a.output) return; |
|||
return bscript.decompile(a.output)!.slice(1); |
|||
}); |
|||
|
|||
// extended validation
|
|||
if (opts.validate) { |
|||
if (a.output) { |
|||
const chunks = bscript.decompile(a.output) |
|||
if (chunks![0] !== OPS.OP_RETURN) throw new TypeError('Output is invalid') |
|||
if (!chunks!.slice(1).every(typef.Buffer)) throw new TypeError('Output is invalid') |
|||
|
|||
if (a.data && !stacksEqual(a.data, <Array<Buffer>>o.data)) throw new TypeError('Data mismatch') |
|||
const chunks = bscript.decompile(a.output); |
|||
if (chunks![0] !== OPS.OP_RETURN) |
|||
throw new TypeError('Output is invalid'); |
|||
if (!chunks!.slice(1).every(typef.Buffer)) |
|||
throw new TypeError('Output is invalid'); |
|||
|
|||
if (a.data && !stacksEqual(a.data, <Array<Buffer>>o.data)) |
|||
throw new TypeError('Data mismatch'); |
|||
} |
|||
} |
|||
|
|||
return Object.assign(o, a) |
|||
return Object.assign(o, a); |
|||
} |
|||
|
|||
@ -1,35 +1,35 @@ |
|||
import { Network } from '../networks' // eslint-disable-line
|
|||
import { p2data as embed } from './embed' |
|||
import { p2ms } from './p2ms' |
|||
import { p2pk } from './p2pk' |
|||
import { p2pkh } from './p2pkh' |
|||
import { p2sh } from './p2sh' |
|||
import { p2wpkh } from './p2wpkh' |
|||
import { p2wsh } from './p2wsh' |
|||
import { Network } from '../networks'; |
|||
import { p2data as embed } from './embed'; |
|||
import { p2ms } from './p2ms'; |
|||
import { p2pk } from './p2pk'; |
|||
import { p2pkh } from './p2pkh'; |
|||
import { p2sh } from './p2sh'; |
|||
import { p2wpkh } from './p2wpkh'; |
|||
import { p2wsh } from './p2wsh'; |
|||
|
|||
export interface Payment { |
|||
network?: Network, |
|||
output?: Buffer, |
|||
data?: Array<Buffer>, |
|||
m?: number, |
|||
n?: number, |
|||
pubkeys?: Array<Buffer>, |
|||
input?: Buffer, |
|||
signatures?: Array<Buffer>, |
|||
pubkey?: Buffer, |
|||
signature?: Buffer, |
|||
address?: string, |
|||
hash?: Buffer, |
|||
redeem?: Payment, |
|||
witness?: Array<Buffer>, |
|||
network?: Network; |
|||
output?: Buffer; |
|||
data?: Array<Buffer>; |
|||
m?: number; |
|||
n?: number; |
|||
pubkeys?: Array<Buffer>; |
|||
input?: Buffer; |
|||
signatures?: Array<Buffer>; |
|||
pubkey?: Buffer; |
|||
signature?: Buffer; |
|||
address?: string; |
|||
hash?: Buffer; |
|||
redeem?: Payment; |
|||
witness?: Array<Buffer>; |
|||
} |
|||
|
|||
export interface PaymentOpts { |
|||
validate?: boolean, |
|||
allowIncomplete?: boolean, |
|||
validate?: boolean; |
|||
allowIncomplete?: boolean; |
|||
} |
|||
|
|||
export { embed, p2ms, p2pk, p2pkh, p2sh, p2wpkh, p2wsh } |
|||
export { embed, p2ms, p2pk, p2pkh, p2sh, p2wpkh, p2wsh }; |
|||
|
|||
// TODO
|
|||
// witness commitment
|
|||
|
|||
@ -1,28 +1,28 @@ |
|||
export function prop (object: Object, name: string, f: ()=>any): void { |
|||
export function prop(object: Object, name: string, f: () => any): void { |
|||
Object.defineProperty(object, name, { |
|||
configurable: true, |
|||
enumerable: true, |
|||
get: function () { |
|||
let value = f.call(this) |
|||
this[name] = value |
|||
return value |
|||
get: function() { |
|||
let value = f.call(this); |
|||
this[name] = value; |
|||
return value; |
|||
}, |
|||
set: function (value) { |
|||
set: function(value) { |
|||
Object.defineProperty(this, name, { |
|||
configurable: true, |
|||
enumerable: true, |
|||
value: value, |
|||
writable: true |
|||
}) |
|||
} |
|||
}) |
|||
writable: true, |
|||
}); |
|||
}, |
|||
}); |
|||
} |
|||
|
|||
export function value <T> (f: ()=>T): ()=>T { |
|||
let value: T |
|||
return function (): T { |
|||
if (value !== undefined) return value |
|||
value = f() |
|||
return value |
|||
} |
|||
export function value<T>(f: () => T): () => T { |
|||
let value: T; |
|||
return function(): T { |
|||
if (value !== undefined) return value; |
|||
value = f(); |
|||
return value; |
|||
}; |
|||
} |
|||
|
|||
@ -1,141 +1,160 @@ |
|||
import { Payment, PaymentOpts } from './index' // eslint-disable-line
|
|||
import * as bscript from '../script' |
|||
import * as lazy from './lazy' |
|||
import { bitcoin as BITCOIN_NETWORK } from '../networks' |
|||
const OPS = bscript.OPS |
|||
const typef = require('typeforce') |
|||
const ecc = require('tiny-secp256k1') |
|||
|
|||
const OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1
|
|||
|
|||
function stacksEqual (a: Array<Buffer>, b: Array<Buffer>): boolean { |
|||
if (a.length !== b.length) return false |
|||
|
|||
return a.every(function (x, i) { |
|||
return x.equals(b[i]) |
|||
}) |
|||
import { Payment, PaymentOpts } from './index'; |
|||
import * as bscript from '../script'; |
|||
import * as lazy from './lazy'; |
|||
import { bitcoin as BITCOIN_NETWORK } from '../networks'; |
|||
const OPS = bscript.OPS; |
|||
const typef = require('typeforce'); |
|||
const ecc = require('tiny-secp256k1'); |
|||
|
|||
const OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1
|
|||
|
|||
function stacksEqual(a: Array<Buffer>, b: Array<Buffer>): boolean { |
|||
if (a.length !== b.length) return false; |
|||
|
|||
return a.every(function(x, i) { |
|||
return x.equals(b[i]); |
|||
}); |
|||
} |
|||
|
|||
// input: OP_0 [signatures ...]
|
|||
// output: m [pubKeys ...] n OP_CHECKMULTISIG
|
|||
export function p2ms (a: Payment, opts?: PaymentOpts): Payment { |
|||
export function p2ms(a: Payment, opts?: PaymentOpts): Payment { |
|||
if ( |
|||
!a.input && |
|||
!a.output && |
|||
!(a.pubkeys && a.m !== undefined) && |
|||
!a.signatures |
|||
) throw new TypeError('Not enough data') |
|||
opts = Object.assign({ validate: true }, opts || {}) |
|||
|
|||
function isAcceptableSignature (x: Buffer | number) { |
|||
return bscript.isCanonicalScriptSignature(<Buffer>x) || |
|||
(opts!.allowIncomplete && |
|||
(<number> x === OPS.OP_0)) !== undefined // eslint-disable-line
|
|||
) |
|||
throw new TypeError('Not enough data'); |
|||
opts = Object.assign({ validate: true }, opts || {}); |
|||
|
|||
function isAcceptableSignature(x: Buffer | number) { |
|||
return ( |
|||
bscript.isCanonicalScriptSignature(<Buffer>x) || |
|||
(opts!.allowIncomplete && <number>x === OPS.OP_0) !== undefined |
|||
); |
|||
} |
|||
|
|||
typef({ |
|||
network: typef.maybe(typef.Object), |
|||
m: typef.maybe(typef.Number), |
|||
n: typef.maybe(typef.Number), |
|||
output: typef.maybe(typef.Buffer), |
|||
pubkeys: typef.maybe(typef.arrayOf(ecc.isPoint)), |
|||
|
|||
signatures: typef.maybe(typef.arrayOf(isAcceptableSignature)), |
|||
input: typef.maybe(typef.Buffer) |
|||
}, a) |
|||
|
|||
const network = a.network || BITCOIN_NETWORK |
|||
const o: Payment = { network } |
|||
|
|||
let chunks: Array<Buffer | number> = [] |
|||
let decoded = false |
|||
function decode (output: Buffer | Array<Buffer | number>): void { |
|||
if (decoded) return |
|||
decoded = true |
|||
chunks = <Array<Buffer | number>>bscript.decompile(output) |
|||
o.m = <number> chunks[0] - OP_INT_BASE // eslint-disable-line
|
|||
o.n = <number> chunks[chunks.length - 2] - OP_INT_BASE // eslint-disable-line
|
|||
o.pubkeys = <Array<Buffer>>chunks.slice(1, -2) |
|||
typef( |
|||
{ |
|||
network: typef.maybe(typef.Object), |
|||
m: typef.maybe(typef.Number), |
|||
n: typef.maybe(typef.Number), |
|||
output: typef.maybe(typef.Buffer), |
|||
pubkeys: typef.maybe(typef.arrayOf(ecc.isPoint)), |
|||
|
|||
signatures: typef.maybe(typef.arrayOf(isAcceptableSignature)), |
|||
input: typef.maybe(typef.Buffer), |
|||
}, |
|||
a, |
|||
); |
|||
|
|||
const network = a.network || BITCOIN_NETWORK; |
|||
const o: Payment = { network }; |
|||
|
|||
let chunks: Array<Buffer | number> = []; |
|||
let decoded = false; |
|||
function decode(output: Buffer | Array<Buffer | number>): void { |
|||
if (decoded) return; |
|||
decoded = true; |
|||
chunks = <Array<Buffer | number>>bscript.decompile(output); |
|||
o.m = <number>chunks[0] - OP_INT_BASE; |
|||
o.n = <number>chunks[chunks.length - 2] - OP_INT_BASE; |
|||
o.pubkeys = <Array<Buffer>>chunks.slice(1, -2); |
|||
} |
|||
|
|||
lazy.prop(o, 'output', function () { |
|||
if (!a.m) return |
|||
if (!o.n) return |
|||
if (!a.pubkeys) return |
|||
return bscript.compile((<Array<Buffer | number>>[]).concat( |
|||
OP_INT_BASE + a.m, |
|||
a.pubkeys, |
|||
OP_INT_BASE + o.n, |
|||
OPS.OP_CHECKMULTISIG |
|||
)) |
|||
}) |
|||
lazy.prop(o, 'm', function () { |
|||
if (!o.output) return |
|||
decode(o.output) |
|||
return o.m |
|||
}) |
|||
lazy.prop(o, 'n', function () { |
|||
if (!o.pubkeys) return |
|||
return o.pubkeys.length |
|||
}) |
|||
lazy.prop(o, 'pubkeys', function () { |
|||
if (!a.output) return |
|||
decode(a.output) |
|||
return o.pubkeys |
|||
}) |
|||
lazy.prop(o, 'signatures', function () { |
|||
if (!a.input) return |
|||
return bscript.decompile(a.input)!.slice(1) |
|||
}) |
|||
lazy.prop(o, 'input', function () { |
|||
if (!a.signatures) return |
|||
return bscript.compile((<Array<Buffer | number>>[OPS.OP_0]).concat(a.signatures)) |
|||
}) |
|||
lazy.prop(o, 'witness', function () { |
|||
if (!o.input) return |
|||
return [] |
|||
}) |
|||
lazy.prop(o, 'output', function() { |
|||
if (!a.m) return; |
|||
if (!o.n) return; |
|||
if (!a.pubkeys) return; |
|||
return bscript.compile( |
|||
(<Array<Buffer | number>>[]).concat( |
|||
OP_INT_BASE + a.m, |
|||
a.pubkeys, |
|||
OP_INT_BASE + o.n, |
|||
OPS.OP_CHECKMULTISIG, |
|||
), |
|||
); |
|||
}); |
|||
lazy.prop(o, 'm', function() { |
|||
if (!o.output) return; |
|||
decode(o.output); |
|||
return o.m; |
|||
}); |
|||
lazy.prop(o, 'n', function() { |
|||
if (!o.pubkeys) return; |
|||
return o.pubkeys.length; |
|||
}); |
|||
lazy.prop(o, 'pubkeys', function() { |
|||
if (!a.output) return; |
|||
decode(a.output); |
|||
return o.pubkeys; |
|||
}); |
|||
lazy.prop(o, 'signatures', function() { |
|||
if (!a.input) return; |
|||
return bscript.decompile(a.input)!.slice(1); |
|||
}); |
|||
lazy.prop(o, 'input', function() { |
|||
if (!a.signatures) return; |
|||
return bscript.compile( |
|||
(<Array<Buffer | number>>[OPS.OP_0]).concat(a.signatures), |
|||
); |
|||
}); |
|||
lazy.prop(o, 'witness', function() { |
|||
if (!o.input) return; |
|||
return []; |
|||
}); |
|||
|
|||
// extended validation
|
|||
if (opts.validate) { |
|||
if (a.output) { |
|||
decode(a.output) |
|||
if (!typef.Number(chunks[0])) throw new TypeError('Output is invalid') |
|||
if (!typef.Number(chunks[chunks.length - 2])) throw new TypeError('Output is invalid') |
|||
if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG) throw new TypeError('Output is invalid') |
|||
|
|||
if ( |
|||
o.m! <= 0 || // eslint-disable-line
|
|||
o.n! > 16 || // eslint-disable-line
|
|||
o.m! > o.n! || // eslint-disable-line
|
|||
o.n !== chunks.length - 3) throw new TypeError('Output is invalid') |
|||
if (!o.pubkeys!.every(x => ecc.isPoint(x))) throw new TypeError('Output is invalid') |
|||
|
|||
if (a.m !== undefined && a.m !== o.m) throw new TypeError('m mismatch') |
|||
if (a.n !== undefined && a.n !== o.n) throw new TypeError('n mismatch') |
|||
if (a.pubkeys && !stacksEqual(a.pubkeys, o.pubkeys!)) throw new TypeError('Pubkeys mismatch') |
|||
decode(a.output); |
|||
if (!typef.Number(chunks[0])) throw new TypeError('Output is invalid'); |
|||
if (!typef.Number(chunks[chunks.length - 2])) |
|||
throw new TypeError('Output is invalid'); |
|||
if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG) |
|||
throw new TypeError('Output is invalid'); |
|||
|
|||
if (o.m! <= 0 || o.n! > 16 || o.m! > o.n! || o.n !== chunks.length - 3) |
|||
throw new TypeError('Output is invalid'); |
|||
if (!o.pubkeys!.every(x => ecc.isPoint(x))) |
|||
throw new TypeError('Output is invalid'); |
|||
|
|||
if (a.m !== undefined && a.m !== o.m) throw new TypeError('m mismatch'); |
|||
if (a.n !== undefined && a.n !== o.n) throw new TypeError('n mismatch'); |
|||
if (a.pubkeys && !stacksEqual(a.pubkeys, o.pubkeys!)) |
|||
throw new TypeError('Pubkeys mismatch'); |
|||
} |
|||
|
|||
if (a.pubkeys) { |
|||
if (a.n !== undefined && a.n !== a.pubkeys.length) throw new TypeError('Pubkey count mismatch') |
|||
o.n = a.pubkeys.length |
|||
if (a.n !== undefined && a.n !== a.pubkeys.length) |
|||
throw new TypeError('Pubkey count mismatch'); |
|||
o.n = a.pubkeys.length; |
|||
|
|||
if (o.n < o.m!) throw new TypeError('Pubkey count cannot be less than m') |
|||
if (o.n < o.m!) throw new TypeError('Pubkey count cannot be less than m'); |
|||
} |
|||
|
|||
if (a.signatures) { |
|||
if (a.signatures.length < o.m!) throw new TypeError('Not enough signatures provided') |
|||
if (a.signatures.length > o.m!) throw new TypeError('Too many signatures provided') |
|||
if (a.signatures.length < o.m!) |
|||
throw new TypeError('Not enough signatures provided'); |
|||
if (a.signatures.length > o.m!) |
|||
throw new TypeError('Too many signatures provided'); |
|||
} |
|||
|
|||
if (a.input) { |
|||
if (a.input[0] !== OPS.OP_0) throw new TypeError('Input is invalid') |
|||
if (o.signatures!.length === 0 || !o.signatures!.every(isAcceptableSignature)) throw new TypeError('Input has invalid signature(s)') |
|||
|
|||
if (a.signatures && !stacksEqual(a.signatures, o.signatures!)) throw new TypeError('Signature mismatch') |
|||
if (a.m !== undefined && a.m !== a.signatures!.length) throw new TypeError('Signature count mismatch') |
|||
if (a.input[0] !== OPS.OP_0) throw new TypeError('Input is invalid'); |
|||
if ( |
|||
o.signatures!.length === 0 || |
|||
!o.signatures!.every(isAcceptableSignature) |
|||
) |
|||
throw new TypeError('Input has invalid signature(s)'); |
|||
|
|||
if (a.signatures && !stacksEqual(a.signatures, o.signatures!)) |
|||
throw new TypeError('Signature mismatch'); |
|||
if (a.m !== undefined && a.m !== a.signatures!.length) |
|||
throw new TypeError('Signature count mismatch'); |
|||
} |
|||
} |
|||
|
|||
return Object.assign(o, a) |
|||
return Object.assign(o, a); |
|||
} |
|||
|
|||
@ -1,78 +1,80 @@ |
|||
import { Payment, PaymentOpts } from './index' // eslint-disable-line
|
|||
import * as bscript from '../script' |
|||
import * as lazy from './lazy' |
|||
import { bitcoin as BITCOIN_NETWORK } from '../networks' |
|||
const typef = require('typeforce') |
|||
const OPS = bscript.OPS |
|||
const ecc = require('tiny-secp256k1') |
|||
import { Payment, PaymentOpts } from './index'; |
|||
import * as bscript from '../script'; |
|||
import * as lazy from './lazy'; |
|||
import { bitcoin as BITCOIN_NETWORK } from '../networks'; |
|||
const typef = require('typeforce'); |
|||
const OPS = bscript.OPS; |
|||
const ecc = require('tiny-secp256k1'); |
|||
|
|||
// input: {signature}
|
|||
// output: {pubKey} OP_CHECKSIG
|
|||
export function p2pk (a: Payment, opts?: PaymentOpts): Payment { |
|||
if ( |
|||
!a.input && |
|||
!a.output && |
|||
!a.pubkey && |
|||
!a.input && |
|||
!a.signature |
|||
) throw new TypeError('Not enough data') |
|||
opts = Object.assign({ validate: true }, opts || {}) |
|||
export function p2pk(a: Payment, opts?: PaymentOpts): Payment { |
|||
if (!a.input && !a.output && !a.pubkey && !a.input && !a.signature) |
|||
throw new TypeError('Not enough data'); |
|||
opts = Object.assign({ validate: true }, opts || {}); |
|||
|
|||
typef({ |
|||
network: typef.maybe(typef.Object), |
|||
output: typef.maybe(typef.Buffer), |
|||
pubkey: typef.maybe(ecc.isPoint), |
|||
typef( |
|||
{ |
|||
network: typef.maybe(typef.Object), |
|||
output: typef.maybe(typef.Buffer), |
|||
pubkey: typef.maybe(ecc.isPoint), |
|||
|
|||
signature: typef.maybe(bscript.isCanonicalScriptSignature), |
|||
input: typef.maybe(typef.Buffer) |
|||
}, a) |
|||
signature: typef.maybe(bscript.isCanonicalScriptSignature), |
|||
input: typef.maybe(typef.Buffer), |
|||
}, |
|||
a, |
|||
); |
|||
|
|||
const _chunks = <()=>Array<Buffer | number>>lazy.value(function () { return bscript.decompile(a.input!) }) |
|||
const _chunks = <() => Array<Buffer | number>>lazy.value(function() { |
|||
return bscript.decompile(a.input!); |
|||
}); |
|||
|
|||
const network = a.network || BITCOIN_NETWORK |
|||
const o: Payment = { network } |
|||
const network = a.network || BITCOIN_NETWORK; |
|||
const o: Payment = { network }; |
|||
|
|||
lazy.prop(o, 'output', function () { |
|||
if (!a.pubkey) return |
|||
return bscript.compile([ |
|||
a.pubkey, |
|||
OPS.OP_CHECKSIG |
|||
]) |
|||
}) |
|||
lazy.prop(o, 'pubkey', function () { |
|||
if (!a.output) return |
|||
return a.output.slice(1, -1) |
|||
}) |
|||
lazy.prop(o, 'signature', function () { |
|||
if (!a.input) return |
|||
return <Buffer>_chunks()[0] |
|||
}) |
|||
lazy.prop(o, 'input', function () { |
|||
if (!a.signature) return |
|||
return bscript.compile([a.signature]) |
|||
}) |
|||
lazy.prop(o, 'witness', function () { |
|||
if (!o.input) return |
|||
return [] |
|||
}) |
|||
lazy.prop(o, 'output', function() { |
|||
if (!a.pubkey) return; |
|||
return bscript.compile([a.pubkey, OPS.OP_CHECKSIG]); |
|||
}); |
|||
lazy.prop(o, 'pubkey', function() { |
|||
if (!a.output) return; |
|||
return a.output.slice(1, -1); |
|||
}); |
|||
lazy.prop(o, 'signature', function() { |
|||
if (!a.input) return; |
|||
return <Buffer>_chunks()[0]; |
|||
}); |
|||
lazy.prop(o, 'input', function() { |
|||
if (!a.signature) return; |
|||
return bscript.compile([a.signature]); |
|||
}); |
|||
lazy.prop(o, 'witness', function() { |
|||
if (!o.input) return; |
|||
return []; |
|||
}); |
|||
|
|||
// extended validation
|
|||
if (opts.validate) { |
|||
if (a.output) { |
|||
if (a.output[a.output.length - 1] !== OPS.OP_CHECKSIG) throw new TypeError('Output is invalid') |
|||
if (!ecc.isPoint(o.pubkey)) throw new TypeError('Output pubkey is invalid') |
|||
if (a.pubkey && !a.pubkey.equals(o.pubkey!)) throw new TypeError('Pubkey mismatch') |
|||
if (a.output[a.output.length - 1] !== OPS.OP_CHECKSIG) |
|||
throw new TypeError('Output is invalid'); |
|||
if (!ecc.isPoint(o.pubkey)) |
|||
throw new TypeError('Output pubkey is invalid'); |
|||
if (a.pubkey && !a.pubkey.equals(o.pubkey!)) |
|||
throw new TypeError('Pubkey mismatch'); |
|||
} |
|||
|
|||
if (a.signature) { |
|||
if (a.input && !a.input.equals(o.input!)) throw new TypeError('Signature mismatch') |
|||
if (a.input && !a.input.equals(o.input!)) |
|||
throw new TypeError('Signature mismatch'); |
|||
} |
|||
|
|||
if (a.input) { |
|||
if (_chunks().length !== 1) throw new TypeError('Input is invalid') |
|||
if (!bscript.isCanonicalScriptSignature(o.signature!)) throw new TypeError('Input has invalid signature') |
|||
if (_chunks().length !== 1) throw new TypeError('Input is invalid'); |
|||
if (!bscript.isCanonicalScriptSignature(o.signature!)) |
|||
throw new TypeError('Input has invalid signature'); |
|||
} |
|||
} |
|||
|
|||
return Object.assign(o, a) |
|||
return Object.assign(o, a); |
|||
} |
|||
|
|||
@ -1,134 +1,142 @@ |
|||
import { Payment, PaymentOpts } from './index' // eslint-disable-line
|
|||
import * as bscript from '../script' |
|||
import * as bcrypto from '../crypto' |
|||
import * as lazy from './lazy' |
|||
import { bitcoin as BITCOIN_NETWORK } from '../networks' |
|||
const typef = require('typeforce') |
|||
const OPS = bscript.OPS |
|||
const ecc = require('tiny-secp256k1') |
|||
import { Payment, PaymentOpts } from './index'; |
|||
import * as bscript from '../script'; |
|||
import * as bcrypto from '../crypto'; |
|||
import * as lazy from './lazy'; |
|||
import { bitcoin as BITCOIN_NETWORK } from '../networks'; |
|||
const typef = require('typeforce'); |
|||
const OPS = bscript.OPS; |
|||
const ecc = require('tiny-secp256k1'); |
|||
|
|||
const bech32 = require('bech32') |
|||
const bech32 = require('bech32'); |
|||
|
|||
const EMPTY_BUFFER = Buffer.alloc(0) |
|||
const EMPTY_BUFFER = Buffer.alloc(0); |
|||
|
|||
// witness: {signature} {pubKey}
|
|||
// input: <>
|
|||
// output: OP_0 {pubKeyHash}
|
|||
export function p2wpkh (a: Payment, opts?: PaymentOpts): Payment { |
|||
if ( |
|||
!a.address && |
|||
!a.hash && |
|||
!a.output && |
|||
!a.pubkey && |
|||
!a.witness |
|||
) throw new TypeError('Not enough data') |
|||
opts = Object.assign({ validate: true }, opts || {}) |
|||
|
|||
typef({ |
|||
address: typef.maybe(typef.String), |
|||
hash: typef.maybe(typef.BufferN(20)), |
|||
input: typef.maybe(typef.BufferN(0)), |
|||
network: typef.maybe(typef.Object), |
|||
output: typef.maybe(typef.BufferN(22)), |
|||
pubkey: typef.maybe(ecc.isPoint), |
|||
signature: typef.maybe(bscript.isCanonicalScriptSignature), |
|||
witness: typef.maybe(typef.arrayOf(typef.Buffer)) |
|||
}, a) |
|||
|
|||
const _address = lazy.value(function () { |
|||
const result = bech32.decode(a.address) |
|||
const version = result.words.shift() |
|||
const data = bech32.fromWords(result.words) |
|||
export function p2wpkh(a: Payment, opts?: PaymentOpts): Payment { |
|||
if (!a.address && !a.hash && !a.output && !a.pubkey && !a.witness) |
|||
throw new TypeError('Not enough data'); |
|||
opts = Object.assign({ validate: true }, opts || {}); |
|||
|
|||
typef( |
|||
{ |
|||
address: typef.maybe(typef.String), |
|||
hash: typef.maybe(typef.BufferN(20)), |
|||
input: typef.maybe(typef.BufferN(0)), |
|||
network: typef.maybe(typef.Object), |
|||
output: typef.maybe(typef.BufferN(22)), |
|||
pubkey: typef.maybe(ecc.isPoint), |
|||
signature: typef.maybe(bscript.isCanonicalScriptSignature), |
|||
witness: typef.maybe(typef.arrayOf(typef.Buffer)), |
|||
}, |
|||
a, |
|||
); |
|||
|
|||
const _address = lazy.value(function() { |
|||
const result = bech32.decode(a.address); |
|||
const version = result.words.shift(); |
|||
const data = bech32.fromWords(result.words); |
|||
return { |
|||
version, |
|||
prefix: result.prefix, |
|||
data: Buffer.from(data) |
|||
} |
|||
}) |
|||
|
|||
const network = a.network || BITCOIN_NETWORK |
|||
const o: Payment = { network } |
|||
|
|||
lazy.prop(o, 'address', function () { |
|||
if (!o.hash) return |
|||
|
|||
const words = bech32.toWords(o.hash) |
|||
words.unshift(0x00) |
|||
return bech32.encode(network.bech32, words) |
|||
}) |
|||
lazy.prop(o, 'hash', function () { |
|||
if (a.output) return a.output.slice(2, 22) |
|||
if (a.address) return _address().data |
|||
if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey! || o.pubkey!) |
|||
}) |
|||
lazy.prop(o, 'output', function () { |
|||
if (!o.hash) return |
|||
return bscript.compile([ |
|||
OPS.OP_0, |
|||
o.hash |
|||
]) |
|||
}) |
|||
lazy.prop(o, 'pubkey', function () { |
|||
if (a.pubkey) return a.pubkey |
|||
if (!a.witness) return |
|||
return a.witness[1] |
|||
}) |
|||
lazy.prop(o, 'signature', function () { |
|||
if (!a.witness) return |
|||
return a.witness[0] |
|||
}) |
|||
lazy.prop(o, 'input', function () { |
|||
if (!o.witness) return |
|||
return EMPTY_BUFFER |
|||
}) |
|||
lazy.prop(o, 'witness', function () { |
|||
if (!a.pubkey) return |
|||
if (!a.signature) return |
|||
return [a.signature, a.pubkey] |
|||
}) |
|||
data: Buffer.from(data), |
|||
}; |
|||
}); |
|||
|
|||
const network = a.network || BITCOIN_NETWORK; |
|||
const o: Payment = { network }; |
|||
|
|||
lazy.prop(o, 'address', function() { |
|||
if (!o.hash) return; |
|||
|
|||
const words = bech32.toWords(o.hash); |
|||
words.unshift(0x00); |
|||
return bech32.encode(network.bech32, words); |
|||
}); |
|||
lazy.prop(o, 'hash', function() { |
|||
if (a.output) return a.output.slice(2, 22); |
|||
if (a.address) return _address().data; |
|||
if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey! || o.pubkey!); |
|||
}); |
|||
lazy.prop(o, 'output', function() { |
|||
if (!o.hash) return; |
|||
return bscript.compile([OPS.OP_0, o.hash]); |
|||
}); |
|||
lazy.prop(o, 'pubkey', function() { |
|||
if (a.pubkey) return a.pubkey; |
|||
if (!a.witness) return; |
|||
return a.witness[1]; |
|||
}); |
|||
lazy.prop(o, 'signature', function() { |
|||
if (!a.witness) return; |
|||
return a.witness[0]; |
|||
}); |
|||
lazy.prop(o, 'input', function() { |
|||
if (!o.witness) return; |
|||
return EMPTY_BUFFER; |
|||
}); |
|||
lazy.prop(o, 'witness', function() { |
|||
if (!a.pubkey) return; |
|||
if (!a.signature) return; |
|||
return [a.signature, a.pubkey]; |
|||
}); |
|||
|
|||
// extended validation
|
|||
if (opts.validate) { |
|||
let hash: Buffer = Buffer.from([]) |
|||
let hash: Buffer = Buffer.from([]); |
|||
if (a.address) { |
|||
if (network && network.bech32 !== _address().prefix) throw new TypeError('Invalid prefix or Network mismatch') |
|||
if (_address().version !== 0x00) throw new TypeError('Invalid address version') |
|||
if (_address().data.length !== 20) throw new TypeError('Invalid address data') |
|||
hash = _address().data |
|||
if (network && network.bech32 !== _address().prefix) |
|||
throw new TypeError('Invalid prefix or Network mismatch'); |
|||
if (_address().version !== 0x00) |
|||
throw new TypeError('Invalid address version'); |
|||
if (_address().data.length !== 20) |
|||
throw new TypeError('Invalid address data'); |
|||
hash = _address().data; |
|||
} |
|||
|
|||
if (a.hash) { |
|||
if (hash.length > 0 && !hash.equals(a.hash)) throw new TypeError('Hash mismatch') |
|||
else hash = a.hash |
|||
if (hash.length > 0 && !hash.equals(a.hash)) |
|||
throw new TypeError('Hash mismatch'); |
|||
else hash = a.hash; |
|||
} |
|||
|
|||
if (a.output) { |
|||
if ( |
|||
a.output.length !== 22 || |
|||
a.output[0] !== OPS.OP_0 || |
|||
a.output[1] !== 0x14) throw new TypeError('Output is invalid') |
|||
if (hash.length > 0 && !hash.equals(a.output.slice(2))) throw new TypeError('Hash mismatch') |
|||
else hash = a.output.slice(2) |
|||
a.output[1] !== 0x14 |
|||
) |
|||
throw new TypeError('Output is invalid'); |
|||
if (hash.length > 0 && !hash.equals(a.output.slice(2))) |
|||
throw new TypeError('Hash mismatch'); |
|||
else hash = a.output.slice(2); |
|||
} |
|||
|
|||
if (a.pubkey) { |
|||
const pkh = bcrypto.hash160(a.pubkey) |
|||
if (hash.length > 0 && !hash.equals(pkh)) throw new TypeError('Hash mismatch') |
|||
else hash = pkh |
|||
const pkh = bcrypto.hash160(a.pubkey); |
|||
if (hash.length > 0 && !hash.equals(pkh)) |
|||
throw new TypeError('Hash mismatch'); |
|||
else hash = pkh; |
|||
} |
|||
|
|||
if (a.witness) { |
|||
if (a.witness.length !== 2) throw new TypeError('Witness is invalid') |
|||
if (!bscript.isCanonicalScriptSignature(a.witness[0])) throw new TypeError('Witness has invalid signature') |
|||
if (!ecc.isPoint(a.witness[1])) throw new TypeError('Witness has invalid pubkey') |
|||
|
|||
if (a.signature && !a.signature.equals(a.witness[0])) throw new TypeError('Signature mismatch') |
|||
if (a.pubkey && !a.pubkey.equals(a.witness[1])) throw new TypeError('Pubkey mismatch') |
|||
|
|||
const pkh = bcrypto.hash160(a.witness[1]) |
|||
if (hash.length > 0 && !hash.equals(pkh)) throw new TypeError('Hash mismatch') |
|||
if (a.witness.length !== 2) throw new TypeError('Witness is invalid'); |
|||
if (!bscript.isCanonicalScriptSignature(a.witness[0])) |
|||
throw new TypeError('Witness has invalid signature'); |
|||
if (!ecc.isPoint(a.witness[1])) |
|||
throw new TypeError('Witness has invalid pubkey'); |
|||
|
|||
if (a.signature && !a.signature.equals(a.witness[0])) |
|||
throw new TypeError('Signature mismatch'); |
|||
if (a.pubkey && !a.pubkey.equals(a.witness[1])) |
|||
throw new TypeError('Pubkey mismatch'); |
|||
|
|||
const pkh = bcrypto.hash160(a.witness[1]); |
|||
if (hash.length > 0 && !hash.equals(pkh)) |
|||
throw new TypeError('Hash mismatch'); |
|||
} |
|||
} |
|||
|
|||
return Object.assign(o, a) |
|||
return Object.assign(o, a); |
|||
} |
|||
|
|||
@ -1,206 +1,218 @@ |
|||
import * as types from './types' |
|||
import * as scriptNumber from './script_number' |
|||
import * as scriptSignature from './script_signature' |
|||
const bip66 = require('bip66') |
|||
const ecc = require('tiny-secp256k1') |
|||
const pushdata = require('pushdata-bitcoin') |
|||
const typeforce = require('typeforce') |
|||
|
|||
export type OpCode = number |
|||
export const OPS = <{[index:string]: OpCode}> require('bitcoin-ops') |
|||
|
|||
const REVERSE_OPS = <{[index:number]: string}> require('bitcoin-ops/map') |
|||
const OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1
|
|||
|
|||
function isOPInt (value:number): boolean { |
|||
return types.Number(value) && |
|||
((value === OPS.OP_0) || |
|||
(value >= OPS.OP_1 && value <= OPS.OP_16) || |
|||
(value === OPS.OP_1NEGATE)) |
|||
import * as types from './types'; |
|||
import * as scriptNumber from './script_number'; |
|||
import * as scriptSignature from './script_signature'; |
|||
const bip66 = require('bip66'); |
|||
const ecc = require('tiny-secp256k1'); |
|||
const pushdata = require('pushdata-bitcoin'); |
|||
const typeforce = require('typeforce'); |
|||
|
|||
export type OpCode = number; |
|||
export const OPS = <{ [index: string]: OpCode }>require('bitcoin-ops'); |
|||
|
|||
const REVERSE_OPS = <{ [index: number]: string }>require('bitcoin-ops/map'); |
|||
const OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1
|
|||
|
|||
function isOPInt(value: number): boolean { |
|||
return ( |
|||
types.Number(value) && |
|||
(value === OPS.OP_0 || |
|||
(value >= OPS.OP_1 && value <= OPS.OP_16) || |
|||
value === OPS.OP_1NEGATE) |
|||
); |
|||
} |
|||
|
|||
function isPushOnlyChunk (value: number | Buffer): boolean { |
|||
return types.Buffer(value) || isOPInt(<number>value) |
|||
function isPushOnlyChunk(value: number | Buffer): boolean { |
|||
return types.Buffer(value) || isOPInt(<number>value); |
|||
} |
|||
|
|||
export function isPushOnly (value: Array<number | Buffer>) { |
|||
return types.Array(value) && value.every(isPushOnlyChunk) |
|||
export function isPushOnly(value: Array<number | Buffer>) { |
|||
return types.Array(value) && value.every(isPushOnlyChunk); |
|||
} |
|||
|
|||
function asMinimalOP (buffer: Buffer): number | void { |
|||
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 |
|||
function asMinimalOP(buffer: Buffer): number | void { |
|||
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; |
|||
} |
|||
|
|||
function chunksIsBuffer(buf: Buffer | Array<number | Buffer>): buf is Buffer { |
|||
return Buffer.isBuffer(buf) |
|||
return Buffer.isBuffer(buf); |
|||
} |
|||
|
|||
function chunksIsArray(buf: Buffer | Array<number | Buffer>): buf is Array<number | Buffer> { |
|||
return types.Array(buf) |
|||
function chunksIsArray( |
|||
buf: Buffer | Array<number | Buffer>, |
|||
): buf is Array<number | Buffer> { |
|||
return types.Array(buf); |
|||
} |
|||
|
|||
function singleChunkIsBuffer(buf: number | Buffer): buf is Buffer { |
|||
return Buffer.isBuffer(buf) |
|||
return Buffer.isBuffer(buf); |
|||
} |
|||
|
|||
export function compile (chunks: Buffer | Array<number | Buffer>): Buffer { |
|||
export function compile(chunks: Buffer | Array<number | Buffer>): Buffer { |
|||
// TODO: remove me
|
|||
if (chunksIsBuffer(chunks)) return chunks |
|||
if (chunksIsBuffer(chunks)) return chunks; |
|||
|
|||
typeforce(types.Array, chunks) |
|||
typeforce(types.Array, chunks); |
|||
|
|||
const bufferSize = chunks.reduce(function (accum: number, chunk) { |
|||
const bufferSize = chunks.reduce(function(accum: number, chunk) { |
|||
// data chunk
|
|||
if (singleChunkIsBuffer(chunk)) { |
|||
// adhere to BIP62.3, minimal push policy
|
|||
if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) { |
|||
return accum + 1 |
|||
return accum + 1; |
|||
} |
|||
|
|||
return accum + pushdata.encodingLength(chunk.length) + chunk.length |
|||
return accum + pushdata.encodingLength(chunk.length) + chunk.length; |
|||
} |
|||
|
|||
// opcode
|
|||
return accum + 1 |
|||
}, 0.0) |
|||
return accum + 1; |
|||
}, 0.0); |
|||
|
|||
const buffer = Buffer.allocUnsafe(bufferSize) |
|||
let offset = 0 |
|||
const buffer = Buffer.allocUnsafe(bufferSize); |
|||
let offset = 0; |
|||
|
|||
chunks.forEach(function (chunk) { |
|||
chunks.forEach(function(chunk) { |
|||
// data chunk
|
|||
if (singleChunkIsBuffer(chunk)) { |
|||
// adhere to BIP62.3, minimal push policy
|
|||
const opcode = asMinimalOP(chunk) |
|||
const opcode = asMinimalOP(chunk); |
|||
if (opcode !== undefined) { |
|||
buffer.writeUInt8(opcode, offset) |
|||
offset += 1 |
|||
return |
|||
buffer.writeUInt8(opcode, offset); |
|||
offset += 1; |
|||
return; |
|||
} |
|||
|
|||
offset += pushdata.encode(buffer, chunk.length, offset) |
|||
chunk.copy(buffer, offset) |
|||
offset += chunk.length |
|||
offset += pushdata.encode(buffer, chunk.length, offset); |
|||
chunk.copy(buffer, offset); |
|||
offset += chunk.length; |
|||
|
|||
// opcode
|
|||
// opcode
|
|||
} else { |
|||
buffer.writeUInt8(chunk, offset) |
|||
offset += 1 |
|||
buffer.writeUInt8(chunk, offset); |
|||
offset += 1; |
|||
} |
|||
}) |
|||
}); |
|||
|
|||
if (offset !== buffer.length) throw new Error('Could not decode chunks') |
|||
return buffer |
|||
if (offset !== buffer.length) throw new Error('Could not decode chunks'); |
|||
return buffer; |
|||
} |
|||
|
|||
export function decompile (buffer: Buffer | Array<number | Buffer>): Array<number | Buffer> | null { |
|||
export function decompile( |
|||
buffer: Buffer | Array<number | Buffer>, |
|||
): Array<number | Buffer> | null { |
|||
// TODO: remove me
|
|||
if (chunksIsArray(buffer)) return buffer |
|||
if (chunksIsArray(buffer)) return buffer; |
|||
|
|||
typeforce(types.Buffer, buffer) |
|||
typeforce(types.Buffer, buffer); |
|||
|
|||
const chunks: Array<number | Buffer> = [] |
|||
let i = 0 |
|||
const chunks: Array<number | Buffer> = []; |
|||
let i = 0; |
|||
|
|||
while (i < buffer.length) { |
|||
const opcode = buffer[i] |
|||
const opcode = buffer[i]; |
|||
|
|||
// data chunk
|
|||
if ((opcode > OPS.OP_0) && (opcode <= OPS.OP_PUSHDATA4)) { |
|||
const d = pushdata.decode(buffer, i) |
|||
if (opcode > OPS.OP_0 && opcode <= OPS.OP_PUSHDATA4) { |
|||
const d = pushdata.decode(buffer, i); |
|||
|
|||
// did reading a pushDataInt fail?
|
|||
if (d === null) return null |
|||
i += d.size |
|||
if (d === null) return null; |
|||
i += d.size; |
|||
|
|||
// attempt to read too much data?
|
|||
if (i + d.number > buffer.length) return null |
|||
if (i + d.number > buffer.length) return null; |
|||
|
|||
const data = buffer.slice(i, i + d.number) |
|||
i += d.number |
|||
const data = buffer.slice(i, i + d.number); |
|||
i += d.number; |
|||
|
|||
// decompile minimally
|
|||
const op = asMinimalOP(data) |
|||
const op = asMinimalOP(data); |
|||
if (op !== undefined) { |
|||
chunks.push(op) |
|||
chunks.push(op); |
|||
} else { |
|||
chunks.push(data) |
|||
chunks.push(data); |
|||
} |
|||
|
|||
// opcode
|
|||
// opcode
|
|||
} else { |
|||
chunks.push(opcode) |
|||
chunks.push(opcode); |
|||
|
|||
i += 1 |
|||
i += 1; |
|||
} |
|||
} |
|||
|
|||
return chunks |
|||
return chunks; |
|||
} |
|||
|
|||
export function toASM (chunks: Buffer | Array<number | Buffer>): string { |
|||
export function toASM(chunks: Buffer | Array<number | Buffer>): string { |
|||
if (chunksIsBuffer(chunks)) { |
|||
chunks = <Array<number | Buffer>>decompile(chunks) |
|||
chunks = <Array<number | Buffer>>decompile(chunks); |
|||
} |
|||
|
|||
return chunks.map(function (chunk) { |
|||
// data?
|
|||
if (singleChunkIsBuffer(chunk)) { |
|||
const op = asMinimalOP(chunk) |
|||
if (op === undefined) return chunk.toString('hex') |
|||
chunk = <number>op |
|||
} |
|||
return chunks |
|||
.map(function(chunk) { |
|||
// data?
|
|||
if (singleChunkIsBuffer(chunk)) { |
|||
const op = asMinimalOP(chunk); |
|||
if (op === undefined) return chunk.toString('hex'); |
|||
chunk = <number>op; |
|||
} |
|||
|
|||
// opcode!
|
|||
return REVERSE_OPS[chunk] |
|||
}).join(' ') |
|||
// opcode!
|
|||
return REVERSE_OPS[chunk]; |
|||
}) |
|||
.join(' '); |
|||
} |
|||
|
|||
export function fromASM (asm: string): Buffer { |
|||
typeforce(types.String, asm) |
|||
export function fromASM(asm: string): Buffer { |
|||
typeforce(types.String, asm); |
|||
|
|||
return compile(asm.split(' ').map(function (chunkStr) { |
|||
// opcode?
|
|||
if (OPS[chunkStr] !== undefined) return OPS[chunkStr] |
|||
typeforce(types.Hex, chunkStr) |
|||
return compile( |
|||
asm.split(' ').map(function(chunkStr) { |
|||
// opcode?
|
|||
if (OPS[chunkStr] !== undefined) return OPS[chunkStr]; |
|||
typeforce(types.Hex, chunkStr); |
|||
|
|||
// data!
|
|||
return Buffer.from(chunkStr, 'hex') |
|||
})) |
|||
// data!
|
|||
return Buffer.from(chunkStr, 'hex'); |
|||
}), |
|||
); |
|||
} |
|||
|
|||
export function toStack (chunks: Buffer | Array<number | Buffer>): Array<Buffer> { |
|||
chunks = <Array<number | Buffer>>decompile(chunks) |
|||
typeforce(isPushOnly, chunks) |
|||
export function toStack( |
|||
chunks: Buffer | Array<number | Buffer>, |
|||
): Array<Buffer> { |
|||
chunks = <Array<number | Buffer>>decompile(chunks); |
|||
typeforce(isPushOnly, chunks); |
|||
|
|||
return chunks.map(function (op) { |
|||
if (singleChunkIsBuffer(op)) return op |
|||
if (op === OPS.OP_0) return Buffer.allocUnsafe(0) |
|||
return chunks.map(function(op) { |
|||
if (singleChunkIsBuffer(op)) return op; |
|||
if (op === OPS.OP_0) return Buffer.allocUnsafe(0); |
|||
|
|||
return scriptNumber.encode(op - OP_INT_BASE) |
|||
}) |
|||
return scriptNumber.encode(op - OP_INT_BASE); |
|||
}); |
|||
} |
|||
|
|||
export function isCanonicalPubKey (buffer: Buffer): boolean { |
|||
return ecc.isPoint(buffer) |
|||
export function isCanonicalPubKey(buffer: Buffer): boolean { |
|||
return ecc.isPoint(buffer); |
|||
} |
|||
|
|||
export function isDefinedHashType (hashType: number): boolean { |
|||
const hashTypeMod = hashType & ~0x80 |
|||
export function isDefinedHashType(hashType: number): boolean { |
|||
const hashTypeMod = hashType & ~0x80; |
|||
|
|||
// return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE
|
|||
return hashTypeMod > 0x00 && hashTypeMod < 0x04 |
|||
return hashTypeMod > 0x00 && hashTypeMod < 0x04; |
|||
} |
|||
|
|||
export function isCanonicalScriptSignature (buffer: Buffer): boolean { |
|||
if (!Buffer.isBuffer(buffer)) return false |
|||
if (!isDefinedHashType(buffer[buffer.length - 1])) return false |
|||
export function isCanonicalScriptSignature(buffer: Buffer): boolean { |
|||
if (!Buffer.isBuffer(buffer)) return false; |
|||
if (!isDefinedHashType(buffer[buffer.length - 1])) return false; |
|||
|
|||
return bip66.check(buffer.slice(0, -1)) |
|||
return bip66.check(buffer.slice(0, -1)); |
|||
} |
|||
|
|||
export const number = scriptNumber |
|||
export const signature = scriptSignature |
|||
export const number = scriptNumber; |
|||
export const signature = scriptSignature; |
|||
|
|||
@ -1,62 +1,71 @@ |
|||
export function decode( |
|||
buffer: Buffer, |
|||
maxLength?: number, |
|||
minimal?: boolean, |
|||
): number { |
|||
maxLength = maxLength || 4; |
|||
minimal = minimal === undefined ? true : minimal; |
|||
|
|||
|
|||
export function decode (buffer: Buffer, maxLength?: number, minimal?: boolean): number { |
|||
maxLength = maxLength || 4 |
|||
minimal = minimal === undefined ? true : minimal |
|||
|
|||
const length = buffer.length |
|||
if (length === 0) return 0 |
|||
if (length > maxLength) throw new TypeError('Script number overflow') |
|||
const length = buffer.length; |
|||
if (length === 0) return 0; |
|||
if (length > maxLength) throw new TypeError('Script number overflow'); |
|||
if (minimal) { |
|||
if ((buffer[length - 1] & 0x7f) === 0) { |
|||
if (length <= 1 || (buffer[length - 2] & 0x80) === 0) throw new Error('Non-minimally encoded script number') |
|||
if (length <= 1 || (buffer[length - 2] & 0x80) === 0) |
|||
throw new Error('Non-minimally encoded script number'); |
|||
} |
|||
} |
|||
|
|||
// 40-bit
|
|||
if (length === 5) { |
|||
const a = buffer.readUInt32LE(0) |
|||
const b = buffer.readUInt8(4) |
|||
const a = buffer.readUInt32LE(0); |
|||
const b = buffer.readUInt8(4); |
|||
|
|||
if (b & 0x80) return -(((b & ~0x80) * 0x100000000) + a) |
|||
return (b * 0x100000000) + a |
|||
if (b & 0x80) return -((b & ~0x80) * 0x100000000 + a); |
|||
return b * 0x100000000 + a; |
|||
} |
|||
|
|||
// 32-bit / 24-bit / 16-bit / 8-bit
|
|||
let result = 0 |
|||
let result = 0; |
|||
for (var i = 0; i < length; ++i) { |
|||
result |= buffer[i] << (8 * i) |
|||
result |= buffer[i] << (8 * i); |
|||
} |
|||
|
|||
if (buffer[length - 1] & 0x80) return -(result & ~(0x80 << (8 * (length - 1)))) |
|||
return result |
|||
if (buffer[length - 1] & 0x80) |
|||
return -(result & ~(0x80 << (8 * (length - 1)))); |
|||
return result; |
|||
} |
|||
|
|||
function scriptNumSize (i: number): number { |
|||
return i > 0x7fffffff ? 5 |
|||
: i > 0x7fffff ? 4 |
|||
: i > 0x7fff ? 3 |
|||
: i > 0x7f ? 2 |
|||
: i > 0x00 ? 1 |
|||
: 0 |
|||
function scriptNumSize(i: number): number { |
|||
return i > 0x7fffffff |
|||
? 5 |
|||
: i > 0x7fffff |
|||
? 4 |
|||
: i > 0x7fff |
|||
? 3 |
|||
: i > 0x7f |
|||
? 2 |
|||
: i > 0x00 |
|||
? 1 |
|||
: 0; |
|||
} |
|||
|
|||
export function encode (number: number): Buffer { |
|||
let value = Math.abs(number) |
|||
const size = scriptNumSize(value) |
|||
const buffer = Buffer.allocUnsafe(size) |
|||
const negative = number < 0 |
|||
export function encode(number: number): Buffer { |
|||
let value = Math.abs(number); |
|||
const size = scriptNumSize(value); |
|||
const buffer = Buffer.allocUnsafe(size); |
|||
const negative = number < 0; |
|||
|
|||
for (var i = 0; i < size; ++i) { |
|||
buffer.writeUInt8(value & 0xff, i) |
|||
value >>= 8 |
|||
buffer.writeUInt8(value & 0xff, i); |
|||
value >>= 8; |
|||
} |
|||
|
|||
if (buffer[size - 1] & 0x80) { |
|||
buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1) |
|||
buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1); |
|||
} else if (negative) { |
|||
buffer[size - 1] |= 0x80 |
|||
buffer[size - 1] |= 0x80; |
|||
} |
|||
|
|||
return buffer |
|||
return buffer; |
|||
} |
|||
|
|||
@ -1,64 +1,66 @@ |
|||
import * as types from './types' |
|||
const bip66 = require('bip66') |
|||
import * as types from './types'; |
|||
const bip66 = require('bip66'); |
|||
|
|||
const typeforce = require('typeforce') |
|||
const typeforce = require('typeforce'); |
|||
|
|||
const ZERO = Buffer.alloc(1, 0) |
|||
function toDER (x: Buffer): Buffer { |
|||
let i = 0 |
|||
while (x[i] === 0) ++i |
|||
if (i === x.length) return ZERO |
|||
x = x.slice(i) |
|||
if (x[0] & 0x80) return Buffer.concat([ZERO, x], 1 + x.length) |
|||
return x |
|||
const ZERO = Buffer.alloc(1, 0); |
|||
function toDER(x: Buffer): Buffer { |
|||
let i = 0; |
|||
while (x[i] === 0) ++i; |
|||
if (i === x.length) return ZERO; |
|||
x = x.slice(i); |
|||
if (x[0] & 0x80) return Buffer.concat([ZERO, x], 1 + x.length); |
|||
return x; |
|||
} |
|||
|
|||
function fromDER (x: Buffer): Buffer { |
|||
if (x[0] === 0x00) x = x.slice(1) |
|||
const buffer = Buffer.alloc(32, 0) |
|||
const bstart = Math.max(0, 32 - x.length) |
|||
x.copy(buffer, bstart) |
|||
return buffer |
|||
function fromDER(x: Buffer): Buffer { |
|||
if (x[0] === 0x00) x = x.slice(1); |
|||
const buffer = Buffer.alloc(32, 0); |
|||
const bstart = Math.max(0, 32 - x.length); |
|||
x.copy(buffer, bstart); |
|||
return buffer; |
|||
} |
|||
|
|||
interface ScriptSignature { |
|||
signature: Buffer |
|||
hashType: number |
|||
signature: Buffer; |
|||
hashType: number; |
|||
} |
|||
|
|||
// BIP62: 1 byte hashType flag (only 0x01, 0x02, 0x03, 0x81, 0x82 and 0x83 are allowed)
|
|||
export function decode (buffer: Buffer): ScriptSignature { |
|||
const hashType = buffer.readUInt8(buffer.length - 1) |
|||
const hashTypeMod = hashType & ~0x80 |
|||
if (hashTypeMod <= 0 || hashTypeMod >= 4) throw new Error('Invalid hashType ' + hashType) |
|||
export function decode(buffer: Buffer): ScriptSignature { |
|||
const hashType = buffer.readUInt8(buffer.length - 1); |
|||
const hashTypeMod = hashType & ~0x80; |
|||
if (hashTypeMod <= 0 || hashTypeMod >= 4) |
|||
throw new Error('Invalid hashType ' + hashType); |
|||
|
|||
const decode = bip66.decode(buffer.slice(0, -1)) |
|||
const r = fromDER(decode.r) |
|||
const s = fromDER(decode.s) |
|||
const decode = bip66.decode(buffer.slice(0, -1)); |
|||
const r = fromDER(decode.r); |
|||
const s = fromDER(decode.s); |
|||
|
|||
return { |
|||
signature: Buffer.concat([r, s], 64), |
|||
hashType: hashType |
|||
} |
|||
hashType: hashType, |
|||
}; |
|||
} |
|||
|
|||
export function encode (signature: Buffer, hashType: number): Buffer { |
|||
typeforce({ |
|||
signature: types.BufferN(64), |
|||
hashType: types.UInt8 |
|||
}, { signature, hashType }) |
|||
export function encode(signature: Buffer, hashType: number): Buffer { |
|||
typeforce( |
|||
{ |
|||
signature: types.BufferN(64), |
|||
hashType: types.UInt8, |
|||
}, |
|||
{ signature, hashType }, |
|||
); |
|||
|
|||
const hashTypeMod = hashType & ~0x80 |
|||
if (hashTypeMod <= 0 || hashTypeMod >= 4) throw new Error('Invalid hashType ' + hashType) |
|||
const hashTypeMod = hashType & ~0x80; |
|||
if (hashTypeMod <= 0 || hashTypeMod >= 4) |
|||
throw new Error('Invalid hashType ' + hashType); |
|||
|
|||
const hashTypeBuffer = Buffer.allocUnsafe(1) |
|||
hashTypeBuffer.writeUInt8(hashType, 0) |
|||
const hashTypeBuffer = Buffer.allocUnsafe(1); |
|||
hashTypeBuffer.writeUInt8(hashType, 0); |
|||
|
|||
const r = toDER(signature.slice(0, 32)) |
|||
const s = toDER(signature.slice(32, 64)) |
|||
const r = toDER(signature.slice(0, 32)); |
|||
const s = toDER(signature.slice(32, 64)); |
|||
|
|||
return Buffer.concat([ |
|||
bip66.encode(r, s), |
|||
hashTypeBuffer |
|||
]) |
|||
return Buffer.concat([bip66.encode(r, s), hashTypeBuffer]); |
|||
} |
|||
|
|||
@ -1,17 +1,16 @@ |
|||
// OP_RETURN {data}
|
|||
import * as bscript from '../script' |
|||
const OPS = bscript.OPS |
|||
import * as bscript from '../script'; |
|||
const OPS = bscript.OPS; |
|||
|
|||
export function check (script: Buffer | Array<number | Buffer>): boolean { |
|||
const buffer = bscript.compile(script) |
|||
export function check(script: Buffer | Array<number | Buffer>): boolean { |
|||
const buffer = bscript.compile(script); |
|||
|
|||
return buffer.length > 1 && |
|||
buffer[0] === OPS.OP_RETURN |
|||
return buffer.length > 1 && buffer[0] === OPS.OP_RETURN; |
|||
} |
|||
check.toJSON = function () { return 'null data output' } |
|||
check.toJSON = function() { |
|||
return 'null data output'; |
|||
}; |
|||
|
|||
const output = { check } |
|||
const output = { check }; |
|||
|
|||
export { |
|||
output |
|||
} |
|||
export { output }; |
|||
|
|||
File diff suppressed because it is too large
@ -1,49 +1,51 @@ |
|||
const typeforce = require('typeforce') |
|||
const typeforce = require('typeforce'); |
|||
|
|||
const UINT31_MAX: number = Math.pow(2, 31) - 1 |
|||
export function UInt31 (value: number): boolean { |
|||
return typeforce.UInt32(value) && value <= UINT31_MAX |
|||
const UINT31_MAX: number = Math.pow(2, 31) - 1; |
|||
export function UInt31(value: number): boolean { |
|||
return typeforce.UInt32(value) && value <= UINT31_MAX; |
|||
} |
|||
|
|||
export function BIP32Path (value: string): boolean { |
|||
return typeforce.String(value) && !!value.match(/^(m\/)?(\d+'?\/)*\d+'?$/) |
|||
export function BIP32Path(value: string): boolean { |
|||
return typeforce.String(value) && !!value.match(/^(m\/)?(\d+'?\/)*\d+'?$/); |
|||
} |
|||
BIP32Path.toJSON = function () { return 'BIP32 derivation path' } |
|||
BIP32Path.toJSON = function() { |
|||
return 'BIP32 derivation path'; |
|||
}; |
|||
|
|||
const SATOSHI_MAX: number = 21 * 1e14 |
|||
export function Satoshi (value: number): boolean { |
|||
return typeforce.UInt53(value) && value <= SATOSHI_MAX |
|||
const SATOSHI_MAX: number = 21 * 1e14; |
|||
export function Satoshi(value: number): boolean { |
|||
return typeforce.UInt53(value) && value <= SATOSHI_MAX; |
|||
} |
|||
|
|||
// external dependent types
|
|||
export const ECPoint = typeforce.quacksLike('Point') |
|||
export const ECPoint = typeforce.quacksLike('Point'); |
|||
|
|||
// exposed, external API
|
|||
export const Network = typeforce.compile({ |
|||
messagePrefix: typeforce.oneOf(typeforce.Buffer, typeforce.String), |
|||
bip32: { |
|||
public: typeforce.UInt32, |
|||
private: typeforce.UInt32 |
|||
private: typeforce.UInt32, |
|||
}, |
|||
pubKeyHash: typeforce.UInt8, |
|||
scriptHash: typeforce.UInt8, |
|||
wif: typeforce.UInt8 |
|||
}) |
|||
wif: typeforce.UInt8, |
|||
}); |
|||
|
|||
export const Buffer256bit = typeforce.BufferN(32) |
|||
export const Hash160bit = typeforce.BufferN(20) |
|||
export const Hash256bit = typeforce.BufferN(32) |
|||
export const Number = typeforce.Number |
|||
export const Array = typeforce.Array |
|||
export const Boolean = typeforce.Boolean |
|||
export const String = typeforce.String |
|||
export const Buffer = typeforce.Buffer |
|||
export const Hex = typeforce.Hex |
|||
export const maybe = typeforce.maybe |
|||
export const tuple = typeforce.tuple |
|||
export const UInt8 = typeforce.UInt8 |
|||
export const UInt32 = typeforce.UInt32 |
|||
export const Function = typeforce.Function |
|||
export const BufferN = typeforce.BufferN |
|||
export const Null = typeforce.Null |
|||
export const oneOf = typeforce.oneOf |
|||
export const Buffer256bit = typeforce.BufferN(32); |
|||
export const Hash160bit = typeforce.BufferN(20); |
|||
export const Hash256bit = typeforce.BufferN(32); |
|||
export const Number = typeforce.Number; |
|||
export const Array = typeforce.Array; |
|||
export const Boolean = typeforce.Boolean; |
|||
export const String = typeforce.String; |
|||
export const Buffer = typeforce.Buffer; |
|||
export const Hex = typeforce.Hex; |
|||
export const maybe = typeforce.maybe; |
|||
export const tuple = typeforce.tuple; |
|||
export const UInt8 = typeforce.UInt8; |
|||
export const UInt32 = typeforce.UInt32; |
|||
export const Function = typeforce.Function; |
|||
export const BufferN = typeforce.BufferN; |
|||
export const Null = typeforce.Null; |
|||
export const oneOf = typeforce.oneOf; |
|||
|
|||
Loading…
Reference in new issue