@btc-vision/bitcoin 6.3.6 → 6.4.0

package/test/ts-node-register.js

@@ -1,5 +1,7 @@
-// This file is required to run mocha tests on the TS files directly
-
-require('ts-node').register({
-    project: 'test/tsconfig.json',
-});
+// This file is required to run mocha tests on the TS files directly
+
+import { register } from 'ts-node';
+
+register({
+    project: 'test/tsconfig.json',
+});

package/test/tsconfig.json

@@ -1,9 +1,11 @@
 {
     "compilerOptions": {
         "target": "ESNext",
-        "module": "commonjs",
+        "module": "esnext",
+        "moduleResolution": "nodenext",
         "outDir": "../",
         "declaration": false,
+        "allowSyntheticDefaultImports": true,
         "rootDir": "../",
         "rootDirs": [
             "../src",
@@ -16,6 +18,7 @@
         "lib": [
             "ES2021"
         ],
+        "resolvePackageJsonImports": true,
         "allowJs": false,
         "resolveJsonModule": true,
         "strict": true,

package/test/types.spec.ts

@@ -1,58 +1,53 @@
-import * as assert from 'assert';
-import { describe, it } from 'mocha';
-import * as types from '../src/types';
-
-const typeforce = require('typeforce');
-
-describe('types', () => {
-    describe('Buffer Hash160/Hash256', () => {
-        const buffer20byte = Buffer.alloc(20);
-        const buffer32byte = Buffer.alloc(32);
-
-        it('return true for valid size', () => {
-            assert(types.Hash160bit(buffer20byte));
-            assert(types.Hash256bit(buffer32byte));
-        });
-
-        it('return true for oneOf', () => {
-            assert.doesNotThrow(() => {
-                typeforce(
-                    types.oneOf(types.Hash160bit, types.Hash256bit),
-                    buffer32byte,
-                );
-            });
-
-            assert.doesNotThrow(() => {
-                typeforce(
-                    types.oneOf(types.Hash256bit, types.Hash160bit),
-                    buffer32byte,
-                );
-            });
-        });
-
-        it('throws for invalid size', () => {
-            assert.throws(() => {
-                types.Hash160bit(buffer32byte);
-            }, /Expected Buffer\(Length: 20\), got Buffer\(Length: 32\)/);
-
-            assert.throws(() => {
-                types.Hash256bit(buffer20byte);
-            }, /Expected Buffer\(Length: 32\), got Buffer\(Length: 20\)/);
-        });
-    });
-
-    describe('Satoshi', () => {
-        [
-            { value: -1, result: false },
-            { value: 0, result: true },
-            { value: 1, result: true },
-            { value: 20999999 * 1e8, result: true },
-            { value: 21000000 * 1e8, result: true },
-            { value: 21000001 * 1e8, result: false },
-        ].forEach(f => {
-            it('returns ' + f.result + ' for valid for ' + f.value, () => {
-                assert.strictEqual(types.Satoshi(f.value), f.result);
-            });
-        });
-    });
-});
+import assert from 'assert';
+import { describe, it } from 'mocha';
+import * as types from '../src/types.js';
+
+// @ts-ignore
+import typeforce from 'typeforce';
+
+describe('types', () => {
+    describe('Buffer Hash160/Hash256', () => {
+        const buffer20byte = Buffer.alloc(20);
+        const buffer32byte = Buffer.alloc(32);
+
+        it('return true for valid size', () => {
+            assert(types.Hash160bit(buffer20byte));
+            assert(types.Hash256bit(buffer32byte));
+        });
+
+        it('return true for oneOf', () => {
+            assert.doesNotThrow(() => {
+                typeforce(types.oneOf(types.Hash160bit, types.Hash256bit), buffer32byte);
+            });
+
+            assert.doesNotThrow(() => {
+                typeforce(types.oneOf(types.Hash256bit, types.Hash160bit), buffer32byte);
+            });
+        });
+
+        it('throws for invalid size', () => {
+            assert.throws(() => {
+                types.Hash160bit(buffer32byte);
+            }, /Expected Buffer\(Length: 20\), got Buffer\(Length: 32\)/);
+
+            assert.throws(() => {
+                types.Hash256bit(buffer20byte);
+            }, /Expected Buffer\(Length: 32\), got Buffer\(Length: 20\)/);
+        });
+    });
+
+    describe('Satoshi', () => {
+        [
+            { value: -1, result: false },
+            { value: 0, result: true },
+            { value: 1, result: true },
+            { value: 20999999 * 1e8, result: true },
+            { value: 21000000 * 1e8, result: true },
+            { value: 21000001 * 1e8, result: false },
+        ].forEach((f) => {
+            it('returns ' + f.result + ' for valid for ' + f.value, () => {
+                assert.strictEqual(types.Satoshi(f.value), f.result);
+            });
+        });
+    });
+});