smartledger-bsv 3.3.5 → 3.4.4

package/lib/statuslist/index.js

@@ -0,0 +1,164 @@
+'use strict'
+
+/**
+ * StatusList2021 Module
+ * W3C StatusList2021 for credential revocation and suspension
+ */
+
+var vcjwt = require('../vcjwt')
+var crypto = require('crypto')
+
+// Create a new status list
+async function createStatusList(params) {
+  if (!params.issuerDid || !params.privateJwk) {
+    throw new Error('issuerDid and privateJwk are required')
+  }
+
+  var listId = params.listId || params.issuerDid + '/status/' + Date.now()
+  
+  // Create a bitstring for 100,000 credentials (default size)
+  var listSize = params.listSize || 100000
+  var byteSize = Math.ceil(listSize / 8)
+  var bitstringBuffer = Buffer.alloc(byteSize, 0)
+
+  // Compress with gzip
+  var zlib = require('zlib')
+  var compressed = zlib.gzipSync(bitstringBuffer)
+  var encodedCompressed = compressed.toString('base64')
+
+  // Create StatusList2021 credential
+  var statusListCredential = {
+    '@context': [
+      'https://www.w3.org/2018/credentials/v1',
+      'https://w3id.org/vc/status-list/2021/v1'
+    ],
+    type: ['VerifiableCredential', 'StatusList2021Credential'],
+    issuer: params.issuerDid,
+    issuanceDate: new Date().toISOString(),
+    credentialSubject: {
+      id: listId,
+      type: 'StatusList2021',
+      statusPurpose: 'revocation',
+      encodedList: encodedCompressed
+    }
+  }
+
+  // Issue as JWT
+  var result = await vcjwt.issueVcJwt({
+    issuerDid: params.issuerDid,
+    subjectId: listId,
+    types: ['VerifiableCredential', 'StatusList2021Credential'],
+    credentialSubject: statusListCredential.credentialSubject,
+    privateJwk: params.privateJwk,
+    alg: params.privateJwk.alg || 'ES256'
+  })
+
+  return {
+    listVcJwt: result.jwt,
+    listId: listId
+  }
+}
+
+// Update status list (revoke/suspend/activate)
+async function updateStatusList(params) {
+  if (!params.listVcJwt || params.index === undefined || !params.status || !params.privateJwk) {
+    throw new Error('listVcJwt, index, status, and privateJwk are required')
+  }
+
+  // Decode the existing status list JWT
+  var parts = params.listVcJwt.split('.')
+  if (parts.length !== 3) {
+    throw new Error('Invalid JWT format')
+  }
+
+  var payload = JSON.parse(vcjwt.base64UrlDecode(parts[1]).toString())
+  var encodedList = payload.vc.credentialSubject.encodedList
+
+  // Decompress
+  var zlib = require('zlib')
+  var compressed = Buffer.from(encodedList, 'base64')
+  var bitstring = zlib.gunzipSync(compressed)
+
+  // Update the bit at the given index
+  var byteIndex = Math.floor(params.index / 8)
+  var bitIndex = params.index % 8
+  
+  if (byteIndex >= bitstring.length) {
+    throw new Error('Index out of range')
+  }
+
+  // StatusList2021 uses 2 bits per credential for 4 states
+  // For simplicity, we'll use single bit: 0=valid, 1=revoked/suspended
+  var statusBit = (params.status === 'revoked' || params.status === 'suspended') ? 1 : 0
+  
+  if (statusBit === 1) {
+    bitstring[byteIndex] |= (1 << bitIndex)
+  } else {
+    bitstring[byteIndex] &= ~(1 << bitIndex)
+  }
+
+  // Recompress
+  var recompressed = zlib.gzipSync(bitstring)
+  var newEncodedList = recompressed.toString('base64')
+
+  // Create updated credential
+  var updatedCredentialSubject = {
+    id: payload.vc.credentialSubject.id,
+    type: 'StatusList2021',
+    statusPurpose: 'revocation',
+    encodedList: newEncodedList
+  }
+
+  // Re-issue as JWT
+  var result = await vcjwt.issueVcJwt({
+    issuerDid: payload.iss,
+    subjectId: payload.vc.credentialSubject.id,
+    types: ['VerifiableCredential', 'StatusList2021Credential'],
+    credentialSubject: updatedCredentialSubject,
+    privateJwk: params.privateJwk,
+    alg: params.privateJwk.alg || 'ES256'
+  })
+
+  return {
+    listVcJwt: result.jwt
+  }
+}
+
+// Get credential status entry
+function getCredentialStatusEntry(params) {
+  if (!params.listVcJwt || params.index === undefined) {
+    throw new Error('listVcJwt and index are required')
+  }
+
+  // Decode the status list JWT
+  var parts = params.listVcJwt.split('.')
+  if (parts.length !== 3) {
+    throw new Error('Invalid JWT format')
+  }
+
+  var payload = JSON.parse(vcjwt.base64UrlDecode(parts[1]).toString())
+  var encodedList = payload.vc.credentialSubject.encodedList
+
+  // Decompress
+  var zlib = require('zlib')
+  var compressed = Buffer.from(encodedList, 'base64')
+  var bitstring = zlib.gunzipSync(compressed)
+
+  // Check the bit at the given index
+  var byteIndex = Math.floor(params.index / 8)
+  var bitIndex = params.index % 8
+  
+  if (byteIndex >= bitstring.length) {
+    throw new Error('Index out of range')
+  }
+
+  var bit = (bitstring[byteIndex] >> bitIndex) & 1
+  
+  return bit === 1 ? 'revoked' : 'valid'
+}
+
+module.exports = {
+  createStatusList: createStatusList,
+  updateStatusList: updateStatusList,
+  getCredentialStatusEntry: getCredentialStatusEntry
+}

package/lib/transaction/transaction.js

@@ -577,7 +577,7 @@ Transaction.prototype._fromMultisigUtxo = function (utxo, pubkeys, threshold) {
   } else if (utxo.script.isScriptHashOut()) {
     Clazz = MultiSigScriptHashInput
   } else {
-    throw new Error('@TODO')
+    throw new errors.Transaction.Input.UnsupportedScript(utxo.script.toString())
   }
   this.addInput(new Clazz({
     output: new Output({
@@ -911,6 +911,13 @@ Transaction.prototype._getUnspentValue = function () {
 
 Transaction.prototype._clearSignatures = function () {
   _.each(this.inputs, function (input) {
+    // Custom-script inputs (bare Input base class — e.g. covenant or other
+    // non-standard locking scripts) have no library-managed signatures to
+    // clear; the caller owns input.script. Mirror the guard pattern used by
+    // Transaction.prototype.isFullySigned / isValidSignature below.
+    if (input.clearSignatures === Input.prototype.clearSignatures) {
+      return
+    }
     input.clearSignatures()
   })
 }

package/lib/util/_.js

@@ -1,5 +1,7 @@
 'use strict'
 
+var Random = require('../crypto/random')
+
 var _ = {}
 
 _.isArray = t => Array.isArray(t)
@@ -28,10 +30,14 @@ _.values = o => Object.values(o)
 _.filter = (a, f) => a.filter(f)
 _.reduce = (a, f, s) => a.reduce(f, s)
 _.without = (a, n) => a.filter(t => t !== n)
+// CSPRNG-backed Fisher-Yates. Output-order shuffling is a privacy primitive
+// (Transaction.shuffleOutputs); a predictable PRNG defeats the purpose.
 _.shuffle = a => {
   const result = a.slice(0)
   for (let i = result.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
+    const buf = Random.getRandomBuffer(4)
+    const r = buf.readUInt32BE(0) / 0x100000000
+    const j = Math.floor(r * (i + 1));
     [result[i], result[j]] = [result[j], result[i]]
   }
   return result

package/lib/vcjwt/index.js

@@ -0,0 +1,189 @@
+'use strict'
+
+/**
+ * VC-JWT Module
+ * W3C Verifiable Credentials using JWT/JWS
+ * Supports ES256 (P-256) and ES256K (secp256k1)
+ */
+
+var crypto = require('crypto')
+
+// Base64URL encoding
+function base64UrlEncode(buffer) {
+  return buffer.toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=/g, '')
+}
+
+// Base64URL decoding
+function base64UrlDecode(str) {
+  str = str.replace(/-/g, '+').replace(/_/g, '/')
+  while (str.length % 4) {
+    str += '='
+  }
+  return Buffer.from(str, 'base64')
+}
+
+// Issue a Verifiable Credential as JWT
+async function issueVcJwt(params) {
+  if (!params.issuerDid || !params.subjectId || !params.credentialSubject || !params.privateJwk) {
+    throw new Error('issuerDid, subjectId, credentialSubject, and privateJwk are required')
+  }
+
+  var alg = params.alg || 'ES256'
+  var kid = params.kid || params.privateJwk.kid
+  var types = params.types || ['VerifiableCredential']
+  var expSeconds = params.expSeconds || (365 * 24 * 60 * 60) // 1 year default
+
+  var now = Math.floor(Date.now() / 1000)
+  var issuedAt = new Date().toISOString()
+
+  // Build VC payload
+  var vcPayload = {
+    '@context': [
+      'https://www.w3.org/2018/credentials/v1'
+    ],
+    type: types,
+    issuer: params.issuerDid,
+    issuanceDate: issuedAt,
+    credentialSubject: Object.assign({
+      id: params.subjectId
+    }, params.credentialSubject)
+  }
+
+  // Build JWT claims
+  var jwtPayload = {
+    iss: params.issuerDid,
+    sub: params.subjectId,
+    iat: now,
+    exp: now + expSeconds,
+    vc: vcPayload
+  }
+
+  // Build JWT header
+  var header = {
+    alg: alg,
+    typ: 'JWT',
+    kid: kid
+  }
+
+  // Encode header and payload
+  var headerB64 = base64UrlEncode(Buffer.from(JSON.stringify(header)))
+  var payloadB64 = base64UrlEncode(Buffer.from(JSON.stringify(jwtPayload)))
+  var signingInput = headerB64 + '.' + payloadB64
+
+  // Sign with private key
+  var privateKey = crypto.createPrivateKey({
+    key: params.privateJwk,
+    format: 'jwk'
+  })
+
+  var signature
+  if (alg === 'ES256') {
+    signature = crypto.sign('sha256', Buffer.from(signingInput), privateKey)
+  } else if (alg === 'ES256K') {
+    signature = crypto.sign('sha256', Buffer.from(signingInput), privateKey)
+  } else {
+    throw new Error('Unsupported algorithm: ' + alg)
+  }
+
+  var signatureB64 = base64UrlEncode(signature)
+  var jwt = signingInput + '.' + signatureB64
+
+  return { jwt: jwt }
+}
+
+// Verify a VC-JWT
+async function verifyVcJwt(jwt, opts) {
+  opts = opts || {}
+
+  try {
+    // Parse JWT
+    var parts = jwt.split('.')
+    if (parts.length !== 3) {
+      return { valid: false, error: 'Invalid JWT format' }
+    }
+
+    var headerB64 = parts[0]
+    var payloadB64 = parts[1]
+    var signatureB64 = parts[2]
+
+    var header = JSON.parse(base64UrlDecode(headerB64).toString())
+    var payload = JSON.parse(base64UrlDecode(payloadB64).toString())
+    var signature = base64UrlDecode(signatureB64)
+
+    // Check expiration
+    var now = Math.floor(Date.now() / 1000)
+    var clockTolerance = opts.clockToleranceSec || 60
+    
+    if (payload.exp && payload.exp < (now - clockTolerance)) {
+      return { valid: false, error: 'JWT expired', header: header, payload: payload }
+    }
+
+    // Check issuer if expected
+    if (opts.expectedIssuerDid && payload.iss !== opts.expectedIssuerDid) {
+      return { valid: false, error: 'Unexpected issuer', header: header, payload: payload }
+    }
+
+    // Get public key from DID resolver or use default resolver
+    var publicKey
+    if (opts.didResolver) {
+      var resolved = await opts.didResolver(payload.iss)
+      if (!resolved || !resolved.jwks || !resolved.jwks.keys) {
+        return { valid: false, error: 'Failed to resolve issuer DID', header: header, payload: payload }
+      }
+      
+      // Find matching key by kid
+      var matchingKey = resolved.jwks.keys.find(function(k) {
+        return k.kid === header.kid
+      })
+      
+      if (!matchingKey) {
+        return { valid: false, error: 'Key not found in JWKS', header: header, payload: payload }
+      }
+      
+      publicKey = matchingKey
+    } else {
+      // Without resolver, verification cannot proceed
+      return { valid: false, error: 'DID resolver required for verification', header: header, payload: payload }
+    }
+
+    // Verify signature
+    var signingInput = headerB64 + '.' + payloadB64
+    var pubKey = crypto.createPublicKey({
+      key: publicKey,
+      format: 'jwk'
+    })
+
+    var isValid = crypto.verify(
+      'sha256',
+      Buffer.from(signingInput),
+      pubKey,
+      signature
+    )
+
+    if (!isValid) {
+      return { valid: false, error: 'Invalid signature', header: header, payload: payload }
+    }
+
+    return {
+      valid: true,
+      header: header,
+      payload: payload
+    }
+
+  } catch (error) {
+    return {
+      valid: false,
+      error: error.message || 'Verification failed'
+    }
+  }
+}
+
+module.exports = {
+  issueVcJwt: issueVcJwt,
+  verifyVcJwt: verifyVcJwt,
+  base64UrlEncode: base64UrlEncode,
+  base64UrlDecode: base64UrlDecode
+}

package/ltp-entry.js

@@ -1,2 +1 @@
-// LTP module placeholder - will be implemented in future release
-module.exports = require('./lib/smart_contract');
+module.exports = require('./lib/ltp')

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "smartledger-bsv",
-  "version": "3.3.5",
-  "description": "🚀 Complete Bitcoin SV development framework with Legal Token Protocol (LTP), Global Digital Attestation Framework (GDAF), Shamir Secret Sharing, and 12 flexible loading options. Includes primitives-only architecture for maximum integration flexibility, SmartContract framework, covenant builder, and comprehensive Bitcoin SV API. Perfect for legal tokens, DeFi, smart contracts, and secure Bitcoin applications.",
+  "version": "3.4.4",
+  "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",
   "bugs": {
     "url": "https://github.com/codenlighten/smartledger-bsv/issues"
   },
   "main": "index.js",
+  "types": "bsv.d.ts",
+  "bin": {
+    "smartledger-bsv": "./bin/cli.js"
+  },
   "scripts": {
     "lint": "standard",
     "test": "mocha",
+    "test:cli": "mocha test/cli/smoke.js --timeout 25000",
     "test:ltp": "node complete_ltp_demo.js",
     "test:ltp-primitives": "node simple_demo.js",
     "test:architecture": "node architecture_demo.js",
@@ -46,15 +51,20 @@
     "build-covenant": "NODE_OPTIONS=\"--openssl-legacy-provider\" webpack covenant-entry.js --config build/webpack.covenant.config.js",
     "build-script-helper": "NODE_OPTIONS=\"--openssl-legacy-provider\" webpack script-helper-entry.js --config build/webpack.script-helper.config.js",
     "build-security": "NODE_OPTIONS=\"--openssl-legacy-provider\" webpack security-entry.js --config build/webpack.security.config.js",
+    "build-didweb": "NODE_OPTIONS=\"--openssl-legacy-provider\" webpack didweb-entry.js --config build/webpack.didweb.config.js",
+    "build-vcjwt": "NODE_OPTIONS=\"--openssl-legacy-provider\" webpack vcjwt-entry.js --config build/webpack.vcjwt.config.js",
+    "build-statuslist": "NODE_OPTIONS=\"--openssl-legacy-provider\" webpack statuslist-entry.js --config build/webpack.statuslist.config.js",
+    "build-anchor": "NODE_OPTIONS=\"--openssl-legacy-provider\" webpack anchor-entry.js --config build/webpack.anchor.config.js",
     "build-bundle": "NODE_OPTIONS=\"--openssl-legacy-provider\" webpack bundle-entry.js --config build/webpack.bundle.config.js",
     "build": "npm run build-bsv && npm run build-ecies && npm run build-message && npm run build-mnemonic && npm run build-shamir && npm run build-smartcontract",
     "build-specialized": "npm run build-covenant && npm run build-script-helper && npm run build-security",
+    "build-credentials": "npm run build-didweb && npm run build-vcjwt && npm run build-statuslist && npm run build-anchor",
     "build-advanced": "npm run build-ltp && npm run build-gdaf",
-    "build-all": "npm run build && npm run build-bundle && npm run build-specialized && npm run build-advanced",
+    "build-all": "npm run build && npm run build-bundle && npm run build-specialized && npm run build-advanced && npm run build-credentials",
     "test:browser": "echo 'Open tests/standalone-modules-test.html in browser for comprehensive testing'",
     "test:bundle": "echo 'Open tests/bundle-completeness-test.html in browser to verify bundle completeness'",
     "preimage:extract": "node examples/preimage/extract_preimage_bidirectional.js",
-    "prepublishOnly": "NODE_OPTIONS=\"--openssl-legacy-provider\" npm run build"
+    "prepublishOnly": "NODE_OPTIONS=\"--openssl-legacy-provider\" npm run build-all"
   },
   "unpkg": "bsv.min.js",
   "jsdelivr": "bsv.min.js",
@@ -62,12 +72,13 @@
   "files": [
     "index.js",
     "lib/",
-    "utilities/",
+    "utilities/*.js",
+    "utilities/README.md",
+    "utilities/wallet.json",
     "ecies/",
     "message/",
     "mnemonic/",
     "build/",
-    "tests/",
     "*-entry.js",
     "bsv.min.js",
     "bsv.bundle.js",
@@ -81,17 +92,12 @@
     "bsv-covenant.min.js",
     "bsv-script-helper.min.js",
     "bsv-security.min.js",
+    "bsv-didweb.min.js",
+    "bsv-vcjwt.min.js",
+    "bsv-statuslist.min.js",
+    "bsv-anchor.min.js",
     "bsv.d.ts",
-    "validation_test.js",
-    "test_shamir.js",
-    "shamir_demo.js",
-    "complete_ltp_demo.js",
-    "simple_demo.js",
-    "architecture_demo.js",
-    "test_standalone_shamir.html",
     "docs/",
-    "demos/",
-    "examples/",
     "LICENSE",
     "README.md",
     "SECURITY.md",

package/statuslist-entry.js

@@ -0,0 +1 @@
+module.exports = require('./lib/statuslist')

package/utilities/blockchain-state.js

@@ -5,6 +5,15 @@
  * Acts as the "blockchain database" for our miner simulator.
  */
 
+// Set BSV_DEBUG=1 (Node) or window.BSV_DEBUG = true (browser) to surface
+// info/warning narration from this module. Matches the gating pattern
+// used by lib/browser-utxo-manager-es5.js since v3.4.1.
+const debug = function () {
+  const enabled = (typeof process !== 'undefined' && process.env && process.env.BSV_DEBUG) ||
+                  (typeof window !== 'undefined' && window.BSV_DEBUG)
+  if (enabled) console.log.apply(console, arguments)
+}
+
 // Browser-compatible imports
 let bsv, fs, path, BLOCKCHAIN_STATE_PATH
 
@@ -16,7 +25,7 @@ if (typeof window === 'undefined' && typeof require === 'function') {
     path = require('path')
     BLOCKCHAIN_STATE_PATH = path.join(__dirname, 'blockchain-state.json')
   } catch (e) {
-    console.warn('BlockchainState: Running in browser mode - persistence disabled')
+    debug('BlockchainState: Running in browser mode - persistence disabled')
   }
 } else {
   // In browser, try to get bsv from global scope or fallback
@@ -54,14 +63,14 @@ function loadBlockchainState () {
     }
 
     if (!fs.existsSync(BLOCKCHAIN_STATE_PATH)) {
-      console.log('🆕 Creating new blockchain state...')
+      debug('🆕 Creating new blockchain state...')
       const initialState = initializeBlockchainState()
       saveBlockchainState(initialState)
       return initialState
     }
 
     const state = JSON.parse(fs.readFileSync(BLOCKCHAIN_STATE_PATH, 'utf8'))
-    console.log('📖 Loaded existing blockchain state')
+    debug('📖 Loaded existing blockchain state')
     return state
   } catch (error) {
     console.error('❌ Error loading blockchain state:', error.message)
@@ -79,7 +88,7 @@ function saveBlockchainState (state) {
     // Only save to file in Node.js environment
     if (fs && BLOCKCHAIN_STATE_PATH) {
       fs.writeFileSync(BLOCKCHAIN_STATE_PATH, JSON.stringify(state, null, 2))
-      console.log('💾 Blockchain state saved')
+      debug('💾 Blockchain state saved')
     }
   } catch (error) {
     console.error('❌ Error saving blockchain state:', error.message)
@@ -90,12 +99,12 @@ function saveBlockchainState (state) {
  * Register a new wallet in the blockchain state
  */
 function registerWallet (walletAddress, walletData) {
-  console.log(`📝 Registering wallet: ${walletAddress}`)
+  debug(`📝 Registering wallet: ${walletAddress}`)
 
   const state = loadBlockchainState()
 
   if (state.wallets[walletAddress]) {
-    console.log('ℹ️  Wallet already exists, updating...')
+    debug('ℹ️  Wallet already exists, updating...')
   }
 
   state.wallets[walletAddress] = {
@@ -122,7 +131,7 @@ function registerWallet (walletAddress, walletData) {
 
   saveBlockchainState(state)
 
-  console.log(`✅ Wallet registered: ${walletAddress}`)
+  debug(`✅ Wallet registered: ${walletAddress}`)
   return state
 }
 
@@ -185,7 +194,7 @@ function spendUTXO (txid, vout, spentInTx) {
 
   updateBlockchainMetadata(state)
   saveBlockchainState(state)
-  console.log(`❌ UTXO spent: ${utxoKey} in tx ${spentInTx}`)
+  debug(`❌ UTXO spent: ${utxoKey} in tx ${spentInTx}`)
 }
 
 /**
@@ -197,7 +206,7 @@ function addUTXO (utxo, ownerAddress) {
 
   // Check if UTXO already exists
   if (state.globalUTXOSet[utxoKey]) {
-    console.log(`⚠️ UTXO ${utxoKey} already exists, skipping`)
+    debug(`⚠️ UTXO ${utxoKey} already exists, skipping`)
     return
   }
 
@@ -229,7 +238,7 @@ function addUTXO (utxo, ownerAddress) {
   updateBlockchainMetadata(state)
   saveBlockchainState(state)
 
-  console.log(`✅ UTXO added: ${utxoKey} for ${ownerAddress}`)
+  debug(`✅ UTXO added: ${utxoKey} for ${ownerAddress}`)
 }
 
 /**
@@ -255,18 +264,18 @@ function updateBlockchainMetadata (state) {
 function getBlockchainStats () {
   const state = loadBlockchainState()
 
-  console.log('🌐 Blockchain State Statistics:')
-  console.log('═══════════════════════════════════════════')
-  console.log(`📊 Total Wallets: ${state.metadata.totalWallets}`)
-  console.log(`💰 Total UTXOs: ${state.metadata.totalUTXOs}`)
-  console.log(`💎 Total Value: ${state.metadata.totalValue} satoshis`)
-  console.log(`🏗️  Block Height: ${state.metadata.blockHeight}`)
-  console.log(`🕐 Last Updated: ${state.metadata.lastUpdated}\n`)
+  debug('🌐 Blockchain State Statistics:')
+  debug('═══════════════════════════════════════════')
+  debug(`📊 Total Wallets: ${state.metadata.totalWallets}`)
+  debug(`💰 Total UTXOs: ${state.metadata.totalUTXOs}`)
+  debug(`💎 Total Value: ${state.metadata.totalValue} satoshis`)
+  debug(`🏗️  Block Height: ${state.metadata.blockHeight}`)
+  debug(`🕐 Last Updated: ${state.metadata.lastUpdated}\n`)
 
   if (Object.keys(state.wallets).length > 0) {
-    console.log('👛 Registered Wallets:')
+    debug('👛 Registered Wallets:')
     Object.entries(state.wallets).forEach(([address, wallet]) => {
-      console.log(`  ${address}: ${wallet.utxos.length} UTXOs, ${wallet.totalValue} sats`)
+      debug(`  ${address}: ${wallet.utxos.length} UTXOs, ${wallet.totalValue} sats`)
     })
   }
 
@@ -280,14 +289,14 @@ function importWalletFromFile () {
   const walletPath = path.join(__dirname, 'wallet.json')
 
   if (!fs.existsSync(walletPath)) {
-    console.log('❌ No wallet.json found to import')
+    debug('❌ No wallet.json found to import')
     return false
   }
 
   try {
     const walletData = JSON.parse(fs.readFileSync(walletPath, 'utf8'))
 
-    console.log('📥 Importing wallet from wallet.json...')
+    debug('📥 Importing wallet from wallet.json...')
 
     const walletInfo = {
       registeredAt: new Date().toISOString(),
@@ -296,7 +305,7 @@ function importWalletFromFile () {
 
     registerWallet(walletData.wallet.address, walletInfo)
 
-    console.log('✅ Wallet imported successfully')
+    debug('✅ Wallet imported successfully')
     return true
   } catch (error) {
     console.error('❌ Error importing wallet:', error.message)
@@ -313,7 +322,7 @@ if (require.main === module) {
   } else if (args[0] === 'init') {
     const state = initializeBlockchainState()
     saveBlockchainState(state)
-    console.log('🆕 Initialized new blockchain state')
+    debug('🆕 Initialized new blockchain state')
   }
 
   getBlockchainStats()

package/vcjwt-entry.js

@@ -0,0 +1 @@
+module.exports = require('./lib/vcjwt')