/* eslint-disable @typescript-eslint/ban-types */
// Type definitions for mvc 1.5.5
// Project: https://github.com/moneybutton/bsv
// Forked From: https://github.com/bitpay/bitcore-lib
// Definitions by: Lautaro Dragan <https://github.com/lautarodragan>
// Definitions extended by: David Case <https://github.com/shruggr>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

import BN_P = require('../bn.js')

/// <reference types="bn.js" />

export class Opcode {
  static OP_0: number
  static OP_PUSHDATA1: number
  static OP_PUSHDATA2: number
  static OP_PUSHDATA4: number
  static OP_1NEGATE: number
  static OP_RESERVED: number
  static OP_TRUE: number
  static OP_1: number
  static OP_2: number
  static OP_3: number
  static OP_4: number
  static OP_5: number
  static OP_6: number
  static OP_7: number
  static OP_8: number
  static OP_9: number
  static OP_10: number
  static OP_11: number
  static OP_12: number
  static OP_13: number
  static OP_14: number
  static OP_15: number
  static OP_16: number

  // control
  static OP_NOP: number
  static OP_VER: number
  static OP_IF: number
  static OP_NOTIF: number
  static OP_VERIF: number
  static OP_VERNOTIF: number
  static OP_ELSE: number
  static OP_ENDIF: number
  static OP_VERIFY: number
  static OP_RETURN: number

  // stack ops
  static OP_TOALTSTACK: number
  static OP_FROMALTSTACK: number
  static OP_2DROP: number
  static OP_2DUP: number
  static OP_3DUP: number
  static OP_2OVER: number
  static OP_2ROT: number
  static OP_2SWAP: number
  static OP_IFDUP: number
  static OP_DEPTH: number
  static OP_DROP: number
  static OP_DUP: number
  static OP_NIP: number
  static OP_OVER: number
  static OP_PICK: number
  static OP_ROLL: number
  static OP_ROT: number
  static OP_SWAP: number
  static OP_TUCK: number

  // splice ops
  static OP_CAT: number
  static OP_SPLIT: number
  static OP_NUM2BIN: number
  static OP_BIN2NUM: number
  static OP_SIZE: number

  // bit logic
  static OP_INVERT: number
  static OP_AND: number
  static OP_OR: number
  static OP_XOR: number
  static OP_EQUAL: number
  static OP_EQUALVERIFY: number
  static OP_RESERVED1: number
  static OP_RESERVED2: number

  // numeric
  static OP_1ADD: number
  static OP_1SUB: number
  static OP_2MUL: number
  static OP_2DIV: number
  static OP_NEGATE: number
  static OP_ABS: number
  static OP_NOT: number
  static OP_0NOTEQUAL: number

  static OP_ADD: number
  static OP_SUB: number
  static OP_MUL: number
  static OP_DIV: number
  static OP_MOD: number
  static OP_LSHIFT: number
  static OP_RSHIFT: number

  static OP_BOOLAND: number
  static OP_BOOLOR: number
  static OP_NUMEQUAL: number
  static OP_NUMEQUALVERIFY: number
  static OP_NUMNOTEQUAL: number
  static OP_LESSTHAN: number
  static OP_GREATERTHAN: number
  static OP_LESSTHANOREQUAL: number
  static OP_GREATERTHANOREQUAL: number
  static OP_MIN: number
  static OP_MAX: number

  static OP_WITHIN: number

  // crypto
  static OP_RIPEMD160: number
  static OP_SHA1: number
  static OP_SHA256: number
  static OP_HASH160: number
  static OP_HASH256: number
  static OP_CODESEPARATOR: number
  static OP_CHECKSIG: number
  static OP_CHECKSIGVERIFY: number
  static OP_CHECKMULTISIG: number
  static OP_CHECKMULTISIGVERIFY: number

  static OP_CHECKLOCKTIMEVERIFY: number
  static OP_CHECKSEQUENCEVERIFY: number

  // expansion
  static OP_NOP1: number
  static OP_NOP2: number
  static OP_NOP3: number
  static OP_NOP4: number
  static OP_NOP5: number
  static OP_NOP6: number
  static OP_NOP7: number
  static OP_NOP8: number
  static OP_NOP9: number
  static OP_NOP10: number

  // template matching params
  static OP_PUBKEYHASH: number
  static OP_PUBKEY: number
  static OP_INVALIDOPCODE: number
}

export namespace encoding {
  class Base58 {}
  class Base58Check {}
  class BufferReader {
    constructor(buf: Buffer)
    readUInt8(): number
    readUInt16BE(): number
    readUInt16LE(): number
    readUInt32BE(): number
    readUInt32LE(): number
    readInt32LE(): number
    readUInt64BEBN(): number
    readUInt64LEBN(): number
    readVarintNum(): number
    readVarLengthBuffer(): Buffer
    readVarintBuf(): Buffer
    readVarintBN(): crypto.BN
    reverse(): this
    readReverse(len: number): Buffer
  }
  class BufferWriter {
    writeUInt8(n: number): this
    writeUInt16BE(n: number): this
    writeUInt16LE(n: number): this
    writeUInt32BE(n: number): this
    writeUInt32LE(n: number): this
    writeInt32LE(n: number): this
    writeUInt64BEBN(n: number): this
    writeUInt64LEBN(n: number): this
    writeVarintNum(n: number): this
    writeVarintBN(n: crypto.BN): this
    writeReverse(buf: Buffer): this
    toBuffer(): Buffer
  }
  class Varint {}
}

export namespace crypto {
  interface IOpts {
    endian: 'big' | 'little'
    size?: number
  }

  class BN extends BN_P {
    static fromSM(buf: Buffer, opts?: IOpts): BN
    neg(): BN
    add(one: BN): BN
    toSM(opts?: IOpts): Buffer
    toNumber(): number
    static fromBuffer(buf: Buffer, opts?: IOpts): BN
    //toBuffer(opts?: IOpts): Buffer;
    static fromHex(hex: string, opts?: IOpts): BN
  }

  namespace ECDSA {
    function sign(message: Buffer, key: PrivateKey, endian?: string): Signature
    function verify(hashbuf: Buffer, sig: Signature, pubkey: PublicKey, endian?: 'little'): boolean
  }

  namespace Hash {
    function sha1(buffer: Buffer): Buffer
    function sha256(buffer: Buffer): Buffer
    function sha256sha256(buffer: Buffer): Buffer
    function sha256ripemd160(buffer: Buffer): Buffer
    function sha512(buffer: Buffer): Buffer
    function ripemd160(buffer: Buffer): Buffer

    function sha256hmac(data: Buffer, key: Buffer): Buffer
    function sha512hmac(data: Buffer, key: Buffer): Buffer
  }

  namespace Random {
    function getRandomBuffer(size: number): Buffer
  }

  class Point {
    static fromX(odd: boolean, x: crypto.BN | string): Point
    static getG(): any
    static getN(): crypto.BN
    getX(): crypto.BN
    getY(): crypto.BN
    validate(): this
    mul(n: crypto.BN): Point
  }

  class Signature {
    static fromDER(sig: Buffer): Signature
    static fromString(data: string): Signature
    static SIGHASH_ALL: number
    static SIGHASH_NONE: number
    static SIGHASH_SINGLE: number
    static SIGHASH_FORKID: number
    static SIGHASH_ANYONECANPAY: number
    r: BN
    s: BN
    nhashtype: number
    toString(): string
    toBuffer(): Buffer
    toDER(): Buffer
    isTxDER(buf: Buffer): boolean
    hasLowS(): boolean
    toTxFormat(): Buffer
    set(obj: { r?: BN; s?: BN; i?: number; compressed?: boolean; nhashtype?: number }): this
  }
}

export namespace Transaction {
  interface IUnspentOutput {
    address?: string
    txId: string
    outputIndex: number
    script: string
    satoshis: number
  }
  class UnspentOutput {
    static fromObject(o: IUnspentOutput): UnspentOutput
    constructor(data: IUnspentOutput)
    inspect(): string
    toObject(): IUnspentOutput
    toString(): string
  }

  class Output {
    readonly script: Script
    satoshis: number
    readonly satoshisBN: crypto.BN
    spentTxId: string | null
    constructor(data: object)

    setScript(script: Script | string | Buffer): this
    inspect(): string
    toObject(): object
    getSize(): number
    toBufferWriter(writer?: encoding.BufferWriter): encoding.BufferWriter
  }

  export namespace Input {
    class PublicKeyHash extends Input {
      /**
       * @param {Transaction} transaction - the transaction to be signed
       * @param {PrivateKey} privateKey - the private key with which to sign the transaction
       * @param {number} index - the index of the input in the transaction input vector
       * @param {number=} sigtype - the type of signature, defaults to Signature.SIGHASH_ALL
       * @param {Buffer=} hashData - the precalculated hash of the public key associated with the privateKey provided
       * @return {Array} of objects that can be
       */
      getSignatures(
        transaction: Transaction,
        privateKey: PrivateKey,
        index: number,
        sigtype: number,
        hashData: Buffer
      ): Signature[]
    }
  }

  class Input {
    prevTxId: Buffer
    readonly outputIndex: number
    readonly sequenceNumber: number
    readonly script: Script
    output?: Output
    constructor(params: object)
    isValidSignature(tx: Transaction, sig: any): boolean
    setScript(script: Script): this

    /**
     * Add the provided signature
     *
     * @param {Object} signature
     * @param {PublicKey} signature.publicKey
     * @param {Signature} signature.signature
     * @param {number=} signature.sigtype
     * @return {PublicKeyHashInput} this, for chaining
     */
    addSignature(transaction: Transaction, signature: Signature): this

    /**
     * Clear the input's signature
     * @return {PublicKeyHashInput} this, for chaining
     */
    clearSignatures(): this

    /**
     * Query whether the input is signed
     * @return {boolean}
     */
    isFullySigned(): boolean

    _estimateSize(): number
  }

  class Signature {
    constructor(arg: Signature | string | object)

    signature: crypto.Signature
    publicKey: PublicKey
    prevTxId: Buffer
    outputIndex: number
    inputIndex: number
    sigtype: number
  }

  namespace Sighash {
    function sighashPreimage(
      transaction: Transaction,
      sighashType: number,
      inputNumber: number,
      subscript: Script,
      satoshisBN: crypto.BN,
      flags?: number
    ): Buffer
    function sighash(
      transaction: Transaction,
      sighashType: number,
      inputNumber: number,
      subscript: Script,
      satoshisBN: crypto.BN,
      flags?: number
    ): Buffer
    function sign(
      transaction: Transaction,
      privateKey: PrivateKey,
      sighashType: number,
      inputIndex: number,
      subscript: Script,
      satoshisBN: crypto.BN,
      flags?: number
    ): crypto.Signature
    function verify(
      transaction: Transaction,
      signature: Signature,
      publicKey: PublicKey,
      inputIndex: number,
      subscript: Script,
      satoshisBN: crypto.BN,
      flags?: number
    ): boolean
  }
}

export class Transaction {
  static DUST_AMOUNT: number
  static CHANGE_OUTPUT_MAX_SIZE: number
  inputs: Transaction.Input[]
  outputs: Transaction.Output[]
  readonly id: string
  readonly hash: string
  readonly inputAmount: number
  readonly outputAmount: number
  nid: string
  nLockTime: number
  version: number

  //temporary
  _fee: number
  _outputAmount: number
  _changeIndex: number
  _removeOutput(index: number)

  constructor(serialized?: any)

  from(utxos: Transaction.IUnspentOutput | Transaction.IUnspentOutput[]): this
  to(address: Address[] | Address | string, amount: number): this
  change(address: Address | string): this
  fee(amount: number): this
  feePerKb(amount: number): this
  sign(privateKey: PrivateKey[] | string[] | PrivateKey | string): this
  applySignature(sig: crypto.Signature): this
  addInput(input: Transaction.Input, outputScript?: Script | string, satoshis?: number): this
  addOutput(output: Transaction.Output): this
  addData(value: Buffer | string): this
  lockUntilDate(time: Date | number): this
  lockUntilBlockHeight(height: number): this

  hasWitnesses(): boolean
  getFee(): number
  getChangeOutput(): Transaction.Output | null
  getLockTime(): Date | number

  verify(): string | boolean
  isCoinbase(): boolean

  enableRBF(): this
  isRBF(): boolean

  inspect(): string
  serialize(opts?: object | boolean): string
  uncheckedSerialize(): string

  toObject(): any
  toBuffer(): Buffer

  isFullySigned(): boolean

  getSerializationError(opts?: object): any

  _getUnspentValue(): number
  _estimateFee(): number
  _estimateSize(): number
}

export class ECIES {
  constructor(opts?: any, algorithm?: string)

  privateKey(privateKey: PrivateKey): ECIES
  publicKey(publicKey: PublicKey): ECIES
  encrypt(message: string | Buffer): Buffer
  decrypt(encbuf: Buffer): Buffer
}
export class Block {
  hash: string
  height: number
  transactions: Transaction[]
  header: {
    time: number
    prevHash: string
  }

  constructor(data: Buffer | object)
}

export class PrivateKey {
  constructor(key?: string | PrivateKey, network?: Networks.Type)

  readonly bn: crypto.BN

  readonly publicKey: PublicKey
  readonly compressed: boolean
  readonly network: Networks.Network

  toAddress(network: Networks.Type): Address
  toPublicKey(): PublicKey
  toString(): string
  toObject(): object
  toJSON(): object
  toWIF(): string
  toHex(): string
  toBigNumber(): any //BN;
  toBuffer(): Buffer
  inspect(): string

  static fromString(str: string): PrivateKey
  static fromWIF(str: string): PrivateKey
  static fromRandom(network?: string): PrivateKey
  static fromBuffer(buf: Buffer, network: string | Networks.Type): PrivateKey
  static fromHex(hex: string, network: string | Networks.Type): PrivateKey
  static getValidationError(data: string): any | null
  static isValid(data: string): boolean
}

export class PublicKey {
  constructor(source: string | PublicKey | crypto.Point, extra?: object)

  readonly point: crypto.Point
  readonly compressed: boolean
  readonly network: Networks.Network

  toDER(): Buffer
  toObject(): object
  toBuffer(): Buffer
  toAddress(network?: string | Networks.Type): Address
  toString(): string
  toHex(): string
  inspect(): string

  static fromPrivateKey(privateKey: PrivateKey): PublicKey
  static fromBuffer(buf: Buffer, strict?: boolean): PublicKey
  static fromDER(buf: Buffer, strict?: boolean): PublicKey
  //static fromPoint(point: Point, compressed: boolean): PublicKey;
  //static fromX(odd: boolean, x: Point): PublicKey;
  static fromString(str: string): PublicKey
  static fromHex(hex: string): PublicKey
  static getValidationError(data: string): any | null
  static isValid(data: string): boolean
}

export class Message {
  constructor(message: string | Buffer)

  readonly messageBuffer: Buffer

  sign(privateKey: PrivateKey): string
  verify(address: string | Address, signature: string): boolean
  toObject(): object
  toJSON(): string
  toString(): string
  inspect(): string

  static sign(message: string | Buffer, privateKey: PrivateKey): string
  static verify(message: string | Buffer, address: string | Address, signature: string): boolean
  static MAGIC_BYTES: Buffer
  static magicHash(): string
  static fromString(str: string): Message
  static fromJSON(json: string): Message
  static fromObject(obj: object): Message
}

export class Mnemonic {
  constructor(data: string | Array<string>, wordList?: Array<string>)

  readonly wordList: Array<string>
  readonly phrase: string

  toSeed(passphrase?: string): Buffer
  toHDPrivateKey(passphrase: string, network: string | number): HDPrivateKey
  toString(): string
  inspect(): string

  static fromRandom(wordlist?: Array<string>): Mnemonic
  static fromString(mnemonic: string, wordList?: Array<string>): Mnemonic
  static isValid(mnemonic: string, wordList?: Array<string>): boolean
  static fromSeed(seed: Buffer, wordlist: Array<string>): Mnemonic
}

export class HDPrivateKey {
  constructor(data?: string | Buffer | object)

  readonly hdPublicKey: HDPublicKey

  readonly xprivkey: Buffer
  readonly xpubkey: Buffer
  readonly network: Networks.Network
  readonly depth: number
  readonly privateKey: PrivateKey
  readonly publicKey: PublicKey
  readonly fingerPrint: Buffer

  derive(arg: string | number, hardened?: boolean): HDPrivateKey
  deriveChild(arg: string | number, hardened?: boolean): HDPrivateKey
  deriveNonCompliantChild(arg: string | number, hardened?: boolean): HDPrivateKey

  toString(): string
  toObject(): object
  toJSON(): object
  toBuffer(): Buffer
  toHex(): string
  inspect(): string

  static fromRandom(): HDPrivateKey
  static fromString(str: string): HDPrivateKey
  static fromObject(obj: object): HDPrivateKey
  static fromSeed(hexa: string | Buffer, network: string | Networks.Type): HDPrivateKey
  static fromBuffer(buf: Buffer): HDPrivateKey
  static fromHex(hex: string): HDPrivateKey
  static isValidPath(arg: string | number, hardened: boolean): boolean
  static isValidSerialized(data: string | Buffer, network?: string | Networks.Type): boolean
  static getSerializedError(data: string | Buffer, network?: string | Networks.Type): any | null
}

export class HDPublicKey {
  constructor(arg: string | Buffer | object)

  readonly xpubkey: Buffer
  readonly network: Networks.Network
  readonly depth: number
  readonly publicKey: PublicKey
  readonly fingerPrint: Buffer

  derive(arg: string | number, hardened?: boolean): HDPublicKey
  deriveChild(arg: string | number, hardened?: boolean): HDPublicKey

  toString(): string
  toObject(): object
  toJSON(): object
  toBuffer(): Buffer
  toHex(): string
  inspect(): string

  static fromString(str: string): HDPublicKey
  static fromObject(obj: object): HDPublicKey
  static fromBuffer(buf: Buffer): HDPublicKey
  static fromHex(hex: string): HDPublicKey

  static fromHDPrivateKey(hdPrivateKey: HDPrivateKey): HDPublicKey
  static isValidPath(arg: string | number): boolean
  static isValidSerialized(data: string | Buffer, network?: string | Networks.Type): boolean
  static getSerializedError(data: string | Buffer, network?: string | Networks.Type): any | null
}

export namespace Script {
  const types: {
    DATA_OUT: string
  }

  interface IOpChunk {
    buf: Buffer
    len: number
    opcodenum: number
  }

  function buildMultisigOut(publicKeys: PublicKey[], threshold: number, opts: object): Script
  function buildMultisigIn(
    pubkeys: PublicKey[],
    threshold: number,
    signatures: Buffer[],
    opts: object
  ): Script

  function buildPublicKeyHashOut(address: Address | PublicKey | string): Script
  function buildPublicKeyOut(pubkey: PublicKey): Script
  function buildDataOut(data: string | Buffer, encoding?: string): Script
  function buildSafeDataOut(data: (string | Buffer)[]): Script
  function buildScriptHashOut(script: Script): Script
  function buildPublicKeyIn(signature: crypto.Signature | Buffer, sigtype: number): Script
  function buildPublicKeyHashIn(
    publicKey: PublicKey,
    signature: crypto.Signature | Buffer,
    sigtype: number
  ): Script

  function fromAddress(address: string | Address): Script
  function fromASM(str: string): Script
  function fromHex(hex: string): Script
  function fromString(str: string): Script
  function fromBuffer(buf: Buffer): Script

  function empty(): Script

  namespace Interpreter {
    interface InterpretState {
      step: any
      mainstack: any
      altstack: any
    }
    type StepListenerFunction = (step: any, stack: any[], altstack: any[]) => void
  }

  export class Interpreter {
    static SCRIPT_ENABLE_MAGNETIC_OPCODES: number
    static SCRIPT_ENABLE_MONOLITH_OPCODES: number
    static SCRIPT_VERIFY_STRICTENC: number
    static SCRIPT_ENABLE_SIGHASH_FORKID: number
    static SCRIPT_VERIFY_LOW_S: number
    static SCRIPT_VERIFY_NULLFAIL: number
    static SCRIPT_VERIFY_DERSIG: number
    static SCRIPT_VERIFY_MINIMALDATA: number
    static SCRIPT_VERIFY_NULLDUMMY: number
    static SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS: number
    static SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY: number
    static SCRIPT_VERIFY_CHECKSEQUENCEVERIFY: number
    static MAX_SCRIPT_ELEMENT_SIZE: number
    static MAXIMUM_ELEMENT_SIZE: number
    stepListener?: Interpreter.StepListenerFunction
    errstr?: string
    verify: (
      inputScript: Script,
      outputScript: Script,
      txn: Transaction,
      nin: number,
      flags: any,
      satoshisBN: crypto.BN
    ) => boolean
  }
}

export class Script {
  constructor(data?: string | object)

  chunks: Array<Script.IOpChunk>

  set(obj: object): this

  toBuffer(): Buffer
  toASM(): string
  toString(): string
  toHex(): string

  isPublicKeyHashOut(): boolean
  isPublicKeyHashIn(): boolean

  getPublicKey(): Buffer
  getPublicKeyHash(): Buffer

  isPublicKeyOut(): boolean
  isPublicKeyIn(): boolean

  isScriptHashOut(): boolean
  isWitnessScriptHashOut(): boolean
  isWitnessPublicKeyHashOut(): boolean
  isWitnessProgram(): boolean
  isScriptHashIn(): boolean
  isMultisigOut(): boolean
  isMultisigIn(): boolean
  isDataOut(): boolean
  isSafeDataOut(): boolean

  getData(): Buffer
  isPushOnly(): boolean

  classify(): string
  classifyInput(): string
  classifyOutput(): string

  isStandard(): boolean

  prepend(obj: any): this
  add(obj: any): this

  hasCodeseparators(): boolean
  removeCodeseparators(): this

  equals(script: Script): boolean

  getAddressInfo(): Address | boolean
  findAndDelete(script: Script): this
  checkMinimalPush(i: number): boolean
  getSignatureOperationsCount(accurate: boolean): number

  toAddress(network?: string): Address
}

export namespace Networks {
  type Type = 'mainnet' | 'livenet' | 'testnet'

  interface Network {
    readonly name: string
    readonly alias: string
  }

  const livenet: Network
  const mainnet: Network
  const testnet: Network

  function add(data: any): Network
  function remove(network: Network): void
  function get(args: string | number | Network, keys: string | string[]): Network
}

export class Address {
  readonly hashBuffer: Buffer
  readonly network: Networks.Network
  readonly type: string

  constructor(
    data: Buffer | Uint8Array | string | object,
    network?: Networks.Type | string,
    type?: string
  )
  static fromString(address: string, network: Networks.Type): Address
  static fromPublicKey(data: PublicKey, network: Networks.Type): Address
  static fromPrivateKey(privateKey: PrivateKey, network: Networks.Type): Address
  static fromPublicKeyHash(hash: Buffer | Uint8Array, network: Networks.Type): Address
  static fromScriptHash(hash: Buffer | Uint8Array, network: Networks.Type): Address
  toBuffer(): Buffer
}

export class Unit {
  static fromBTC(amount: number): Unit
  static fromMilis(amount: number): Unit
  static fromBits(amount: number): Unit
  static fromSatoshis(amount: number): Unit

  constructor(amount: number, unitPreference: string)

  toBTC(): number
  toMilis(): number
  toBits(): number
  toSatoshis(): number
}

export namespace util {
  namespace preconditions {
    function checkState(condition: any, message: any)
    function checkArgument(condition: any, argumentName: string, message?: any, docsPath?: string)
    function checkArgumentType(argument, type, argumentName)
  }
}

export namespace deps {
  namespace _ {
    function isString(t: any): boolean
    function isNumber(t: any): boolean
  }
}