@btc-vision/bitcoin 6.5.6 → 7.0.0-alpha.0

package/test/script.spec.ts

@@ -1,6 +1,7 @@
 import assert from 'assert';
 import { describe, it } from 'vitest';
 import * as bscript from '../src/script.js';
+import { toHex } from '../src/io/index.js';
 import fixtures from './fixtures/script.json' with { type: 'json' };
 
 // @ts-ignore
@@ -128,7 +129,7 @@ describe('script', () => {
 
                 it('encodes/decodes ' + ih, () => {
                     const script = bscript.fromASM(f.input);
-                    assert.strictEqual(script.toString('hex'), f.inputHex);
+                    assert.strictEqual(toHex(script), f.inputHex);
                     assert.strictEqual(bscript.toASM(script), f.input);
                 });
             }
@@ -136,7 +137,7 @@ describe('script', () => {
             if (f.outputHex) {
                 it('encodes/decodes ' + f.output, () => {
                     const script = bscript.fromASM(f.output);
-                    assert.strictEqual(script.toString('hex'), f.outputHex);
+                    assert.strictEqual(toHex(script), f.outputHex);
                     assert.strictEqual(bscript.toASM(script), f.output);
                 });
             }
@@ -164,7 +165,7 @@ describe('script', () => {
                 const stack = bscript.toStack(script);
                 assert.deepStrictEqual(
                     stack.map((x) => {
-                        return x.toString('hex');
+                        return toHex(x);
                     }),
                     f.stack,
                 );
@@ -183,12 +184,12 @@ describe('script', () => {
             it('compiles ' + f.asm, () => {
                 const scriptSig = bscript.fromASM(f.asm);
 
-                assert.strictEqual(scriptSig.toString('hex'), f.script);
+                assert.strictEqual(toHex(scriptSig), f.script);
 
                 if (f.nonstandard) {
                     const scriptSigNS = bscript.fromASM(f.nonstandard.scriptSig);
 
-                    assert.strictEqual(scriptSigNS.toString('hex'), f.script);
+                    assert.strictEqual(toHex(scriptSigNS), f.script);
                 }
             });
         });
@@ -199,7 +200,7 @@ describe('script', () => {
             it('decompiles ' + f.asm, () => {
                 const chunks = bscript.decompile(Buffer.from(f.script, 'hex'));
 
-                assert.strictEqual(bscript.compile(chunks!).toString('hex'), f.script);
+                assert.strictEqual(toHex(bscript.compile(chunks!)), f.script);
                 assert.strictEqual(bscript.toASM(chunks!), f.asm);
 
                 if (f.nonstandard) {
@@ -207,7 +208,7 @@ describe('script', () => {
                         Buffer.from(f.nonstandard.scriptSigHex, 'hex'),
                     );
 
-                    assert.strictEqual(bscript.compile(chunksNS!).toString('hex'), f.script);
+                    assert.strictEqual(toHex(bscript.compile(chunksNS!)), f.script);
 
                     // toASM converts verbatim, only `compile` transforms the script to a minimalpush compliant script
                     assert.strictEqual(bscript.toASM(chunksNS!), f.nonstandard.scriptSig);
@@ -235,12 +236,12 @@ describe('script', () => {
 
         function testEncodingForSize(num: number): void {
             it('compliant for data PUSH of length ' + num, () => {
-                const buffer = Buffer.alloc(num);
+                const buffer = new Uint8Array(num);
                 const script = bscript.compile([buffer]);
 
                 assert(
-                    minimalData(script),
-                    'Failed for ' + num + ' length script: ' + script.toString('hex'),
+                    minimalData(Buffer.from(script)),
+                    'Failed for ' + num + ' length script: ' + toHex(script),
                 );
             });
         }

package/test/script_signature.spec.ts

@@ -1,23 +1,21 @@
 import assert from 'assert';
 import { describe, it } from 'vitest';
 import { signature as bscriptSig } from '../src/script.js';
+import { toHex, fromHex, concat } from '../src/io/index.js';
 import fixtures from './fixtures/signature.json' with { type: 'json' };
 
 describe('Script Signatures', () => {
-    function fromRaw(signature: { r: string; s: string }): Buffer {
-        return Buffer.concat(
-            [Buffer.from(signature.r, 'hex'), Buffer.from(signature.s, 'hex')],
-            64,
-        );
+    function fromRaw(signature: { r: string; s: string }): Uint8Array {
+        return concat([fromHex(signature.r), fromHex(signature.s)]);
     }
 
-    function toRaw(signature: Buffer): {
+    function toRaw(signature: Uint8Array): {
         r: string;
         s: string;
     } {
         return {
-            r: signature.slice(0, 32).toString('hex'),
-            s: signature.slice(32, 64).toString('hex'),
+            r: toHex(signature.slice(0, 32)),
+            s: toHex(signature.slice(32, 64)),
         };
     }
 
@@ -26,7 +24,7 @@ describe('Script Signatures', () => {
             it('encodes ' + f.hex, () => {
                 const buffer = bscriptSig.encode(fromRaw(f.raw), f.hashType);
 
-                assert.strictEqual(buffer.toString('hex'), f.hex);
+                assert.strictEqual(toHex(buffer), f.hex);
             });
         });
 
@@ -46,7 +44,7 @@ describe('Script Signatures', () => {
     describe('decode', () => {
         fixtures.valid.forEach((f) => {
             it('decodes ' + f.hex, () => {
-                const decode = bscriptSig.decode(Buffer.from(f.hex, 'hex'));
+                const decode = bscriptSig.decode(fromHex(f.hex));
 
                 assert.deepStrictEqual(toRaw(decode.signature), f.raw);
                 assert.strictEqual(decode.hashType, f.hashType);
@@ -55,7 +53,7 @@ describe('Script Signatures', () => {
 
         fixtures.invalid.forEach((f) => {
             it('throws on ' + f.hex, () => {
-                const buffer = Buffer.from(f.hex, 'hex');
+                const buffer = fromHex(f.hex);
 
                 assert.throws(() => {
                     bscriptSig.decode(buffer);