Adding fixture types... WIP

test/fixtureTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// aa

ts_test/address.ts

@@ -1,9 +1,10 @@
 import * as bitcoinjs from '..';
+import { FixtureAddress } from './fixtureTypes';
 const baddress = bitcoinjs.address;
 const bscript = bitcoinjs.script;
 const { describe, it } = require('mocha');
 const assert = require('assert');
-const fixtures = require('../ts_test/fixtures/address.json');
+const fixtures: FixtureAddress = require('../ts_test/fixtures/address.json');
 // @ts-ignore
 const NETWORKS = Object.assign(
   {
@@ -140,7 +141,7 @@ describe('address', () => {
     fixtures.invalid.toOutputScript.forEach(f => {
       it('throws when ' + f.exception, () => {
         assert.throws(() => {
-          baddress.toOutputScript(f.address, f.network);
+          baddress.toOutputScript(f.address, f.network as any);
         }, new RegExp(f.address + ' ' + f.exception));
       });
     });

ts_test/bitcoin.core.ts

@@ -1,16 +1,27 @@
 import * as bitcoin from '..';
+import {
+  CoreBase58Attributes,
+  CoreBase58EncodeDecode,
+  CoreBase58KeysInvalid,
+  CoreBase58KeysValid,
+  CoreBlocks,
+  CoreSigCanonical,
+  CoreSigHash,
+  CoreSigNonCanonical,
+  CoreTxValid,
+} from './fixtureTypes';
 const { describe, it } = require('mocha');
 const assert = require('assert');
 const base58 = require('bs58');
 
-const base58EncodeDecode = require('../ts_test/fixtures/core/base58_encode_decode.json');
+const base58EncodeDecode: CoreBase58EncodeDecode = require('../ts_test/fixtures/core/base58_encode_decode.json');
-const base58KeysInvalid = require('../ts_test/fixtures/core/base58_keys_invalid.json');
+const base58KeysInvalid: CoreBase58KeysInvalid = require('../ts_test/fixtures/core/base58_keys_invalid.json');
-const base58KeysValid = require('../ts_test/fixtures/core/base58_keys_valid.json');
+const base58KeysValid: CoreBase58KeysValid = require('../ts_test/fixtures/core/base58_keys_valid.json');
-const blocksValid = require('../ts_test/fixtures/core/blocks.json');
+const blocksValid: CoreBlocks = require('../ts_test/fixtures/core/blocks.json');
-const sigCanonical = require('../ts_test/fixtures/core/sig_canonical.json');
+const sigCanonical: CoreSigCanonical = require('../ts_test/fixtures/core/sig_canonical.json');
-const sigHash = require('../ts_test/fixtures/core/sighash.json');
+const sigHash: CoreSigHash = require('../ts_test/fixtures/core/sighash.json');
-const sigNoncanonical = require('../ts_test/fixtures/core/sig_noncanonical.json');
+const sigNoncanonical: CoreSigNonCanonical = require('../ts_test/fixtures/core/sig_noncanonical.json');
-const txValid = require('../ts_test/fixtures/core/tx_valid.json');
+const txValid: CoreTxValid = require('../ts_test/fixtures/core/tx_valid.json');
 
 describe('Bitcoin-core', () => {
   // base58EncodeDecode
@@ -44,8 +55,8 @@ describe('Bitcoin-core', () => {
 
     base58KeysValid.forEach(f => {
       const expected = f[0];
-      const hash = Buffer.from(f[1], 'hex');
+      const hash = Buffer.from(f[1] as string, 'hex');
-      const params = f[2];
+      const params = f[2] as CoreBase58Attributes;
 
       if (params.isPrivkey) return;
 
@@ -92,9 +103,9 @@ describe('Bitcoin-core', () => {
   // base58KeysValid
   describe('ECPair', () => {
     base58KeysValid.forEach(f => {
-      const string0 = f[0];
+      const string0 = f[0] as string;
       const hex = f[1];
-      const params = f[2];
+      const params = f[2] as CoreBase58Attributes;
 
       if (!params.isPrivkey) return;
 
@@ -154,13 +165,13 @@ describe('Bitcoin-core', () => {
       //      const verifyFlags = f[2] // TODO: do we need to test this?
 
       it('can decode ' + fhex, () => {
-        const transaction = bitcoin.Transaction.fromHex(fhex);
+        const transaction = bitcoin.Transaction.fromHex(fhex as string);
 
         transaction.ins.forEach((txIn, i) => {
           const input = inputs[i];
 
           // reverse because test data is reversed
-          const prevOutHash = Buffer.from(input[0], 'hex').reverse();
+          const prevOutHash = Buffer.from(input[0] as string, 'hex').reverse();
           const prevOutIndex = input[1];
 
           assert.deepStrictEqual(txIn.hash, prevOutHash);
@@ -178,10 +189,10 @@ describe('Bitcoin-core', () => {
       // Objects that are only a single string are ignored
       if (f.length === 1) return;
 
-      const txHex = f[0];
+      const txHex = f[0] as string;
-      const scriptHex = f[1];
+      const scriptHex = f[1] as string;
-      const inIndex = f[2];
+      const inIndex = f[2] as number;
-      const hashType = f[3];
+      const hashType = f[3] as number;
       const expectedHash = f[4];
 
       const hashTypes = [];

ts_test/block.ts

@@ -1,8 +1,9 @@
 import { Block } from '..';
+import { FixtureBlock } from './fixtureTypes';
 const { describe, it, beforeEach } = require('mocha');
 const assert = require('assert');
 
-const fixtures = require('../ts_test/fixtures/block');
+const fixtures: FixtureBlock = require('../ts_test/fixtures/block');
 
 describe('Block', () => {
   describe('version', () => {

ts_test/fixtureTypes.ts

@@ -0,0 +1,524 @@
+// fixtures/core folder
+export type CoreBase58EncodeDecode = [string[]];
+export type CoreBase58KeysInvalid = [string[]];
+export interface CoreBase58Attributes {
+  isPrivkey: boolean;
+  isTestnet: boolean;
+  isCompressed?: boolean;
+  addrType?: string;
+}
+export type CoreBase58KeysValid = [Array<string | CoreBase58Attributes>];
+export type CoreBlocks = [
+  {
+    id: string;
+    transactions: number;
+    hex: string;
+  }
+];
+export type CoreSigCanonical = string[];
+export type CoreSigNonCanonical = string[];
+export type CoreSigHash = [Array<string | number>];
+export type CoreTxValid = [string[] | Array<string | [Array<string | number>]>];
+
+// fixtures folder
+export interface FixtureAddress {
+  standard: Array<{
+    network: string;
+    version: number;
+    script: string;
+    hash?: string;
+    base58check?: string;
+    bech32?: string;
+    data?: string;
+  }>;
+  bech32: Array<{
+    bech32: string;
+    address: string;
+    version: number;
+    prefix: string;
+    data: string;
+  }>;
+  invalid: {
+    bech32: Array<{
+      version: number;
+      prefix: string;
+      data: string;
+      bech32: string;
+      address: string;
+      exception: string;
+    }>;
+    fromBase58Check: Array<{
+      address: string;
+      exception: string;
+    }>;
+    fromOutputScript: Array<{
+      exception: string;
+      script: string;
+    }>;
+    toOutputScript: Array<{
+      exception: string;
+      address: string;
+      network?: {
+        bech32: string;
+      };
+    }>;
+  };
+}
+export interface FixtureBlock {
+  targets: Array<{
+    bits: string;
+    expected: string;
+  }>;
+  valid: Array<{
+    description: string;
+    bits: number;
+    hash: string;
+    hex: string;
+    id: string;
+    merkleRoot: string;
+    nonce: number;
+    prevHash: string;
+    timestamp: number;
+    valid: boolean;
+    version: number;
+    height?: number;
+    witnessCommit?: string;
+  }>;
+  invalid: Array<{
+    exception: string;
+    hex: string;
+  }>;
+}
+export interface FixtureBufferUtils {
+  valid: Array<{
+    dec: number;
+    hex: string;
+  }>;
+  invalid: {
+    readUInt64LE: Array<{
+      description: string;
+      exception: string;
+      hex: string;
+      dec: number;
+    }>;
+  };
+}
+export type FixtureCrypto = Array<{
+  hex: string;
+  hash160: string;
+  hash256: string;
+  ripemd160: string;
+  sha1: string;
+  sha256: string;
+}>;
+export interface FixtureEcdsa {
+  valid: {
+    ecdsa: Array<{
+      d: string;
+      k: string;
+      message: string;
+      signature: {
+        r: string;
+        s: string;
+      };
+    }>;
+    rfc6979: Array<{
+      message: string;
+      d: string;
+      k0: string;
+      k1: string;
+      k15: string;
+    }>;
+  };
+  invalid: {
+    verify: Array<{
+      description: string;
+      d: string;
+      message: string;
+      signature: {
+        r: string;
+        s: string;
+      };
+    }>;
+  };
+}
+export interface FixtureECPair {
+  valid: Array<{
+    d: string;
+    Q: string;
+    compressed: boolean;
+    network: string;
+    address: string;
+    WIF: string;
+  }>;
+  invalid: {
+    fromPrivateKey: Array<{
+      exception: string;
+      d: string;
+      options?: {
+        network?: {};
+        compressed?: number;
+      };
+    }>;
+    fromPublicKey: Array<{
+      exception: string;
+      Q: string;
+      options: {
+        network?: {};
+      };
+      description?: string;
+    }>;
+    fromWIF: Array<{
+      exception: string;
+      WIF: string;
+      network?: string;
+    }>;
+  };
+}
+export interface FixtureEmbed {
+  valid: Array<{
+    description: string;
+    arguments: {
+      output?: string;
+      data?: string[];
+    };
+    options?: {};
+    expected: {
+      output: string;
+      data: string[];
+      input: null;
+      witness: null;
+    };
+  }>;
+  invalid: Array<{
+    exception: string;
+    arguments: {
+      output?: string;
+    };
+    description?: string;
+    options?: {};
+  }>;
+  dynamic: {
+    depends: {
+      data: string[];
+      output: string[];
+    };
+    details: Array<{
+      description: string;
+      data: string[];
+      output: string;
+    }>;
+  };
+}
+
+export type FixtureScriptNumber = [
+  {
+    hex: string;
+    number: number;
+    bytes?: number;
+  }
+];
+export interface FixtureScript {
+  valid: Array<{
+    asm: string;
+    script: string;
+    stack?: string[];
+    nonstandard?: {
+      scriptSig: string;
+      scriptSigHex: string;
+    };
+  }>;
+  invalid: {
+    decompile: Array<{
+      description: string;
+      script: string;
+    }>;
+    fromASM: Array<{
+      description: string;
+      script: string;
+    }>;
+  };
+}
+export interface FixtureSignature {
+  valid: Array<{
+    hex: string;
+    hashType: number;
+    raw: {
+      r: string;
+      s: string;
+    };
+  }>;
+  invalid: Array<{
+    exception: string;
+    hex: string;
+    hashType?: number;
+    raw?: {
+      r: string;
+      s: string;
+    };
+  }>;
+}
+export interface FixtureTemplates {
+  valid: Array<{
+    type: string;
+    typeIncomplete?: string;
+    pubKey?: string;
+    pubKeys?: string[];
+    data?: string[];
+    witnessScript?: string;
+    witnessData?: string[];
+    signature?: string;
+    signatures?: Array<string | null>;
+    redeemScript?: string;
+    redeemScriptSig?: string;
+    input?: string;
+    inputHex?: string;
+    output?: string;
+    outputHex?: string;
+    inputStack?: string[];
+    nonstandard?: {
+      input: string;
+      inputHex: string;
+    };
+  }>;
+  invalid: {
+    pubKey: {
+      inputs: Array<{
+        description: string;
+        input: string;
+      }>;
+      outputs: Array<{
+        description: string;
+        outputHex?: string;
+        output?: string;
+      }>;
+    };
+    pubKeyHash: {
+      inputs: Array<{
+        description: string;
+        input: string;
+      }>;
+      outputs: Array<{
+        description?: string;
+        outputHex?: string;
+        exception?: string;
+        hash?: string;
+      }>;
+    };
+    scriptHash: {
+      inputs: Array<{
+        description: string;
+        input: string;
+      }>;
+      outputs: Array<{
+        description?: string;
+        outputHex?: string;
+        exception?: string;
+        hash?: string;
+      }>;
+    };
+    multisig: {
+      inputs: Array<{
+        output: string;
+        signatures: string[];
+        exception?: string;
+        description?: string;
+        type?: string;
+      }>;
+      outputs: Array<{
+        description?: string;
+        output?: string;
+        exception?: string;
+        m?: number;
+        pubKeys?: string[];
+        signatures?: string[];
+      }>;
+    };
+    witnessPubKeyHash: {
+      inputs: [];
+      outputs: Array<{
+        description?: string;
+        outputHex?: string;
+        exception?: string;
+        hash?: string;
+      }>;
+    };
+    witnessScriptHash: {
+      inputs: [];
+      outputs: Array<{
+        description?: string;
+        outputHex?: string;
+        exception?: string;
+        hash?: string;
+      }>;
+    };
+    witnessCommitment: {
+      inputs: [];
+      outputs: Array<{
+        exception?: string;
+        commitment?: string;
+        description?: string;
+        scriptPubKeyHex?: string;
+      }>;
+    };
+  };
+}
+export interface FixtureTransactionBuilder {
+  valid: {
+    build: Array<{
+      description: string;
+      txHex: string;
+      version?: number | null;
+      locktime?: number;
+      network?: string;
+      incomplete?: boolean;
+      outputs: Array<{
+        script: string;
+        value: number;
+      }>;
+      inputs: Array<{
+        vout: number;
+        txHex?: string;
+        txId?: string;
+        sequence?: number;
+        prevTxScript?: string;
+        signs: Array<{
+          keyPair: string;
+          throws?: boolean;
+          value?: number;
+          witnessScript?: string;
+          redeemScript?: string;
+          network?: string;
+          hashType?: number;
+        }>;
+      }>;
+    }>;
+    fromTransaction: Array<{
+      description: string;
+      network: string;
+      incomplete?: boolean;
+      outputs: Array<{
+        script: string;
+        value: number;
+      }>;
+      inputs: Array<{
+        vout: number;
+        txHex?: string;
+        txId?: string;
+        prevTxScript?: string;
+        signs: Array<{
+          keyPair: string;
+          throws?: boolean;
+          value?: number;
+          witnessScript?: string;
+          redeemScript?: string;
+          network?: string;
+          hashType?: number;
+        }>;
+      }>;
+    }>;
+    fromTransactionSequential: Array<{
+      description: string;
+      network: string;
+      txHex: string;
+      txHexAfter: string;
+      version: number;
+      incomplete: boolean;
+      inputs: Array<{
+        vout: number;
+        scriptSig: string;
+        scriptSigAfter: string;
+        signs: Array<{
+          keyPair: string;
+          redeemScript?: string;
+        }>;
+      }>;
+    }>;
+    classification: {
+      hex: string;
+    };
+    multisig: Array<{
+      description: string;
+      network: string;
+      txHex: string;
+      version: number;
+      outputs: Array<{
+        script: string;
+        value: number;
+      }>;
+      inputs: Array<{
+        vout: number;
+        txHex?: string;
+        txId?: string;
+        prevTxScript?: string;
+        signs: Array<{
+          keyPair: string;
+          throws?: boolean;
+          value?: number;
+          witnessScript?: string;
+          redeemScript?: string;
+          network?: string;
+          hashType?: number;
+        }>;
+      }>;
+    }>;
+  };
+  invalid: {
+    build: Array<{
+      exception: string;
+      description?: string;
+      network?: string;
+      incomplete?: boolean;
+      txHex?: string;
+      outputs?: Array<{
+        script: string;
+        value: number;
+      }>;
+      inputs?: Array<{
+        vout: number;
+        txHex?: string;
+        txId?: string;
+        prevTxScript?: string;
+        signs: Array<{
+          keyPair: string;
+          throws?: boolean;
+          value?: number;
+          witnessScript?: string;
+          redeemScript?: string;
+          network?: string;
+          hashType?: number;
+        }>;
+      }>;
+    }>;
+    sign: Array<{
+      description?: string;
+      network?: string;
+      exception: string;
+      inputs: Array<{
+        vout: number;
+        txHex?: string;
+        txId?: string;
+        prevTxScript?: string;
+        signs: Array<{
+          keyPair: string;
+          throws?: boolean;
+          value?: number;
+          witnessScript?: string;
+          redeemScript?: string;
+          network?: string;
+          hashType?: number;
+        }>;
+      }>;
+      outputs: Array<{
+        script: string;
+        value: number;
+      }>;
+    }>;
+    fromTransaction: Array<{
+      exception: string;
+      txHex: string;
+    }>;
+  };
+}
+
+// aa