@smartledger/bsv 7.13.0 → 8.0.1

package/lib/transaction/sighash.js

@@ -168,15 +168,27 @@ var sighashPreimage = function sighashPreimage (transaction, sighashType, inputN
   // only took effect when FORKID was absent could never select OTDA in practice, and
   // the flag would mean nothing.
   //
-  // Gated on SCRIPT_ENABLE_CHRONICLE, which is off by default: before the upgrade the
-  // 0x20 bit means nothing, so BIP-143 signatures already exist whose type byte happens
-  // to set it. Honouring it unconditionally would reinterpret those as OTDA.
+  // Routed on the bit alone, not on whether Chronicle is enabled, which is what
+  // the node does:
+  //
+  //   if(enabledSighashForkid && sigHashType.hasForkId() && !sigHashType.hasChronicle())
+  //       return SignatureHashBIP143(...);
+  //   return SignatureHashOriginal(...);
+  //
+  // The concern that made this gated is real — before the upgrade the 0x20 bit
+  // meant nothing, so BIP-143 signatures exist whose type byte happens to set
+  // it, and reinterpreting those as OTDA would be a disaster. The node answers
+  // it in a different place: CheckSignatureEncoding rejects a signature
+  // carrying the bit outside Chronicle as SCRIPT_ERR_ILLEGAL_CHRONICLE, so
+  // such a signature never reaches this function. Gating here instead made 260
+  // of the node's 1000 digest vectors disagree, because the digest for a given
+  // transaction and hash type then depends on a flag the node does not consult.
   //
   // Note the sighash type byte is committed INSIDE the preimage either way, so setting
   // this bit changes the digest even where it does not change the algorithm.
-  if ((sighashType & Signature.SIGHASH_CHRONICLE) && (flags & Interpreter.SCRIPT_ENABLE_CHRONICLE)) {
-    // fall through to the original algorithm
-  } else if ((sighashType & Signature.SIGHASH_FORKID) && (flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID)) {
+  if ((sighashType & Signature.SIGHASH_FORKID) &&
+      !(sighashType & Signature.SIGHASH_CHRONICLE) &&
+      (flags & Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID)) {
     return sighashPreimageForForkId(txcopy, sighashType, inputNumber, subscript, satoshisBN)
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartledger/bsv",
-  "version": "7.13.0",
+  "version": "8.0.1",
   "description": "🚀 Complete Bitcoin SV development framework with legally-recognizable DID:web + W3C VC-JWT toolkit, Legal Token Protocol (LTP), Global Digital Attestation Framework (GDAF), StatusList2021 revocation, and 16 flexible loading options. Standards-based credentials with ES256/ES256K support, on-chain BSV anchoring, and comprehensive Bitcoin SV API. Perfect for legal tokens, verifiable credentials, DeFi, smart contracts, and secure Bitcoin applications.",
   "author": "SmartLedger Technology <hello@smartledger.technology> (https://smartledger.technology)",
   "homepage": "https://github.com/codenlighten/smartledger-bsv#readme",
@@ -60,6 +60,9 @@
     "lint": "standard",
     "check:load-order": "node scripts/check-address-load-order.js",
     "conformance": "node conformance/verify.js",
+    "vectors:sv": "node tools/sv-vector-report.js",
+    "vectors:sv-tx": "node tools/sv-tx-report.js",
+    "vectors:sv-sighash": "node tools/sv-sighash-report.js",
     "conformance:generate": "node conformance/generate.js",
     "lint:ratchet": "node scripts/lint-ratchet.js",
     "lint:ratchet:update": "node scripts/lint-ratchet.js --update",

package/test/consensus/base58-vectors.js

@@ -0,0 +1,120 @@
+'use strict'
+
+/**
+ * Base58 and Base58Check vectors from SV Node v1.2.0.
+ *
+ * `base58_encode_decode.json` had no counterpart in the inherited bitcoind
+ * corpus and nothing else here exercises it. It is small, but it is the only
+ * place the raw codec is pinned against the node in both directions, and it
+ * carries the two cases an implementation gets wrong: the empty input, and
+ * leading zero bytes, which base58 encodes as leading '1's rather than as part
+ * of a number.
+ *
+ * The key vectors are content-identical to the bitcoind copies that
+ * test/address.js and test/privatekey.js already use — same 50 rows, different
+ * whitespace. They are run here against the SV copies regardless, so that the
+ * corpus under test/data/bitcoin-sv is the one this library is measured
+ * against. That directory is the declared specification, and re-copying it
+ * from a newer node tag should move these tests with it.
+ */
+
+require('chai').should()
+const bsv = require('../..')
+const Base58 = bsv.encoding.Base58
+const Base58Check = bsv.encoding.Base58Check
+const Address = bsv.Address
+const PrivateKey = bsv.PrivateKey
+
+const encodeDecode = require('../data/bitcoin-sv/base58_encode_decode.json')
+const keysValid = require('../data/bitcoin-sv/base58_keys_valid.json')
+const keysInvalid = require('../data/bitcoin-sv/base58_keys_invalid.json')
+
+describe('base58 vectors (SV Node v1.2.0)', function () {
+  describe('the raw codec', function () {
+    it('encodes every vector to the recorded string', function () {
+      encodeDecode.forEach(function (v, i) {
+        Base58.encode(Buffer.from(v[0], 'hex'))
+          .should.equal(v[1], 'encoding row ' + i + ' (' + v[0] + ')')
+      })
+    })
+
+    it('decodes every vector back to the recorded bytes', function () {
+      encodeDecode.forEach(function (v, i) {
+        Base58.decode(v[1]).toString('hex')
+          .should.equal(v[0], 'decoding row ' + i + ' (' + JSON.stringify(v[1]) + ')')
+      })
+    })
+
+    it('keeps leading zero bytes as leading ones', function () {
+      // Ten zero bytes encode as ten '1's. An implementation that treats the
+      // input purely as a number loses them, and every address starting 1
+      // depends on this.
+      Base58.encode(Buffer.alloc(10)).should.equal('1111111111')
+      Base58.decode('1111111111').should.deep.equal(Buffer.alloc(10))
+    })
+
+    it('round-trips the empty input', function () {
+      Base58.encode(Buffer.alloc(0)).should.equal('')
+      Base58.decode('').length.should.equal(0)
+    })
+  })
+
+  describe('keys and addresses', function () {
+    it('accepts every valid key vector', function () {
+      let addresses = 0
+      let privkeys = 0
+      keysValid.forEach(function (v, i) {
+        const str = v[0]
+        const meta = v[2]
+        if (meta.isPrivkey) {
+          const key = PrivateKey.fromWIF(str)
+          key.toWIF().should.equal(str, 'WIF round trip at ' + i)
+          privkeys++
+        } else {
+          const network = meta.isTestnet ? 'testnet' : 'livenet'
+          const address = Address.fromString(str, network)
+          address.toString().should.equal(str, 'address round trip at ' + i)
+          address.hashBuffer.toString('hex')
+            .should.equal(v[1], 'hash at ' + i)
+          address.type.should.equal(
+            meta.addrType === 'script' ? Address.PayToScriptHash : Address.PayToPublicKeyHash,
+            'type at ' + i)
+          addresses++
+        }
+      })
+      // Both kinds must actually have been reached.
+      addresses.should.be.above(0)
+      privkeys.should.be.above(0)
+    })
+
+    it('rejects every invalid key vector, as neither address nor key', function () {
+      // The claim these vectors make is that the string is not a valid address
+      // and not a valid WIF — not that it fails Base58Check. Several of them
+      // carry a perfectly good checksum and are simply the wrong length or
+      // version, so the checksum layer accepts them and the layer above is
+      // what has to refuse. Asserting the stronger thing would be asserting
+      // something the corpus does not say.
+      let checksumOk = 0
+      keysInvalid.forEach(function (v, i) {
+        const str = v[0]
+        Address.isValid(str).should.equal(false, 'Address accepted row ' + i)
+
+        let isKey = true
+        try {
+          PrivateKey.fromWIF(str)
+        } catch (e) {
+          isKey = false
+        }
+        isKey.should.equal(false, 'PrivateKey accepted row ' + i)
+
+        try {
+          Base58Check.decode(str)
+          checksumOk++
+        } catch (e) { /* a bad checksum is one way to be invalid, not the only one */ }
+      })
+      // Guards the reasoning above: if none of them had a valid checksum, this
+      // test would be weaker than it looks and Base58Check could be asserted.
+      checksumOk.should.be.above(0)
+    })
+  })
+})

package/test/consensus/sv-script-vectors.js

@@ -0,0 +1,81 @@
+'use strict'
+
+/**
+ * Consensus ratchet over the SV Node script vectors.
+ *
+ * A report tells you where you are; this stops you going backwards. Both read
+ * the same harness, so the progress figure and the gate cannot disagree.
+ *
+ * False accepts are held at zero outright rather than through an allowlist,
+ * because accepting a script the network rejects is the direction that can
+ * cost money. False rejects are held at zero too — the corpus passes
+ * completely, so there is nothing to exempt and no list to maintain.
+ */
+
+require('chai').should()
+const harness = require('../../tools/sv-vector-harness')
+
+describe('SV Node script vectors', function () {
+  this.timeout(120000)
+
+  let results = null
+
+  before(function () {
+    results = harness.runAll()
+  })
+
+  it('runs the whole corpus', function () {
+    results.length.should.equal(1483)
+  })
+
+  it('uses no flag the harness does not recognise', function () {
+    // An unrecognised flag means vectors run under the wrong rules, and any
+    // pass among them means nothing.
+    const unknown = new Set()
+    results.forEach(r => r.unknownFlags.forEach(f => unknown.add(f)))
+    Array.from(unknown).should.deep.equal([])
+  })
+
+  it('accepts nothing the node rejects', function () {
+    const accepts = results.filter(r => r.direction === 'accept')
+    const detail = accepts.map(r =>
+      '\n  ' + r.id + '  ' + r.reason + '\n      ' + harness.describe(r.row)).join('')
+    accepts.length.should.equal(0, 'false accepts must stay at zero:' + detail)
+  })
+
+  it('rejects nothing the node accepts', function () {
+    const rejects = results.filter(r => r.direction === 'reject')
+    const detail = rejects.map(r =>
+      '\n  ' + r.id + '  ' + r.reason + '\n      ' + harness.describe(r.row)).join('')
+    rejects.length.should.equal(0, 'false rejects must stay at zero:' + detail)
+  })
+
+  it('fails for the reason the node gives', function () {
+    // Matching the outcome is not the same as matching the reason, and the gap
+    // hid three real bugs — see ERROR_CODE_ALIASES in the harness. Each left
+    // the script failing, so the two tests above stayed green throughout.
+    const wrong = results.filter(r => r.codeMatches === false)
+    const detail = wrong.map(r =>
+      '\n  ' + r.id + '  expected ' + r.expectedCode + ', reported ' + r.gotCode +
+      '\n      ' + harness.describe(r.row)).join('')
+    wrong.length.should.equal(0,
+      wrong.length + ' vector(s) fail for the wrong reason:' + detail)
+  })
+
+  it('compares a code on every vector the node rejects', function () {
+    // Guards the test above: if `comparable` ever narrowed, it would pass by
+    // checking nothing.
+    const rejected = results.filter(r => r.row.expected !== 'OK' && r.passed)
+    rejected.length.should.equal(600)
+    rejected.every(r => r.codeMatches !== null).should.equal(true)
+  })
+
+  it('uses every alias it grants', function () {
+    // The ratchet's other direction. An alias no vector produces any more is
+    // an exemption outliving its reason, and should be deleted rather than
+    // left to cover something later.
+    const produced = new Set(results.filter(r => r.gotCode).map(r => r.gotCode))
+    const unused = Object.keys(harness.ERROR_CODE_ALIASES).filter(a => !produced.has(a))
+    unused.should.deep.equal([], 'alias(es) no vector produces; remove them')
+  })
+})

package/test/consensus/sv-sighash-vectors.js

@@ -0,0 +1,51 @@
+'use strict'
+
+/**
+ * Transaction digest vectors from SV Node v1.2.0 — the regression gate.
+ *
+ * The work is in tools/sv-sighash-harness.js, which npm run vectors:sv-sighash
+ * also uses, so the progress report and this gate cannot disagree about what
+ * passes. That file documents the corpus layout and the node's routing.
+ *
+ * Unlike the script and transaction vectors, this one carries no known-failure
+ * list. It has never had a failing row and there is no reason it should: a
+ * digest is a pure function of a transaction and a hash type, with no era to
+ * negotiate.
+ */
+
+require('chai').should()
+const harness = require('../../tools/sv-sighash-harness')
+
+describe('SV Node sighash vectors', function () {
+  this.timeout(120000)
+
+  const results = harness.runAll()
+
+  it('covers the whole corpus', function () {
+    results.length.should.equal(1000)
+  })
+
+  it('matches the node on both digest columns', function () {
+    const failures = results.filter(r => !r.passed)
+      .map(r => '#' + r.index + ' ' + r.reason)
+    failures.slice(0, 8).should.deep.equal([],
+      failures.length + ' of ' + results.length + ' rows disagree with the node')
+  })
+
+  it('routes every Chronicle-bit row to the original digest', function () {
+    // Stated separately so a routing regression reads as one rather than as
+    // hundreds of unexplained hash mismatches.
+    const withBit = harness.chronicleRows()
+    withBit.length.should.equal(511)
+    withBit.forEach(v => v[4].should.equal(v[5]))
+    results.filter(r => r.chronicleBit)
+      .forEach(r => r.algorithm.should.equal('OTDA'))
+  })
+
+  it('still exercises both algorithms', function () {
+    // Guards the test above: if the routing collapsed to OTDA everywhere it
+    // would pass, and this is what would notice.
+    results.filter(r => r.algorithm === 'BIP143').length.should.be.above(0)
+    results.filter(r => r.algorithm === 'OTDA').length.should.be.above(0)
+  })
+})

package/test/consensus/sv-tx-vectors.js

@@ -0,0 +1,48 @@
+'use strict'
+
+/**
+ * Consensus ratchet over the SV Node transaction vectors.
+ *
+ * These reach a level the script corpus cannot. A script vector evaluates one
+ * unlocking script against one locking script; these deserialise a whole
+ * transaction, resolve each input against the output it claims to spend, and
+ * require every one to verify, with locktimes and sequence numbers in play.
+ *
+ * That level earned itself immediately: it found that Genesis reverts
+ * OP_CHECKLOCKTIMEVERIFY and OP_CHECKSEQUENCEVERIFY to upgradable NOPs, which
+ * this library did not implement and no script vector can reach — the
+ * behaviour only appears once a real nLockTime and sequence number exist.
+ */
+
+require('chai').should()
+const harness = require('../../tools/sv-tx-harness')
+
+describe('SV Node transaction vectors', function () {
+  this.timeout(120000)
+
+  let results = null
+
+  before(function () {
+    results = harness.runAll()
+  })
+
+  it('runs both files', function () {
+    results.length.should.equal(161)
+    results.filter(r => r.expected).length.should.equal(93)
+    results.filter(r => !r.expected).length.should.equal(68)
+  })
+
+  it('accepts no transaction the node rejects', function () {
+    const accepts = results.filter(r => r.direction === 'accept')
+    const detail = accepts.map(r =>
+      '\n  ' + r.id + '  ' + r.reason + '\n      ' + harness.describe(r)).join('')
+    accepts.length.should.equal(0, 'false accepts must stay at zero:' + detail)
+  })
+
+  it('rejects no transaction the node accepts', function () {
+    const rejects = results.filter(r => r.direction === 'reject')
+    const detail = rejects.map(r =>
+      '\n  ' + r.id + '  ' + r.reason + '\n      ' + harness.describe(r)).join('')
+    rejects.length.should.equal(0, 'false rejects must stay at zero:' + detail)
+  })
+})

package/test/data/bitcoin-sv/README.md

@@ -0,0 +1,170 @@
+# SV Node consensus vectors
+
+Consensus test vectors copied verbatim from the reference node implementation.
+These are the specification this library is measured against — do not hand-edit
+them. To update, re-copy from a node tag and record the new provenance here.
+
+| field | value |
+| --- | --- |
+| source | [`bitcoin-sv/bitcoin-sv`](https://github.com/bitcoin-sv/bitcoin-sv) `src/test/data` |
+| tag | `v1.2.0` (Chronicle); byte-identical in `v1.2.2`, the current release |
+| commit | `60dc6a3f2547eeaaa3a605e5a69a9fc8686b0a25` |
+| retrieved | 2026-08-11 |
+| licence | MIT (same as this library) |
+
+Genesis activated at block **620,538** on **2020-02-04**; Chronicle at block
+**943,816** on **2026-04-07**.
+
+## Files
+
+| file | rows run | covers | gate |
+| --- | --- | --- | --- |
+| `script_tests.json` | 1483 | script evaluation, including Genesis and Chronicle rules | `test/consensus/sv-script-vectors.js` |
+| `sighash.json` | 1000 | transaction digest algorithm | `test/consensus/sv-sighash-vectors.js` |
+| `tx_valid.json` | 93 | transactions that must validate | `test/consensus/sv-tx-vectors.js` |
+| `tx_invalid.json` | 68 | transactions that must be rejected | `test/consensus/sv-tx-vectors.js` |
+| `base58_keys_valid.json` | 50 | address and WIF encoding | `test/consensus/base58-vectors.js` |
+| `base58_keys_invalid.json` | 50 | malformed address rejection | `test/consensus/base58-vectors.js` |
+| `base58_encode_decode.json` | 12 | raw base58 round-trips | `test/consensus/base58-vectors.js` |
+
+Every one of these is exercised, and every one passes completely. There is no
+known-failure list and nothing is exempted, so any list added later should read
+as a decision someone made rather than as inherited debt.
+
+These supersede the older pre-Genesis vectors in `test/data/bitcoind`, which are
+inherited from the upstream fork and encode consensus rules the network
+abandoned in 2020. Those are retained for now so the two can be diffed, but
+they are **not** a valid consensus reference. Where they disagree with these,
+these win.
+
+## Measuring the gap
+
+    npm run vectors:sv                  # script vectors
+    npm run vectors:sv-tx               # transaction vectors
+    npm run vectors:sv-sighash          # transaction digest vectors
+
+Each takes `-- --verbose` for the full failing list. Every report shares its
+harness with the corresponding gate under `test/consensus`, so the progress
+figure and the regression gate cannot disagree about what passes.
+
+The script and transaction reports separate the two directions of failure. A
+**false accept** — accepting a script the node rejects — is the direction that
+can cost money, and is held at zero outright. A false reject only costs a
+transaction. The digest report makes no such distinction: a wrong digest is
+equally bad either way, since it both makes valid signatures unverifiable and
+signs something other than what the caller was shown.
+
+## Row layout, and two columns that are easy to get wrong
+
+Defined by `script_json_test` in the node's `src/test/script_tests.cpp`:
+
+    [ [nValue]?, txnVersion, scriptSig, scriptPubKey, flags, expected, comment? ]
+
+- **`nValue`** is present only when a row needs an input amount, and it is
+  wrapped in an **array**. It states whole coins; the transaction carries
+  satoshis, so multiply by 1e8 (the node's `AmountFromValue`).
+- **`txnVersion`** is the *spending* transaction's version, and is present on
+  every row. Chronicle gates its malleability relaxations on version > 1, so
+  this column is consensus-relevant — it is not padding, and it is not an
+  amount. Mistaking it for one changes the crediting transaction's value, which
+  changes its txid, which changes the sighash, which silently breaks every
+  signature-checking vector in the corpus.
+
+The crediting transaction is always version 1; only the spending transaction
+carries the version under test. Both use locktime 0 and a final sequence, and
+the crediting input's scriptSig is `OP_0 OP_0`.
+
+## Flags, and one place this fork differs
+
+Flags are mapped by **name**, never by value. This library assigns
+`MONOLITH_OPCODES` and `MAGNETIC_OPCODES` to bits `1<<18` and `1<<19`, which
+are the bits the node uses for `SCRIPT_GENESIS` and `SCRIPT_UTXO_AFTER_GENESIS`
+— mapping by value would quietly run vectors under the wrong rules while
+appearing to pass.
+
+The corpus never names `MONOLITH` or `MAGNETIC`, because the node has no such
+flags: those opcodes were restored on BSV in 2018 and are simply enabled. This
+library still gates them, so the harness enables them for every row; otherwise
+the report would be dominated by that one difference rather than by consensus.
+The gating is itself a divergence from BSV and is worth removing. It is
+compensated for here rather than hidden, so that the figures mean what they
+say.
+
+## Transaction vectors
+
+`tx_valid.json` and `tx_invalid.json` go a level above the script corpus: a
+whole transaction is deserialised, each input resolved against the output it
+claims to spend, and every one required to verify — with locktimes, sequence
+numbers and multiple inputs in play.
+
+That level is worth having. It found a Genesis rule the script corpus cannot
+reach: `OP_CHECKLOCKTIMEVERIFY` and `OP_CHECKSEQUENCEVERIFY` revert to
+upgradable NOPs after Genesis, and without that, four transactions the network
+accepts were being rejected. The behaviour only appears once a real nLockTime
+and sequence exist, so no single-script vector exercises it.
+
+## Digest vectors
+
+Each row of `sighash.json` carries **two** expected digests for the same inputs
+— one with forkid enabled and one without — which pins the routing in
+`SignatureHash()` rather than one branch of it.
+
+That second column earned its keep. It found 260 rows where this library
+honoured `SIGHASH_CHRONICLE` only when `SCRIPT_ENABLE_CHRONICLE` was also set,
+where the node routes on the bit alone and instead rejects a signature carrying
+that bit outside Chronicle in `CheckSignatureEncoding`, as
+`SCRIPT_ERR_ILLEGAL_CHRONICLE`. Rejected, not reinterpreted.
+
+For a row whose hash type sets `0x20`, both columns are identical — the
+original algorithm is taken either way. 511 of the 1000 rows are of that kind,
+so a gate checking only one column would be blind to half the corpus.
+
+## Base58
+
+The key vectors are content-identical to the bitcoind copies already used by
+`test/address.js` and `test/privatekey.js` — same 50 rows, different whitespace
+— but `base58_encode_decode.json` has no counterpart there, and nothing else
+pins the raw codec against the node in both directions.
+
+Note what the invalid-key vectors actually claim: that a string is neither a
+valid address nor a valid WIF. Several carry a perfectly good checksum and are
+simply the wrong length or version, so `Base58Check` accepts them and the layer
+above is what refuses. A test asserting the checksum layer rejects them would
+be asserting something the corpus does not say.
+
+## Result codes
+
+Matching the node's accept/reject outcome is not the same as failing for the
+node's *reason*, and the gap between the two is where bugs live. Comparing the
+result code of all 600 rejected vectors found four, each of which left the
+script failing — so the outcome check stayed green through every one:
+
+- a div-by-zero guard comparing a `BN` against the number `0`, so it never
+  fired and bn.js asserted instead
+- script number decoding throwing past the evaluator into a generic catch,
+  which is what 78 of the four hundred were
+- a truncated `PUSHDATA` doing the same
+- `OP_NUM2BIN` checking only the upper bound of its size argument, so a
+  negative size reported the wrong failure
+
+All 600 now match: 491 exactly, and 109 through `ERROR_CODE_ALIASES` in
+`tools/sv-vector-harness.js` — names this library reports more narrowly than
+the node, such as `EVAL_FALSE_IN_STACK` for `EVAL_FALSE`. That table is a short
+statement of intent rather than a list of exempted vectors, and it ratchets
+both ways: an unlisted mismatch fails, and so does an alias no vector produces
+any more, so an exemption cannot outlive its reason. Anything added to it
+should be a name that says *more* than the node's, never a different failure
+wearing its label.
+
+## What the vectors cannot reach
+
+Passing this corpus completely is not the same as matching the node. Reading
+the code alongside it found `OP_CAT` capping its result at the static 520-byte
+element size rather than the era-derived one, so after Genesis it rejected
+concatenations the network accepts — built from two 300-byte halves that are
+each legal on their own. It is the one opcode that can grow an element past the
+cap without ever pushing an oversized element, which is why no vector here
+covers it. `test/script/genesis_limits.js` holds it instead.
+
+Where a rule has no vector, the test that holds it belongs somewhere that says
+so.

package/test/data/bitcoin-sv/base58_encode_decode.json

@@ -0,0 +1,14 @@
+[
+["", ""],
+["61", "2g"],
+["626262", "a3gV"],
+["636363", "aPEr"],
+["73696d706c792061206c6f6e6720737472696e67", "2cFupjhnEsSn59qHXstmK2ffpLv2"],
+["00eb15231dfceb60925886b67d065299925915aeb172c06647", "1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L"],
+["516b6fcd0f", "ABnLTmg"],
+["bf4f89001e670274dd", "3SEo3LWLoPntC"],
+["572e4794", "3EFU7m"],
+["ecac89cad93923c02321", "EJDM8drfXA6uyA"],
+["10c8511e", "Rt5zm"],
+["00000000000000000000", "1111111111"]
+]