Git Product home page Git Product logo

btcnodejs's People

Contributors

asmeikal avatar d0ze avatar dakk avatar dependabot[bot] avatar gdecicco avatar nikolai-b avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar

btcnodejs's Issues

Electrum segwit transactions

This might be the wrong place to ask but:

I have created an unsigned segwit transaction on electrum

010000000001016ce640462fb3302c40be33209eafb1c3088ebf6090a4c6d569bbaf3a2c72cb1d0000000000fdffffff02904d00000000000016001459a5efe7f6e80e338dd56c5f4f849f8464888eb2905f0100000000001976a91453c1d05822e2658fd2e1ce0c88184fd3234b081688acfeffffffffb0ad0100000000000201ff53ff045f1cf60122ac17c880000000f70edd475d43567f91ae697de230e82d45adb4b61cf40ad236882898a291ffb602c07ea35af414345f3c92edd9bb114438cc33d71598c64655c7c26318bd0b692b000000008a271400

Which Electrum deserialises as:

{
    "inputs": [
        {
            "address": "bc1qhk5ctz4tqgwshx3364uyuctvdh94ndavdtxv4h",
            "num_sig": 1,
            "prevout_hash": "1dcb722c3aafbb69d5c6a49060bf8e08c3b1af9e2033be402c30b32f4640e66c",
            "prevout_n": 0,
            "pubkeys": [
                "ff045f1cf60122ac17c880000000f70edd475d43567f91ae697de230e82d45adb4b61cf40ad236882898a291ffb602c07ea35af414345f3c92edd9bb114438cc33d71598c64655c7c26318bd0b692b00000000"
            ],
            "scriptSig": "",
            "sequence": 4294967293,
            "signatures": [
                null
            ],
            "type": "p2wpkh",
            "value": 110000,
            "witness": "0201ff53ff045f1cf60122ac17c880000000f70edd475d43567f91ae697de230e82d45adb4b61cf40ad236882898a291ffb602c07ea35af414345f3c92edd9bb114438cc33d71598c64655c7c26318bd0b692b00000000",
            "x_pubkeys": [
                "ff045f1cf60122ac17c880000000f70edd475d43567f91ae697de230e82d45adb4b61cf40ad236882898a291ffb602c07ea35af414345f3c92edd9bb114438cc33d71598c64655c7c26318bd0b692b00000000"
            ]
        }
    ],
    "lockTime": 1320842,
    "outputs": [
        {
            "address": "bc1qtxj7lelkaq8r8rw4d305lpyls3jg3r4jdd97n9",
            "prevout_n": 0,
            "scriptPubKey": "001459a5efe7f6e80e338dd56c5f4f849f8464888eb2",
            "type": 0,
            "value": 19856
        },
        {
            "address": "18dsGLx3Gk9oQakYkDUALkS5bEYjHjQz12",
            "prevout_n": 1,
            "scriptPubKey": "76a91453c1d05822e2658fd2e1ce0c88184fd3234b081688ac",
            "type": 0,
            "value": 90000
        }
    ],
    "version": 1
}

but this library finds that hex invalid.
If I comment out the deserialisation error (new Error("Incomplete tx deserialization"))
then btcnodejs produces a transaction similar with the the witness hex of

ffffffb0ad0100000000000201ff53ff045f1cf60122ac17c880000000f70edd475d43567f91ae697de230e82d45adb4b61cf40ad236882898a291ffb602c07ea35af414345f3c92edd9bb114438cc33d71598c64655c7c26318bd0b692b000000008a271400

I'm guessing this is because when Electrum deserialize the transaction it knows that the witness is not that long (yet). Have you any interest (or idea how) to deserialize partially signed electrum transactions?

For completeness the signed transaction hex is

010000000001016ce640462fb3302c40be33209eafb1c3088ebf6090a4c6d569bbaf3a2c72cb1d0000000000fdffffff02904d00000000000016001459a5efe7f6e80e338dd56c5f4f849f8464888eb2905f0100000000001976a91453c1d05822e2658fd2e1ce0c88184fd3234b081688ac02483045022100ebeb625c62d618c097fb1d54fef8bd3f57698bac191adca0a552725e4f577afc022001814513b04c272c5c86c4a37dd55700be543dc5732db5176dce377f954bd884012103f5b78846b3420430e455df568e4bee061827704c36163699544a0e60660fb7cb8a271400

And here then I can deserialize using btcnodejs and I get the correct witness hex:

btcnodejs witness hex:

3045022100ebeb625c62d618c097fb1d54fef8bd3f57698bac191adca0a552725e4f577afc022001814513b04c272c5c86c4a37dd55700be543dc5732db5176dce377f954bd8840103f5b78846b3420430e455df568e4bee061827704c36163699544a0e60660fb7cb

electrum witness hex is:

02483045022100ebeb625c62d618c097fb1d54fef8bd3f57698bac191adca0a552725e4f577afc022001814513b04c272c5c86c4a37dd55700be543dc5732db5176dce377f954bd884012103f5b78846b3420430e455df568e4bee061827704c36163699544a0e60660fb7cb

Here is the result of

btcnodejs.Transaction.fromHex("010000000001016ce640462fb3302c40be33209eafb1c3088ebf6090a4c6d569bbaf3a2c72cb1d0000000000fdffffff02904d00000000000016001459a5efe7f6e80e338dd56c5f4f849f8464888eb2905f0100000000001976a91453c1d05822e2658fd2e1ce0c88184fd3234b081688acfeffffffffb0ad0100000000000201ff53ff045f1cf60122ac17c880000000f70edd475d43567f91ae697de230e82d45adb4b61cf40ad236882898a291ffb602c07ea35af414345f3c92edd9bb114438cc33d71598c64655c7c26318bd0b692b000000008a271400")
Transaction {
  version: 1,
  inputs:
   [ Input {
       txid:
        '1dcb722c3aafbb69d5c6a49060bf8e08c3b1af9e2033be402c30b32f4640e66c',
       out: 0,
       scriptSig:
        ScriptSig {
          body:
           ByteBuffer {
             buffer: <Buffer >,
             offset: 0,
             markedOffset: -1,
             limit: 0,
             littleEndian: false,
             noAssert: true } },
       sequence: Sequence { n: 4294967293 },
       witness:
        Witness {
          data:
           [ ByteBuffer {
               buffer:
                <Buffer ff ff ff b0 ad 01 00 00 00 00 00 02 01 ff 53 ff 04 5f 1c f6 01 22 ac 17 c8 80 00 00 00 f7 0e dd 47 5d 43 56 7f 91 ae 69 7d e2 30 e8 2d 45 ad b4 b6 1c ... >,
               offset: 0,
               markedOffset: -1,
               limit: 102,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ByteBuffer {
               buffer: <Buffer >,
               offset: 0,
               markedOffset: -1,
               limit: 0,
               littleEndian: false,
               noAssert: true },
             ... 154 more items ] } } ],
  outputs:
   [ Output {
       amount: 19856,
       scriptPubKey:
        P2wpkhV0Script {
          body:
           ByteBuffer {
             buffer:
              <Buffer 00 14 59 a5 ef e7 f6 e8 0e 33 8d d5 6c 5f 4f 84 9f 84 64 88 8e b2>,
             offset: 22,
             markedOffset: -1,
             limit: 22,
             littleEndian: false,
             noAssert: false },
          type: 'p2wpkh',
          pubkeyhash:
           ByteBuffer {
             buffer:
              <Buffer 59 a5 ef e7 f6 e8 0e 33 8d d5 6c 5f 4f 84 9f 84 64 88 8e b2>,
             offset: 0,
             markedOffset: -1,
             limit: 20,
             littleEndian: false,
             noAssert: true } } },
     Output {
       amount: 90000,
       scriptPubKey:
        P2pkhScript {
          body:
           ByteBuffer {
             buffer:
              <Buffer 76 a9 14 53 c1 d0 58 22 e2 65 8f d2 e1 ce 0c 88 18 4f d3 23 4b 08 16 88 ac>,
             offset: 25,
             markedOffset: -1,
             limit: 25,
             littleEndian: false,
             noAssert: false },
          type: 'p2pkh',
          pubkeyhash:
           ByteBuffer {
             buffer:
              <Buffer 53 c1 d0 58 22 e2 65 8f d2 e1 ce 0c 88 18 4f d3 23 4b 08 16>,
             offset: 20,
             markedOffset: -1,
             limit: 20,
             littleEndian: false,
             noAssert: true } } } ],
  locktime: Locktime { n: 0 },
  segwit: true,
  txid:
   '0193744b17b8555ff32b4047912a4c4733b2cecd8547c411fe9e307927cf9b10' }

Segwit bc1 address

is there any simple method of creating bc1... public address from private key within btcnodejs ? If so could please anyone give me a little push since im new...

install trouble

when I use npm install btcnodejs

surely it pull done this node module, but I can not see any BIP39 file in 'lib' which is do have in github code.

Lodash sec vuln in 0.1.2

@d0ze Can you cut a new version of btcnodejs to master? Master does not have lodash security vuln AND is missing package-lock

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.