From 7a9ad39417b1d1ff9d895dec1645b2fcd4deefe1 Mon Sep 17 00:00:00 2001 From: Gabriel Cardona Date: Tue, 14 May 2019 18:41:44 +0900 Subject: [PATCH] Updtes to the Script class and tests. --- index.ts | 2 +- lib/Script.ts | 259 +++++++++++++++++++++++++++----- lib/TransactionBuilder.ts | 5 +- package.json | 4 +- test/unit/Address.ts | 8 +- test/unit/Script.ts | 179 +++++++++------------- test/unit/TransactionBuilder.ts | 256 +++++++++++++++---------------- 7 files changed, 431 insertions(+), 282 deletions(-) diff --git a/index.ts b/index.ts index a1112911..64f9482c 100644 --- a/index.ts +++ b/index.ts @@ -47,7 +47,7 @@ interface NewOptions extends ConsoleOptions { restURL: string } -program.version("7.2.1 ", "-v, --version") +program.version("7.3.0 ", "-v, --version") program .command("new ") diff --git a/lib/Script.ts b/lib/Script.ts index 1fb188e5..6aba722a 100644 --- a/lib/Script.ts +++ b/lib/Script.ts @@ -38,7 +38,6 @@ export interface opcodes { OP_ENDIF: 104 OP_VERIFY: 105 OP_RETURN: 106 - OP_TOALTSTACK: 107 OP_FROMALTSTACK: 108 OP_2DROP: 109 @@ -58,23 +57,19 @@ export interface opcodes { OP_ROT: 123 OP_SWAP: 124 OP_TUCK: 125 - OP_CAT: 126 - OP_SPLIT: 127 OP_NUM2BIN: 128 OP_BIN2NUM: 129 OP_SIZE: 130 - OP_INVERT: 131 - OP_AND: 132 // May 2018 reenabled - OP_OR: 133 // May 2018 reenabled - OP_XOR: 134 // May 2018 reenabled + OP_AND: 132 + OP_OR: 133 + OP_XOR: 134 OP_EQUAL: 135 OP_EQUALVERIFY: 136 OP_RESERVED1: 137 OP_RESERVED2: 138 - OP_1ADD: 139 OP_1SUB: 140 OP_2MUL: 141 @@ -86,11 +81,10 @@ export interface opcodes { OP_ADD: 147 OP_SUB: 148 OP_MUL: 149 - OP_DIV: 150 // May 2018 reenabled - OP_MOD: 151 // May 2018 reenabled + OP_DIV: 150 + OP_MOD: 151 OP_LSHIFT: 152 OP_RSHIFT: 153 - OP_BOOLAND: 154 OP_BOOLOR: 155 OP_NUMEQUAL: 156 @@ -102,9 +96,7 @@ export interface opcodes { OP_GREATERTHANOREQUAL: 162 OP_MIN: 163 OP_MAX: 164 - OP_WITHIN: 165 - OP_RIPEMD160: 166 OP_SHA1: 167 OP_SHA256: 168 @@ -115,15 +107,11 @@ export interface opcodes { OP_CHECKSIGVERIFY: 173 OP_CHECKMULTISIG: 174 OP_CHECKMULTISIGVERIFY: 175 - OP_NOP1: 176 - OP_NOP2: 177 OP_CHECKLOCKTIMEVERIFY: 177 - OP_NOP3: 178 OP_CHECKSEQUENCEVERIFY: 178 - OP_NOP4: 179 OP_NOP5: 180 OP_NOP6: 181 @@ -133,26 +121,113 @@ export interface opcodes { OP_NOP10: 185 OP_CHECKDATASIG: 186 OP_CHECKDATASIGVERIFY: 187 - OP_PUBKEYHASH: 253 OP_PUBKEY: 254 OP_INVALIDOPCODE: 255 } +export interface DecodedP2PKHInput { + signature: Buffer + pubKey: Buffer +} + +export interface DecodedP2MSOutput { + m: number + pubKeys: Buffer[] +} + +export interface DecodedP2SHInput { + redeemScript: Buffer + redeemScriptSig: Buffer +} + +export interface nullData { + output: { + encode(data: Buffer): Buffer + decode(output: Buffer): Buffer + check(output: Buffer): boolean + } +} + +export interface pubKey { + input: + { + encode(signature: Buffer): Buffer + decode(input: Buffer): Buffer + check(input: Buffer): boolean + decodeStack(data: Buffer): Buffer + encodeStack(data: Buffer): Buffer + }, + output: { + encode(pubKey: Buffer): Buffer + decode(output: Buffer): Buffer + check(output: Buffer): boolean + } +} + +export interface pubKeyHash { + input: + { + encode(signature: Buffer, pubKey: Buffer): Buffer + decode(data: Buffer): DecodedP2PKHInput + check(data: Buffer): boolean + decodeStack(data: Buffer): Buffer + encodeStack(data: Buffer): Buffer + }, + output: + { + encode(identifier: Buffer): Buffer + decode(output: Buffer): Buffer + check(output: Buffer): boolean + } +} + +export interface multisig { + input: + { + encode(signatures: Buffer[]): Buffer + decode(input: Buffer): Buffer[] + check(input: Buffer): boolean + }, + output: + { + encode(m: number, pubKeys: Buffer[]): Buffer + decode(output: Buffer): DecodedP2MSOutput + check(output: Buffer): boolean + } +} + +export interface scriptHash { + input: + { + encode(redeemScriptSig: Buffer, redeemScript: Buffer): Buffer + decode(input: Buffer): DecodedP2SHInput + check(data: Buffer): boolean + decodeStack(data: Buffer): Buffer + encodeStack(data: Buffer): Buffer + }, + output: + { + encode(scriptHash: Buffer): Buffer + decode(output: Buffer): Buffer + check(output: Buffer): boolean + } +} + export class Script { - opcodes: opcodes - nullData: any - multisig: any - pubKey: any - pubKeyHash: any - scriptHash: any + public opcodes: opcodes + public nullData: nullData + public pubKey: pubKey + public pubKeyHash: pubKeyHash + public multisig: multisig + public scriptHash: scriptHash constructor() { this.opcodes = opcodes this.nullData = Bitcoin.script.nullData this.multisig = { input: { - encode: (signatures: any) => { + encode: (signatures: Buffer[]): Buffer => { const sigs: any[] = [] signatures.forEach((sig: any) => { sigs.push(sig) @@ -163,7 +238,7 @@ export class Script { check: Bitcoin.script.multisig.input.check }, output: { - encode: (m: any, pubKeys: any) => { + encode: (m: number, pubKeys: Buffer[]): Buffer => { const pks: any[] = [] pubKeys.forEach((pubKey: any) => { pks.push(pubKey) @@ -179,6 +254,26 @@ export class Script { this.scriptHash = Bitcoin.script.scriptHash } + public encode(scriptChunks: Array): Buffer { + const arr: Array = [] + scriptChunks.forEach((chunk: number | Buffer) => { + arr.push(chunk) + }) + return Bitcoin.script.compile(arr) + } + + public decode(scriptBuffer: Buffer): Array { + return Bitcoin.script.decompile(scriptBuffer) + } + + public toASM(buffer: Buffer): string { + return Bitcoin.script.toASM(buffer) + } + + public fromASM(asm: string): Buffer { + return Bitcoin.script.fromASM(asm) + } + public classifyInput(script: Buffer): string { return Bitcoin.script.classifyInput(script) } @@ -187,23 +282,111 @@ export class Script { return Bitcoin.script.classifyOutput(script) } - public decode(scriptBuffer: any): any[] { - return Bitcoin.script.decompile(scriptBuffer) + public encodeNullDataOutput(data: Buffer): Buffer { + return this.nullData.output.encode(data) } - public encode(scriptChunks: any): any { - const arr: any[] = [] - scriptChunks.forEach((chunk: any) => { - arr.push(chunk) - }) - return Bitcoin.script.compile(arr) + public decodeNullDataOutput(output: Buffer): Buffer { + return this.nullData.output.decode(output) } - public toASM(buffer: Buffer): string { - return Bitcoin.script.toASM(buffer) + public checkNullDataOutput(output: Buffer): boolean { + return this.nullData.output.check(output) } - public fromASM(asm: string): any { - return Bitcoin.script.fromASM(asm) + public encodeP2PKInput(signature: Buffer): Buffer { + return this.pubKey.input.encode(signature) + } + + public decodeP2PKInput(input: Buffer): Buffer { + return this.pubKey.input.decode(input) + } + + public checkP2PKInput(input: Buffer): boolean { + return this.pubKey.input.check(input) + } + + public encodeP2PKOutput(pubKey: Buffer): Buffer { + return this.pubKey.output.encode(pubKey) + } + + public decodeP2PKOutput(output: Buffer): Buffer { + return this.pubKey.output.decode(output) + } + + public checkP2PKOutput(output: Buffer): boolean { + return this.pubKey.output.check(output); + } + + public encodeP2PKHInput(signature: Buffer, pubKey: Buffer): Buffer { + return this.pubKeyHash.input.encode(signature, pubKey) + } + + public decodeP2PKHInput(input: Buffer): DecodedP2PKHInput { + return this.pubKeyHash.input.decode(input) + } + + public checkP2PKHInput(input: Buffer): boolean { + return this.pubKeyHash.input.check(input) + } + + public encodeP2PKHOutput(identifier: Buffer): Buffer { + return this.pubKeyHash.output.encode(identifier) + } + + public decodeP2PKHOutput(output: Buffer): Buffer { + return this.pubKeyHash.output.decode(output) + } + + public checkP2PKHOutput(output: Buffer): boolean { + return this.pubKeyHash.output.check(output); + } + + public encodeP2MSInput(signatures: Buffer[]): Buffer { + return this.multisig.input.encode(signatures) + } + + public decodeP2MSInput(input: Buffer): Buffer[] { + return this.multisig.input.decode(input); + } + + public checkP2MSInput(input: Buffer): boolean { + return this.multisig.input.check(input) + } + + public encodeP2MSOutput(m: number, pubKeys: Buffer[]): Buffer { + return this.multisig.output.encode(m, pubKeys) + } + + public decodeP2MSOutput(output: Buffer): DecodedP2MSOutput { + return this.multisig.output.decode(output) + } + + public checkP2MSOutput(output: Buffer): boolean { + return this.multisig.output.check(output); + } + + public encodeP2SHInput(redeemScriptSig: Buffer, redeemScript: Buffer): Buffer { + return this.scriptHash.input.encode(redeemScriptSig, redeemScript) + } + + public decodeP2SHInput(input: Buffer): DecodedP2SHInput { + return this.scriptHash.input.decode(input) + } + + public checkP2SHInput(input: Buffer): boolean { + return this.scriptHash.input.check(input); + } + + public encodeP2SHOutput(scriptHash: Buffer): Buffer { + return this.scriptHash.output.encode(scriptHash) + } + + public decodeP2SHOutput(output: Buffer): Buffer { + return this.scriptHash.output.decode(output); + } + + public checkP2SHOutput(output: Buffer): boolean { + return this.scriptHash.output.check(output) } } diff --git a/lib/TransactionBuilder.ts b/lib/TransactionBuilder.ts index b8c6b0f9..49f8c273 100644 --- a/lib/TransactionBuilder.ts +++ b/lib/TransactionBuilder.ts @@ -67,7 +67,7 @@ export class TransactionBuilder { txHash: string, vout: number, sequence: number = this.DEFAULT_SEQUENCE, - prevOutScript: string | null = null + prevOutScript: string | Buffer | null = null ): void { this.transaction.addInput(txHash, vout, sequence, prevOutScript) } @@ -86,9 +86,10 @@ export class TransactionBuilder { this.p2shInput = true } - public addOutput(scriptPubKey: string, amount: number): void { + public addOutput(scriptPubKey: string | Buffer, amount: number): void { try { this.transaction.addOutput( + // @ts-ignore this._address.toLegacyAddress(scriptPubKey), amount ) diff --git a/package.json b/package.json index f234bfe4..f732addf 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "bitbox-sdk", - "version": "7.2.1", + "version": "7.3.0", "description": "BITBOX SDK for Bitcoin Cash", "author": "Gabriel Cardona ", "contributors": [ @@ -105,4 +105,4 @@ "ts-node": "^8.1.0", "typescript": "^3.4.5" } -} \ No newline at end of file +} diff --git a/test/unit/Address.ts b/test/unit/Address.ts index b0b1b235..0b2039ab 100644 --- a/test/unit/Address.ts +++ b/test/unit/Address.ts @@ -998,7 +998,7 @@ describe("#Address", (): void => { }) describe("#fromOutputScript", (): void => { - const script: any = bitbox.Script.encode([ + const script: Buffer = bitbox.Script.encode([ Buffer.from("BOX", "ascii"), bitbox.Script.opcodes.OP_CAT, Buffer.from("BITBOX", "ascii"), @@ -1006,12 +1006,12 @@ describe("#Address", (): void => { ]) // hash160 script buffer - const p2sh_hash160: any = bitbox.Crypto.hash160(script) + const p2sh_hash160: Buffer = bitbox.Crypto.hash160(script) // encode hash160 as P2SH output - const scriptPubKey: any = bitbox.Script.scriptHash.output.encode(p2sh_hash160) + const scriptPubKey: Buffer = bitbox.Script.encodeP2SHOutput(p2sh_hash160) fixtures.p2shMainnet.forEach((address: string) => { - const p2shAddress: any = bitbox.Address.fromOutputScript(scriptPubKey) + const p2shAddress: string = bitbox.Address.fromOutputScript(scriptPubKey) it(`generate mainnet address from output script`, (): void => { assert.equal(p2shAddress, address) }) diff --git a/test/unit/Script.ts b/test/unit/Script.ts index 34b213fc..8bdec629 100644 --- a/test/unit/Script.ts +++ b/test/unit/Script.ts @@ -1,7 +1,7 @@ // imports import * as assert from "assert"; import { BITBOX } from "../../lib/BITBOX" -import { Script } from "../../lib/Script" +import { Script, DecodedP2PKHInput, DecodedP2MSOutput } from "../../lib/Script" import * as bcl from "bitcoincashjs-lib" // consts @@ -186,24 +186,21 @@ describe("#Script", (): void => { describe("#nullDataTemplate", (): void => { fixtures.nullDataTemplate.forEach((fixture: any): void => { it(`should encode nulldata output`, (): void => { - const buf: Buffer = bitbox.Script.nullData.output.encode( - Buffer.from(`${fixture.data}`, "ascii") - ) - assert.equal(buf.toString("hex"), fixture.hex) + let buf: Buffer = Buffer.from(fixture.data, "ascii") + const encoded: Buffer = bitbox.Script.encodeNullDataOutput(buf) + assert.equal(encoded.toString("hex"), fixture.hex) }) it(`should decode nulldata output`, (): void => { - const buf: Buffer = bitbox.Script.nullData.output.decode( - Buffer.from(`${fixture.hex}`, "hex") - ) - assert.equal(buf.toString("ascii"), fixture.data) + let buf: Buffer = Buffer.from(fixture.hex, "hex") + const decoded: Buffer = bitbox.Script.decodeNullDataOutput(buf) + assert.equal(decoded.toString("ascii"), fixture.data) }) it(`should confirm correctly formatted nulldata output`, (): void => { - const buf: Buffer = bitbox.Script.nullData.output.encode( - Buffer.from(`${fixture.data}`, "ascii") - ) - const valid: boolean = bitbox.Script.nullData.output.check(buf) + let buf: Buffer = Buffer.from(fixture.data, "ascii") + const encoded: Buffer = bitbox.Script.encodeNullDataOutput(buf) + const valid: boolean = bitbox.Script.checkNullDataOutput(encoded) assert.equal(valid, true) }) }) @@ -213,7 +210,7 @@ describe("#Script", (): void => { describe("#pubKeyInputTemplate", (): void => { fixtures.pubKeyInputTemplate.forEach((fixture: any): void => { it(`should encode pubKey input`, (): void => { - const buf: Buffer = bitbox.Script.pubKey.input.encode( + const buf: Buffer = bitbox.Script.encodeP2PKInput( Buffer.from(fixture.signature, "hex") ) assert.equal(buf.toString("hex"), fixture.hex) @@ -227,7 +224,7 @@ describe("#Script", (): void => { }) it(`should confirm correctly formatted pubKeyHash input`, (): void => { - const buf: Buffer = bitbox.Script.pubKey.input.encode( + const buf: Buffer = bitbox.Script.encodeP2PKInput( Buffer.from(fixture.signature, "hex") ) const valid: boolean = bitbox.Script.pubKey.input.check(buf) @@ -239,24 +236,21 @@ describe("#Script", (): void => { describe("#pubKeyOutputTemplate", (): void => { fixtures.pubKeyOutputTemplate.forEach((fixture: any): void => { it(`should encode pubKey output`, (): void => { - const buf: Buffer = bitbox.Script.pubKey.output.encode( - Buffer.from(fixture.pubKey, "hex") - ) - assert.equal(buf.toString("hex"), fixture.hex) + const buf: Buffer = Buffer.from(fixture.pubKey, "hex") + const encoded: Buffer = bitbox.Script.encodeP2PKOutput(buf) + assert.equal(encoded.toString("hex"), fixture.hex) }) it(`should decode pubKey output`, (): void => { - const buf: Buffer = bitbox.Script.pubKey.output.decode( - Buffer.from(`${fixture.hex}`, "hex") - ) - assert.equal(buf.toString("hex"), fixture.pubKey) + const buf: Buffer = Buffer.from(fixture.hex, "hex") + const decoded: Buffer = bitbox.Script.decodeP2PKOutput(buf) + assert.equal(decoded.toString("hex"), fixture.pubKey) }) it(`should confirm correctly formatted pubKey output`, (): void => { - const buf: Buffer = bitbox.Script.pubKey.output.encode( - Buffer.from(fixture.pubKey, "hex") - ) - const valid: boolean = bitbox.Script.pubKey.output.check(buf) + const buf: Buffer = Buffer.from(fixture.pubKey, "hex") + const encoded: Buffer = bitbox.Script.encodeP2PKOutput(buf) + const valid: boolean = bitbox.Script.checkP2PKOutput(encoded) assert.equal(valid, true) }) }) @@ -267,39 +261,29 @@ describe("#Script", (): void => { describe("#pubKeyHashInputTemplate", (): void => { fixtures.pubKeyHashInputTemplate.forEach((fixture: any): void => { it(`should encode pubKeyHash input`, (): void => { - const buf: Buffer = bitbox.Script.pubKeyHash.input.encode( - Buffer.from(fixture.signature, "hex"), - Buffer.from(fixture.pubKey, "hex") - ) - assert.equal(buf.toString("hex"), fixture.hex) + const sigBuf = Buffer.from(fixture.signature, 'hex') + const pubKeyBuf = Buffer.from(fixture.pubKey, 'hex') + const encoded: Buffer = bitbox.Script.encodeP2PKHInput(sigBuf, pubKeyBuf) + assert.equal(encoded.toString("hex"), fixture.hex) }) it(`should decode pubKeyHash input signature`, (): void => { - const buf: { - signature: Buffer - pubKey: Buffer - } = bitbox.Script.pubKeyHash.input.decode( - Buffer.from(fixture.hex, "hex") - ) + const input: Buffer = Buffer.from(fixture.hex, "hex") + const buf: DecodedP2PKHInput = bitbox.Script.decodeP2PKHInput(input) assert.equal(buf.signature.toString("hex"), fixture.signature) }) it(`should decode pubKeyHash input pubkey`, (): void => { - const buf: { - signature: Buffer - pubKey: Buffer - } = bitbox.Script.pubKeyHash.input.decode( - Buffer.from(fixture.hex, "hex") - ) + const input: Buffer = Buffer.from(fixture.hex, "hex") + const buf: DecodedP2PKHInput = bitbox.Script.decodeP2PKHInput(input) assert.equal(buf.pubKey.toString("hex"), fixture.pubKey) }) it(`should confirm correctly formatted pubKeyHash input`, (): void => { - const buf: Buffer = bitbox.Script.pubKeyHash.input.encode( - Buffer.from(fixture.signature, "hex"), - Buffer.from(fixture.pubKey, "hex") - ) - const valid: boolean = bitbox.Script.pubKeyHash.input.check(buf) + const sigBuf = Buffer.from(fixture.signature, 'hex') + const pubKeyBuf = Buffer.from(fixture.pubKey, 'hex') + const encoded: Buffer = bitbox.Script.encodeP2PKHInput(sigBuf, pubKeyBuf) + const valid: boolean = bitbox.Script.checkP2PKHInput(encoded) assert.equal(valid, true) }) }) @@ -310,15 +294,14 @@ describe("#Script", (): void => { const node: bcl.HDNode = bitbox.HDNode.fromXPriv(fixture.xpriv) const identifier: Buffer = bitbox.HDNode.toIdentifier(node) it(`should encode pubKeyHash output`, (): void => { - const buf: Buffer = bitbox.Script.pubKeyHash.output.encode(identifier) - assert.equal(buf.toString("hex"), fixture.hex) + const output: Buffer = bitbox.Script.encodeP2PKHOutput(identifier) + assert.equal(output.toString("hex"), fixture.hex) }) it(`should decode pubKeyHash output`, (): void => { - const buf: Buffer = bitbox.Script.pubKeyHash.output.decode( - Buffer.from(`${fixture.hex}`, "hex") - ) - assert.equal(buf.toString("hex"), identifier.toString("hex")) + let output: Buffer = Buffer.from(`${fixture.hex}`, "hex") + const decoded: Buffer = bitbox.Script.pubKeyHash.output.decode(output) + assert.equal(decoded.toString("hex"), identifier.toString("hex")) }) it(`should confirm correctly formatted pubKeyHash output`, (): void => { @@ -334,32 +317,25 @@ describe("#Script", (): void => { describe("#multisigInputTemplate", (): void => { fixtures.multisigInputTemplate.forEach((fixture: any): void => { it(`should encode multisig input`, (): void => { - const signatures: any[] = fixture.signatures.map((signature: any) => - signature - ? Buffer.from(signature, "hex") - : bitbox.Script.opcodes.OP_0 + const signatures: Buffer[] = fixture.signatures.map((signature: any) => + Buffer.from(signature, "hex") ) - - const buf: Buffer = bitbox.Script.multisig.input.encode(signatures) - assert.equal(buf.toString("hex"), fixture.hex) + const input: Buffer = bitbox.Script.encodeP2MSInput(signatures) + assert.equal(input.toString("hex"), fixture.hex) }) it(`should decode multisig input`, (): void => { - const buf: Buffer[] = bitbox.Script.multisig.input.decode( - Buffer.from(fixture.hex, "hex") - ) - assert.equal(buf[0].toString("hex"), fixture.signatures[0]) + const output: Buffer = Buffer.from(fixture.hex, "hex") + const decoded: Buffer[] = bitbox.Script.decodeP2MSInput(output) + assert.equal(decoded[0].toString("hex"), fixture.signatures[0]) }) it(`should confirm correctly formatted multisig input`, (): void => { - const signatures: any[] = fixture.signatures.map((signature: any) => - signature - ? Buffer.from(signature, "hex") - : bitbox.Script.opcodes.OP_0 + const signatures: Buffer[] = fixture.signatures.map((signature: any) => + Buffer.from(signature, "hex") ) - - const buf: Buffer = bitbox.Script.multisig.input.encode(signatures) - const valid: boolean = bitbox.Script.multisig.input.check(buf) + const input: Buffer = bitbox.Script.encodeP2MSInput(signatures) + const valid: boolean = bitbox.Script.checkP2MSInput(input) assert.equal(valid, true) }) }) @@ -370,23 +346,22 @@ describe("#Script", (): void => { it(`should encode multisig output`, (): void => { const pubKeys: Buffer[] = fixture.pubKeys.map((p: string) => Buffer.from(p, "hex")) const m: number = pubKeys.length - const buf: Buffer = bitbox.Script.multisig.output.encode(m, pubKeys) + const output: Buffer = bitbox.Script.encodeP2MSOutput(m, pubKeys) - assert.equal(buf.toString("hex"), fixture.hex) + assert.equal(output.toString("hex"), fixture.hex) }) it(`should decode multisig output`, (): void => { - const output: any = bitbox.Script.multisig.output.decode( - Buffer.from(`${fixture.hex}`, "hex") - ) - assert.equal(output.m, fixture.pubKeys.length) + const output: Buffer = Buffer.from(`${fixture.hex}`, "hex") + const decoded: DecodedP2MSOutput = bitbox.Script.decodeP2MSOutput(output) + assert.equal(decoded.m, fixture.pubKeys.length) }) it(`should confirm correctly formatted multisig output`, (): void => { const pubKeys: Buffer[] = fixture.pubKeys.map((p: any) => Buffer.from(p, "hex")) const m: number = pubKeys.length - const buf: Buffer = bitbox.Script.multisig.output.encode(m, pubKeys) - const valid: boolean = bitbox.Script.multisig.output.check(buf) + const output: Buffer = bitbox.Script.encodeP2MSOutput(m, pubKeys) + const valid: boolean = bitbox.Script.checkP2MSOutput(output) assert.equal(valid, true) }) }) @@ -397,20 +372,18 @@ describe("#Script", (): void => { describe("#scriptHashInputTemplate", (): void => { fixtures.scriptHashInputTemplate.forEach((fixture: any): void => { it(`should encode scriptHash input`, (): void => { - const buf: Buffer = bitbox.Script.scriptHash.input.encode( - bitbox.Script.fromASM(fixture.redeemScriptSig), - bitbox.Script.fromASM(fixture.redeemScript) - ) - assert.equal(buf.toString("hex"), fixture.hex) + const redeemScriptSig: Buffer = bitbox.Script.fromASM(fixture.redeemScriptSig) + const redeemScript: Buffer = bitbox.Script.fromASM(fixture.redeemScript) + const input: Buffer = bitbox.Script.encodeP2SHInput(redeemScriptSig, redeemScript) + assert.equal(input.toString("hex"), fixture.hex) }) it(`should decode scriptHash input`, (): void => { - const redeemScriptSig: any = bitbox.Script.fromASM(fixture.redeemScriptSig) - const redeemScript: any = bitbox.Script.fromASM(fixture.redeemScript) + const redeemScriptSig: Buffer = bitbox.Script.fromASM(fixture.redeemScriptSig) + const redeemScript: Buffer = bitbox.Script.fromASM(fixture.redeemScript) + const input: Buffer = bitbox.Script.encodeP2SHInput(redeemScriptSig, redeemScript) assert.deepEqual( - bitbox.Script.scriptHash.input.decode( - Buffer.from(fixture.hex, "hex") - ), + bitbox.Script.decodeP2SHInput(input), { redeemScriptSig: redeemScriptSig, redeemScript: redeemScript @@ -419,11 +392,10 @@ describe("#Script", (): void => { }) it(`should confirm correctly formatted scriptHash input`, (): void => { - const buf: Buffer = bitbox.Script.scriptHash.input.encode( - bitbox.Script.fromASM(fixture.redeemScriptSig), - bitbox.Script.fromASM(fixture.redeemScript) - ) - const valid: boolean = bitbox.Script.scriptHash.input.check(buf) + const redeemScriptSig: Buffer = bitbox.Script.fromASM(fixture.redeemScriptSig) + const redeemScript: Buffer = bitbox.Script.fromASM(fixture.redeemScript) + const input: Buffer = bitbox.Script.encodeP2SHInput(redeemScriptSig, redeemScript) + const valid: boolean = bitbox.Script.scriptHash.input.check(input) assert.equal(valid, true) }) }) @@ -432,26 +404,25 @@ describe("#Script", (): void => { describe("#scriptHashOutputTemplate", (): void => { fixtures.scriptHashOutputTemplate.forEach((fixture: any): void => { it(`should encode scriptHash output`, (): void => { - const redeemScript: any = bitbox.Script.fromASM(fixture.output) + const redeemScript: Buffer = bitbox.Script.fromASM(fixture.output) const scriptHash: Buffer = bitbox.Crypto.hash160(redeemScript) - const buf: Buffer = bitbox.Script.scriptHash.output.encode(scriptHash) + const output: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash) - assert.equal(buf.toString("hex"), fixture.hex) + assert.equal(output.toString("hex"), fixture.hex) }) it(`should decode scriptHash output`, (): void => { const redeemScript: any = bitbox.Script.fromASM(fixture.output) const scriptHash: Buffer = bitbox.Crypto.hash160(redeemScript) - const buf: Buffer = bitbox.Script.scriptHash.output.decode( - Buffer.from(`${fixture.hex}`, "hex") - ) - assert.deepEqual(buf, scriptHash) + const output: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash) + let decoded: Buffer = bitbox.Script.decodeP2SHOutput(output) + assert.deepEqual(decoded, scriptHash) }) it(`should confirm correctly formatted scriptHash output`, (): void => { const redeemScript: any = bitbox.Script.fromASM(fixture.output) const scriptHash: Buffer = bitbox.Crypto.hash160(redeemScript) - const buf: Buffer = bitbox.Script.scriptHash.output.encode(scriptHash) + const buf: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash) const valid: boolean = bitbox.Script.scriptHash.output.check(buf) assert.equal(valid, true) }) diff --git a/test/unit/TransactionBuilder.ts b/test/unit/TransactionBuilder.ts index d9078ffd..fd08ef26 100644 --- a/test/unit/TransactionBuilder.ts +++ b/test/unit/TransactionBuilder.ts @@ -41,7 +41,7 @@ describe("#TransactionBuilder", (): void => { const originalAmount: number = fixture.amount const txid: string = fixture.txHash const pubKey: any = bitbox.HDNode.toPublicKey(node) - const prevOutScript: string = bitbox.Script.pubKey.output.encode(pubKey) + const prevOutScript: Buffer = bitbox.Script.encodeP2PKOutput(pubKey) transactionBuilder.addInput( txid, 0, @@ -77,8 +77,8 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder("testnet") const originalAmount: number = fixture.amount const txid: string = fixture.txHash - const pubKey: any = bitbox.HDNode.toPublicKey(node) - const prevOutScript: string = bitbox.Script.pubKey.output.encode(pubKey) + const pubKey: Buffer = bitbox.HDNode.toPublicKey(node) + const prevOutScript: Buffer = bitbox.Script.encodeP2PKOutput(pubKey) transactionBuilder.addInput( txid, 0, @@ -118,12 +118,12 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder() const originalAmount: number = fixture.amount const txid: string = fixture.txHash - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const prevOutScript1: string = bitbox.Script.pubKey.output.encode(pubKey1) - const prevOutScript2: string = bitbox.Script.pubKey.output.encode(pubKey2) - const prevOutScript3: string = bitbox.Script.pubKey.output.encode(pubKey3) + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const prevOutScript1: Buffer = bitbox.Script.encodeP2PKOutput(pubKey1) + const prevOutScript2: Buffer = bitbox.Script.encodeP2PKOutput(pubKey2) + const prevOutScript3: Buffer = bitbox.Script.encodeP2PKOutput(pubKey3) transactionBuilder.addInput( txid, 0, @@ -162,12 +162,12 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder("testnet") const originalAmount: number = fixture.amount const txid: string = fixture.txHash - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const prevOutScript1: string = bitbox.Script.pubKey.output.encode(pubKey1) - const prevOutScript2: string = bitbox.Script.pubKey.output.encode(pubKey2) - const prevOutScript3: string = bitbox.Script.pubKey.output.encode(pubKey3) + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const prevOutScript1: Buffer = bitbox.Script.encodeP2PKOutput(pubKey1) + const prevOutScript2: Buffer = bitbox.Script.encodeP2PKOutput(pubKey2) + const prevOutScript3: Buffer = bitbox.Script.encodeP2PKOutput(pubKey3) transactionBuilder.addInput( txid, 0, @@ -209,14 +209,14 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder() const originalAmount: number = fixture.amount const txid: string = fixture.txHash - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const pubKey4: any = bitbox.HDNode.toPublicKey(node4) - const prevOutScript1: string = bitbox.Script.pubKey.output.encode(pubKey1) - const prevOutScript2: string = bitbox.Script.pubKey.output.encode(pubKey2) - const prevOutScript3: string = bitbox.Script.pubKey.output.encode(pubKey3) - const prevOutScript4: string = bitbox.Script.pubKey.output.encode(pubKey4) + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const pubKey4: Buffer = bitbox.HDNode.toPublicKey(node4) + const prevOutScript1: Buffer = bitbox.Script.encodeP2PKOutput(pubKey1) + const prevOutScript2: Buffer = bitbox.Script.encodeP2PKOutput(pubKey2) + const prevOutScript3: Buffer = bitbox.Script.encodeP2PKOutput(pubKey3) + const prevOutScript4: Buffer = bitbox.Script.encodeP2PKOutput(pubKey4) transactionBuilder.addInput( txid, 0, @@ -270,14 +270,14 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder("testnet") const originalAmount: number = fixture.amount const txid: string = fixture.txHash - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const pubKey4: any = bitbox.HDNode.toPublicKey(node4) - const prevOutScript1: string = bitbox.Script.pubKey.output.encode(pubKey1) - const prevOutScript2: string = bitbox.Script.pubKey.output.encode(pubKey2) - const prevOutScript3: string = bitbox.Script.pubKey.output.encode(pubKey3) - const prevOutScript4: string = bitbox.Script.pubKey.output.encode(pubKey4) + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const pubKey4: Buffer = bitbox.HDNode.toPublicKey(node4) + const prevOutScript1: Buffer = bitbox.Script.encodeP2PKOutput(pubKey1) + const prevOutScript2: Buffer = bitbox.Script.encodeP2PKOutput(pubKey2) + const prevOutScript3: Buffer = bitbox.Script.encodeP2PKOutput(pubKey3) + const prevOutScript4: Buffer = bitbox.Script.encodeP2PKOutput(pubKey4) transactionBuilder.addInput( txid, 0, @@ -332,12 +332,12 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder() const originalAmount: any = fixture.amount const txid: string = fixture.txHash - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const prevOutScript1: string = bitbox.Script.pubKey.output.encode(pubKey1) - const prevOutScript2: string = bitbox.Script.pubKey.output.encode(pubKey2) - const prevOutScript3: string = bitbox.Script.pubKey.output.encode(pubKey3) + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const prevOutScript1: Buffer = bitbox.Script.encodeP2PKOutput(pubKey1) + const prevOutScript2: Buffer = bitbox.Script.encodeP2PKOutput(pubKey2) + const prevOutScript3: Buffer = bitbox.Script.encodeP2PKOutput(pubKey3) transactionBuilder.addInput( txid, 0, @@ -389,12 +389,12 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder("testnet") const originalAmount: number = fixture.amount const txid: string = fixture.txHash - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const prevOutScript1: string = bitbox.Script.pubKey.output.encode(pubKey1) - const prevOutScript2: string = bitbox.Script.pubKey.output.encode(pubKey2) - const prevOutScript3: string = bitbox.Script.pubKey.output.encode(pubKey3) + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const prevOutScript1: Buffer = bitbox.Script.encodeP2PKOutput(pubKey1) + const prevOutScript2: Buffer = bitbox.Script.encodeP2PKOutput(pubKey2) + const prevOutScript3: Buffer = bitbox.Script.encodeP2PKOutput(pubKey3) transactionBuilder.addInput( txid, 0, @@ -968,10 +968,9 @@ describe("#TransactionBuilder", (): void => { const sendAmount: number = originalAmount - byteCount transactionBuilder.addOutput(fixture.output, sendAmount) const data = fixture.data - const buf: string = bitbox.Script.nullData.output.encode( - Buffer.from(data, "ascii") - ) - transactionBuilder.addOutput(buf, 0) + let buf: Buffer = Buffer.from(data, "ascii") + const encoded: Buffer = bitbox.Script.encodeNullDataOutput(buf) + transactionBuilder.addOutput(encoded, 0) const keyPair = bitbox.HDNode.toKeyPair(node) let redeemScript: undefined transactionBuilder.sign( @@ -1003,10 +1002,9 @@ describe("#TransactionBuilder", (): void => { const sendAmount: number = originalAmount - byteCount transactionBuilder.addOutput(fixture.output, sendAmount) const data = fixture.data - const buf: string = bitbox.Script.nullData.output.encode( - Buffer.from(data, "ascii") - ) - transactionBuilder.addOutput(buf, 0) + let buf: Buffer = Buffer.from(data, "ascii") + const encoded: Buffer = bitbox.Script.encodeNullDataOutput(buf) + transactionBuilder.addOutput(encoded, 0) const keyPair = bitbox.HDNode.toKeyPair(node) let redeemScript: undefined transactionBuilder.sign( @@ -1038,10 +1036,9 @@ describe("#TransactionBuilder", (): void => { const sendAmount: number = originalAmount - byteCount transactionBuilder.addOutput(fixture.output, sendAmount) const data = fixture.data - const buf: string = bitbox.Script.nullData.output.encode( - Buffer.from(data, "ascii") - ) - transactionBuilder.addOutput(buf, 0) + let buf: Buffer = Buffer.from(data, "ascii") + const encoded: Buffer = bitbox.Script.encodeNullDataOutput(buf) + transactionBuilder.addOutput(encoded, 0) const keyPair = bitbox.HDNode.toKeyPair(node) let redeemScript: undefined transactionBuilder.sign( @@ -1071,9 +1068,9 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder() const txid: string = fixture.txHash const originalAmount: number = fixture.amount - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const buf1: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const buf1: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey1, pubKey2 ]) @@ -1087,9 +1084,9 @@ describe("#TransactionBuilder", (): void => { { P2PKH: 3 }, { P2PKH: 3 } ) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const pubKey4: any = bitbox.HDNode.toPublicKey(node4) - const buf2: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const pubKey4: Buffer = bitbox.HDNode.toPublicKey(node4) + const buf2: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey3, pubKey4 ]) @@ -1153,9 +1150,9 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder() const txid: string = fixture.txHash const originalAmount: number = fixture.amount - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const buf1: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const buf1: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey1, pubKey2 ]) @@ -1170,16 +1167,16 @@ describe("#TransactionBuilder", (): void => { { P2PKH: 3 } ) const sendAmount: number = originalAmount - byteCount - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const pubKey4: any = bitbox.HDNode.toPublicKey(node4) - const buf2: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const pubKey4: Buffer = bitbox.HDNode.toPublicKey(node4) + const buf2: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey3, pubKey4 ]) transactionBuilder.addOutput(buf2, Math.floor(sendAmount / 2)) - const pubKey5 = bitbox.HDNode.toPublicKey(node5) - const pubKey6 = bitbox.HDNode.toPublicKey(node6) - const buf3: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey5: Buffer = bitbox.HDNode.toPublicKey(node5) + const pubKey6: Buffer = bitbox.HDNode.toPublicKey(node6) + const buf3: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey5, pubKey6 ]) @@ -1245,9 +1242,9 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder() const txid: string = fixture.txHash const originalAmount: number = fixture.amount - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const buf1: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const buf1: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey1, pubKey2 ]) @@ -1257,9 +1254,9 @@ describe("#TransactionBuilder", (): void => { transactionBuilder.DEFAULT_SEQUENCE, buf1 ) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const pubKey4: any = bitbox.HDNode.toPublicKey(node4) - const buf2: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const pubKey4: Buffer = bitbox.HDNode.toPublicKey(node4) + const buf2: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey3, pubKey4 ]) @@ -1274,16 +1271,16 @@ describe("#TransactionBuilder", (): void => { { P2PKH: 3 } ) const sendAmount: number = originalAmount - byteCount - const pubKey5 = bitbox.HDNode.toPublicKey(node5) - const pubKey6 = bitbox.HDNode.toPublicKey(node6) - const buf3: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey5: Buffer = bitbox.HDNode.toPublicKey(node5) + const pubKey6: Buffer = bitbox.HDNode.toPublicKey(node6) + const buf3: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey5, pubKey6 ]) transactionBuilder.addOutput(buf3, Math.floor(sendAmount / 2)) - const pubKey7 = bitbox.HDNode.toPublicKey(node7) - const pubKey8 = bitbox.HDNode.toPublicKey(node8) - const buf4: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey7: Buffer = bitbox.HDNode.toPublicKey(node7) + const pubKey8: Buffer = bitbox.HDNode.toPublicKey(node8) + const buf4: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey7, pubKey8 ]) @@ -1352,9 +1349,9 @@ describe("#TransactionBuilder", (): void => { const transactionBuilder: TransactionBuilder = new bitbox.TransactionBuilder() const txid: string = fixture.txHash const originalAmount: number = fixture.amount - const pubKey1: any = bitbox.HDNode.toPublicKey(node1) - const pubKey2: any = bitbox.HDNode.toPublicKey(node2) - const buf1: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey1: Buffer = bitbox.HDNode.toPublicKey(node1) + const pubKey2: Buffer = bitbox.HDNode.toPublicKey(node2) + const buf1: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey1, pubKey2 ]) @@ -1364,9 +1361,9 @@ describe("#TransactionBuilder", (): void => { transactionBuilder.DEFAULT_SEQUENCE, buf1 ) - const pubKey3: any = bitbox.HDNode.toPublicKey(node3) - const pubKey4: any = bitbox.HDNode.toPublicKey(node4) - const buf2: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey3: Buffer = bitbox.HDNode.toPublicKey(node3) + const pubKey4: Buffer = bitbox.HDNode.toPublicKey(node4) + const buf2: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey3, pubKey4 ]) @@ -1381,9 +1378,9 @@ describe("#TransactionBuilder", (): void => { { P2PKH: 3 } ) const sendAmount: number = originalAmount - byteCount - const pubKey5: any = bitbox.HDNode.toPublicKey(node5) - const pubKey6: any = bitbox.HDNode.toPublicKey(node6) - const buf3: string = bitbox.Script.multisig.output.encode(1, [ + const pubKey5: Buffer = bitbox.HDNode.toPublicKey(node5) + const pubKey6: Buffer = bitbox.HDNode.toPublicKey(node6) + const buf3: Buffer = bitbox.Script.encodeP2MSOutput(1, [ pubKey5, pubKey6 ]) @@ -1458,7 +1455,7 @@ describe("#TransactionBuilder", (): void => { bitbox.Script.opcodes.OP_CHECKSIG ]) const scriptHash1: any = bitbox.Crypto.hash160(buf1) - const data1: string = bitbox.Script.scriptHash.output.encode(scriptHash1) + const data1: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash1) transactionBuilder.addInput( txid, 0, @@ -1480,7 +1477,7 @@ describe("#TransactionBuilder", (): void => { ]) const scriptHash2 = bitbox.Crypto.hash160(buf2) - const data2: string = bitbox.Script.scriptHash.output.encode(scriptHash2) + const data2: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash2) transactionBuilder.addOutput(data2, sendAmount) const keyPair1: bcl.ECPair = bitbox.HDNode.toKeyPair(node1) transactionBuilder.sign( @@ -1544,8 +1541,8 @@ describe("#TransactionBuilder", (): void => { bitbox.Script.opcodes.OP_EQUALVERIFY, bitbox.Script.opcodes.OP_CHECKSIG ]) - const scriptHash1: any = bitbox.Crypto.hash160(buf1) - const data1: string = bitbox.Script.scriptHash.output.encode(scriptHash1) + const scriptHash1: Buffer = bitbox.Crypto.hash160(buf1) + const data1: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash1) transactionBuilder.addInput( txid, 0, @@ -1557,27 +1554,27 @@ describe("#TransactionBuilder", (): void => { { P2PKH: 2 } ) const sendAmount: number = originalAmount - byteCount - const identifier2 = bitbox.HDNode.toIdentifier(node2) - const buf2 = bitbox.Script.encode([ + const identifier2: Buffer = bitbox.HDNode.toIdentifier(node2) + const buf2: Buffer = bitbox.Script.encode([ bitbox.Script.opcodes.OP_DUP, bitbox.Script.opcodes.OP_HASH160, identifier2, bitbox.Script.opcodes.OP_EQUALVERIFY, bitbox.Script.opcodes.OP_CHECKSIG ]) - const scriptHash2 = bitbox.Crypto.hash160(buf2) - const data2: string = bitbox.Script.scriptHash.output.encode(scriptHash2) + const scriptHash2: Buffer = bitbox.Crypto.hash160(buf2) + const data2: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash2) transactionBuilder.addOutput(data2, Math.floor(sendAmount / 2)) - const identifier3 = bitbox.HDNode.toIdentifier(node3) - const buf3 = bitbox.Script.encode([ + const identifier3: Buffer = bitbox.HDNode.toIdentifier(node3) + const buf3: Buffer = bitbox.Script.encode([ bitbox.Script.opcodes.OP_DUP, bitbox.Script.opcodes.OP_HASH160, identifier3, bitbox.Script.opcodes.OP_EQUALVERIFY, bitbox.Script.opcodes.OP_CHECKSIG ]) - const scriptHash3 = bitbox.Crypto.hash160(buf3) - const data3: string = bitbox.Script.scriptHash.output.encode(scriptHash3) + const scriptHash3: Buffer = bitbox.Crypto.hash160(buf3) + const data3: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash3) transactionBuilder.addOutput(data3, Math.floor(sendAmount / 2)) const keyPair1: bcl.ECPair = bitbox.HDNode.toKeyPair(node1) transactionBuilder.sign( @@ -1636,15 +1633,15 @@ describe("#TransactionBuilder", (): void => { const txid: string = fixture.txHash const originalAmount: number = fixture.amount const identifier1: Buffer = bitbox.HDNode.toIdentifier(node1) - const buf1: any = bitbox.Script.encode([ + const buf1: Buffer = bitbox.Script.encode([ bitbox.Script.opcodes.OP_DUP, bitbox.Script.opcodes.OP_HASH160, identifier1, bitbox.Script.opcodes.OP_EQUALVERIFY, bitbox.Script.opcodes.OP_CHECKSIG ]) - const scriptHash1: any = bitbox.Crypto.hash160(buf1) - const data1: string = bitbox.Script.scriptHash.output.encode(scriptHash1) + const scriptHash1: Buffer = bitbox.Crypto.hash160(buf1) + const data1: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash1) transactionBuilder.addInput( txid, 0, @@ -1665,14 +1662,14 @@ describe("#TransactionBuilder", (): void => { bitbox.Script.opcodes.OP_CHECKSIG ]) const scriptHash2: Buffer = bitbox.Crypto.hash160(buf2) - const data2: string = bitbox.Script.scriptHash.output.encode(scriptHash2) + const data2: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash2) transactionBuilder.addInput( txid, 1, transactionBuilder.DEFAULT_SEQUENCE, data2 ) - const identifier3 = bitbox.HDNode.toIdentifier(node3) + const identifier3: Buffer = bitbox.HDNode.toIdentifier(node3) const buf3: Buffer = bitbox.Script.encode([ bitbox.Script.opcodes.OP_DUP, bitbox.Script.opcodes.OP_HASH160, @@ -1681,7 +1678,7 @@ describe("#TransactionBuilder", (): void => { bitbox.Script.opcodes.OP_CHECKSIG ]) const scriptHash3: Buffer = bitbox.Crypto.hash160(buf3) - const data3: string = bitbox.Script.scriptHash.output.encode(scriptHash3) + const data3: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash3) transactionBuilder.addOutput(data3, Math.floor(sendAmount / 2)) const identifier4: Buffer = bitbox.HDNode.toIdentifier(node4) const buf4: Buffer = bitbox.Script.encode([ @@ -1692,7 +1689,7 @@ describe("#TransactionBuilder", (): void => { bitbox.Script.opcodes.OP_CHECKSIG ]) const scriptHash4: Buffer = bitbox.Crypto.hash160(buf4) - const data4: string = bitbox.Script.scriptHash.output.encode(scriptHash4) + const data4: Buffer = bitbox.Script.encodeP2SHOutput(scriptHash4) transactionBuilder.addOutput(data4, Math.floor(sendAmount / 2)) const keyPair1: bcl.ECPair = bitbox.HDNode.toKeyPair(node1) const keyPair2: bcl.ECPair = bitbox.HDNode.toKeyPair(node2) @@ -1755,14 +1752,14 @@ describe("#TransactionBuilder", (): void => { const txid: string = fixture.txHash const originalAmount: number = fixture.amount const identifier1: Buffer = bitbox.HDNode.toIdentifier(node1) - const buf1: any = bitbox.Script.encode([ + const buf1: Buffer = bitbox.Script.encode([ bitbox.Script.opcodes.OP_DUP, bitbox.Script.opcodes.OP_HASH160, identifier1, bitbox.Script.opcodes.OP_EQUALVERIFY, bitbox.Script.opcodes.OP_CHECKSIG ]) - const scriptHash1: any = bitbox.Crypto.hash160(buf1) + const scriptHash1: Buffer = bitbox.Crypto.hash160(buf1) const data1 = bitbox.Script.scriptHash.output.encode(scriptHash1) transactionBuilder.addInput( txid, @@ -1775,15 +1772,15 @@ describe("#TransactionBuilder", (): void => { { P2PKH: 2 } ) const sendAmount: number = originalAmount - byteCount - const identifier2 = bitbox.HDNode.toIdentifier(node2) - const buf2 = bitbox.Script.encode([ + const identifier2: Buffer = bitbox.HDNode.toIdentifier(node2) + const buf2: Buffer = bitbox.Script.encode([ bitbox.Script.opcodes.OP_DUP, bitbox.Script.opcodes.OP_HASH160, identifier2, bitbox.Script.opcodes.OP_EQUALVERIFY, bitbox.Script.opcodes.OP_CHECKSIG ]) - const scriptHash2 = bitbox.Crypto.hash160(buf2) + const scriptHash2: Buffer = bitbox.Crypto.hash160(buf2) const data2 = bitbox.Script.scriptHash.output.encode(scriptHash2) transactionBuilder.addInput( txid, @@ -1791,15 +1788,15 @@ describe("#TransactionBuilder", (): void => { transactionBuilder.DEFAULT_SEQUENCE, data2 ) - const identifier3 = bitbox.HDNode.toIdentifier(node3) - const buf3 = bitbox.Script.encode([ + const identifier3: Buffer = bitbox.HDNode.toIdentifier(node3) + const buf3: Buffer = bitbox.Script.encode([ bitbox.Script.opcodes.OP_DUP, bitbox.Script.opcodes.OP_HASH160, identifier3, bitbox.Script.opcodes.OP_EQUALVERIFY, bitbox.Script.opcodes.OP_CHECKSIG ]) - const scriptHash3 = bitbox.Crypto.hash160(buf3) + const scriptHash3: Buffer = bitbox.Crypto.hash160(buf3) const data3 = bitbox.Script.scriptHash.output.encode(scriptHash3) transactionBuilder.addOutput(data3, sendAmount) const keyPair1: bcl.ECPair = bitbox.HDNode.toKeyPair(node1) @@ -1868,11 +1865,10 @@ describe("#TransactionBuilder", (): void => { const sendAmount: number = originalAmount - byteCount transactionBuilder.addOutput(fixture.output, sendAmount) const data = fixture.data - const buf = bitbox.Script.nullData.output.encode( - Buffer.from(data, "ascii") - ) - transactionBuilder.addOutput(buf, 0) - const keyPair = bitbox.HDNode.toKeyPair(node) + let buf: Buffer = Buffer.from(data, "ascii") + const encoded: Buffer = bitbox.Script.encodeNullDataOutput(buf) + transactionBuilder.addOutput(encoded, 0) + const keyPair: bcl.ECPair = bitbox.HDNode.toKeyPair(node) let redeemScript: undefined transactionBuilder.sign( 0, @@ -1903,10 +1899,9 @@ describe("#TransactionBuilder", (): void => { const sendAmount: number = originalAmount - byteCount transactionBuilder.addOutput(fixture.output, sendAmount) const data = fixture.data - const buf = bitbox.Script.nullData.output.encode( - Buffer.from(data, "ascii") - ) - transactionBuilder.addOutput(buf, 0) + let buf: Buffer = Buffer.from(data, "ascii") + const encoded: Buffer = bitbox.Script.encodeNullDataOutput(buf) + transactionBuilder.addOutput(encoded, 0) const keyPair = bitbox.HDNode.toKeyPair(node) let redeemScript: undefined transactionBuilder.sign( @@ -1938,10 +1933,9 @@ describe("#TransactionBuilder", (): void => { const sendAmount: number = originalAmount - byteCount transactionBuilder.addOutput(fixture.output, sendAmount) const data = fixture.data - const buf = bitbox.Script.nullData.output.encode( - Buffer.from(data, "ascii") - ) - transactionBuilder.addOutput(buf, 0) + let buf: Buffer = Buffer.from(data, "ascii") + const encoded: Buffer = bitbox.Script.encodeNullDataOutput(buf) + transactionBuilder.addOutput(encoded, 0) const keyPair = bitbox.HDNode.toKeyPair(node) let redeemScript: undefined transactionBuilder.sign(