smartledger-bsv 3.2.1 → 3.3.1

package/gdaf-entry.js

@@ -0,0 +1,54 @@
+'use strict'
+
+/**
+ * GDAF (Global Digital Attestation Framework) Standalone Bundle
+ * 
+ * Entry point for creating standalone distribution of the Global Digital
+ * Attestation Framework. This module can be built with webpack to create
+ * a standalone bundle for browser use.
+ */
+
+// Core BSV dependencies for GDAF
+var PublicKey = require('./lib/publickey')
+var PrivateKey = require('./lib/privatekey')
+var Address = require('./lib/address')
+var Transaction = require('./lib/transaction')
+var Script = require('./lib/script')
+var Hash = require('./lib/crypto/hash')
+var ECDSA = require('./lib/crypto/ecdsa')
+var Signature = require('./lib/crypto/signature')
+
+// GDAF modules
+var GDAF = require('./lib/gdaf')
+
+// Create minimal BSV context for GDAF
+var bsvContext = {
+  PublicKey: PublicKey,
+  PrivateKey: PrivateKey,
+  Address: Address,
+  Transaction: Transaction,
+  Script: Script,
+  crypto: {
+    Hash: Hash,
+    ECDSA: ECDSA,
+    Signature: Signature
+  }
+}
+
+// Export GDAF with BSV context
+module.exports = {
+  GDAF: GDAF,
+  bsv: bsvContext,
+  
+  // Direct access to GDAF classes for convenience
+  DIDResolver: require('./lib/gdaf/did-resolver'),
+  AttestationSigner: require('./lib/gdaf/attestation-signer'),
+  AttestationVerifier: require('./lib/gdaf/attestation-verifier'),
+  ZKProver: require('./lib/gdaf/zk-prover'),
+  SmartLedgerAnchor: require('./lib/gdaf/smartledger-anchor'),
+  SchemaValidator: require('./lib/gdaf/schema-validator'),
+  
+  // Utility functions
+  version: '1.0.0',
+  description: 'SmartLedger BSV Global Digital Attestation Framework'
+}

package/index.js

@@ -48,6 +48,7 @@ bsv.crypto.Hash = require('./lib/crypto/hash')
 bsv.crypto.Random = require('./lib/crypto/random')
 bsv.crypto.Point = require('./lib/crypto/point')
 bsv.crypto.Signature = require('./lib/crypto/signature')
+bsv.crypto.Shamir = require('./lib/crypto/shamir')
 
 // SmartLedger security enhancements
 bsv.crypto.SmartVerify = require('./lib/crypto/smartledger_verify')
@@ -82,8 +83,14 @@ bsv.PrivateKey = require('./lib/privatekey')
 bsv.PublicKey = require('./lib/publickey')
 bsv.Script = require('./lib/script')
 bsv.Transaction = require('./lib/transaction')
+bsv.Input = require('./lib/transaction').Input
+bsv.Output = require('./lib/transaction').Output
+bsv.UnspentOutput = require('./lib/transaction').UnspentOutput
 bsv.Message = require('./lib/message')
+bsv.Mnemonic = require('./lib/mnemonic')
+bsv.ECIES = require('./lib/ecies')
 bsv.Signature = require('./lib/crypto/signature')
+bsv.Shamir = require('./lib/crypto/shamir')
 
 // SmartLedger security modules (top-level access)
 bsv.SmartLedger = {
@@ -97,19 +104,279 @@ bsv.SmartLedger = {
 bsv.SmartVerify = require('./lib/crypto/smartledger_verify')
 bsv.EllipticFixed = require('./lib/crypto/elliptic-fixed')
 
-// SmartLedger Development & Testing Tools (Node.js only)
+// SmartLedger Development & Testing Tools
+try {
+  // SmartContract Framework - now available in both Node.js and browser
+  bsv.SmartContract = require('./lib/smart_contract')
+} catch (e) {
+  // SmartContract not available - use standalone bsv-smartcontract.min.js
+  if (typeof window === 'undefined') {
+    console.warn('SmartContract module not available:', e.message)
+  }
+}
+
+// Node.js specific tools (advanced development tools)
 if (typeof window === 'undefined' && typeof require === 'function') {
   try {
     bsv.SmartUTXO = require('./lib/smartutxo')
     bsv.SmartMiner = require('./lib/smartminer')
     bsv.CustomScriptHelper = require('./lib/custom-script-helper')
-    
-    // Smart Contract Framework
-    bsv.SmartContract = require('./lib/smart_contract')
   } catch (e) {
-    // Browser environment - these tools not available
+    // Advanced tools not available
   }
 }
 
+// Global Digital Attestation Framework (GDAF)
+bsv.GDAF = require('./lib/gdaf')
+
+// GDAF Direct Access Methods (for easier developer experience)
+bsv.createDID = function(publicKey) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.createDID(publicKey)
+}
+
+bsv.resolveDID = function(did) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.resolveDID(did)
+}
+
+bsv.createEmailCredential = function(issuerDID, subjectDID, email, issuerPrivateKey) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.createEmailCredential(issuerDID, subjectDID, email, issuerPrivateKey)
+}
+
+bsv.createAgeCredential = function(issuerDID, subjectDID, ageThreshold, birthDate, issuerPrivateKey) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.createAgeCredential(issuerDID, subjectDID, ageThreshold, birthDate, issuerPrivateKey)
+}
+
+bsv.createKYCCredential = function(issuerDID, subjectDID, level, piiHashes, issuerPrivateKey) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.createKYCCredential(issuerDID, subjectDID, level, piiHashes, issuerPrivateKey)
+}
+
+bsv.verifyCredential = function(credential, options) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.verifyCredential(credential, options)
+}
+
+bsv.validateCredential = function(credential, schema) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.validateCredential(credential, schema)
+}
+
+bsv.generateSelectiveProof = function(credential, revealedFields, nonce) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.generateSelectiveProof(credential, revealedFields, nonce)
+}
+
+bsv.generateAgeProof = function(ageCredential, minimumAge, nonce) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.generateAgeProof(ageCredential, minimumAge, nonce)
+}
+
+bsv.verifyAgeProof = function(proof, minimumAge, issuerDID) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.verifyAgeProof(proof, minimumAge, issuerDID)
+}
+
+bsv.createPresentation = function(credentials, holderDID, holderPrivateKey, options) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.createPresentation(credentials, holderDID, holderPrivateKey, options)
+}
+
+bsv.getCredentialSchemas = function() {
+  var gdaf = new bsv.GDAF()
+  return gdaf.getAllSchemas()
+}
+
+bsv.createCredentialTemplate = function(credentialType) {
+  var gdaf = new bsv.GDAF()
+  return gdaf.createTemplate(credentialType)
+}
+
+// Legal Token Protocol (LTP) - Primitives-Only Interface
+bsv.LTP = require('./lib/ltp')
+
+// LTP Right Token Primitives
+bsv.prepareRightToken = function(type, issuerDID, subjectDID, claim, issuerPrivateKey, options) {
+  return bsv.LTP.Right.prepareRightToken(type, issuerDID, subjectDID, claim, issuerPrivateKey, options)
+}
+
+bsv.prepareRightTokenVerification = function(token, options) {
+  return bsv.LTP.Right.prepareRightTokenVerification(token, options)
+}
+
+bsv.prepareRightTokenTransfer = function(token, newOwnerDID, currentOwnerKey, options) {
+  return bsv.LTP.Right.prepareRightTokenTransfer(token, newOwnerDID, currentOwnerKey, options)
+}
+
+bsv.prepareRightTypeValidation = function(type) {
+  return bsv.LTP.Right.prepareRightTypeValidation(type)
+}
+
+// LTP Obligation Token Primitives
+bsv.prepareObligationToken = function(type, issuerDID, obligorDID, obligation, issuerPrivateKey, options) {
+  return bsv.LTP.Obligation.prepareObligationToken(type, issuerDID, obligorDID, obligation, issuerPrivateKey, options)
+}
+
+bsv.prepareObligationVerification = function(token, options) {
+  return bsv.LTP.Obligation.prepareObligationVerification(token, options)
+}
+
+bsv.prepareObligationFulfillment = function(token, fulfillment, obligorKey, options) {
+  return bsv.LTP.Obligation.prepareObligationFulfillment(token, fulfillment, obligorKey, options)
+}
+
+bsv.prepareObligationBreachAssessment = function(token, breach, assessor) {
+  return bsv.LTP.Obligation.prepareObligationBreachAssessment(token, breach, assessor)
+}
+
+bsv.prepareObligationMonitoringReport = function(obligations, criteria) {
+  return bsv.LTP.Obligation.prepareObligationMonitoringReport(obligations, criteria)
+}
+
+// LTP Claim Validation Primitives
+bsv.prepareClaimValidation = function(claim, schemaName) {
+  return bsv.LTP.Claim.prepareClaimValidation(claim, schemaName)
+}
+
+bsv.prepareClaimAttestation = function(claim, schemaName, attestor) {
+  return bsv.LTP.Claim.prepareClaimAttestation(claim, schemaName, attestor)
+}
+
+bsv.prepareClaimDispute = function(claimHash, disputant, dispute) {
+  return bsv.LTP.Claim.prepareClaimDispute(claimHash, disputant, dispute)
+}
+
+bsv.prepareBulkClaimValidation = function(claims, schemaName) {
+  return bsv.LTP.Claim.prepareBulkClaimValidation(claims, schemaName)
+}
+
+bsv.prepareClaimTemplate = function(schemaName, options) {
+  return bsv.LTP.Claim.prepareClaimTemplate(schemaName, options)
+}
+
+// LTP Proof Generation Primitives
+bsv.prepareSignatureProof = function(token, privateKey, options) {
+  return bsv.LTP.Proof.prepareSignatureProof(token, privateKey, options)
+}
+
+bsv.prepareSignatureVerification = function(token, publicKey) {
+  return bsv.LTP.Proof.prepareSignatureVerification(token, publicKey)
+}
+
+bsv.prepareSelectiveDisclosure = function(token, revealedFields, nonce) {
+  return bsv.LTP.Proof.prepareSelectiveDisclosure(token, revealedFields, nonce)
+}
+
+bsv.prepareSelectiveDisclosureVerification = function(proof, expectedNonce) {
+  return bsv.LTP.Proof.prepareSelectiveDisclosureVerification(proof, expectedNonce)
+}
+
+bsv.prepareLegalValidityProof = function(token, jurisdiction, nonce) {
+  return bsv.LTP.Proof.prepareLegalValidityProof(token, jurisdiction, nonce)
+}
+
+bsv.prepareZeroKnowledgeProof = function(token, statement, nonce) {
+  return bsv.LTP.Proof.prepareZeroKnowledgeProof(token, statement, nonce)
+}
+
+// LTP Registry Management Primitives
+bsv.prepareRegistry = function(config) {
+  return bsv.LTP.Registry.prepareRegistry(config)
+}
+
+bsv.prepareTokenRegistration = function(token, registryConfig, options) {
+  return bsv.LTP.Registry.prepareTokenRegistration(token, registryConfig, options)
+}
+
+bsv.prepareTokenApproval = function(tokenId, approver, registryConfig) {
+  return bsv.LTP.Registry.prepareTokenApproval(tokenId, approver, registryConfig)
+}
+
+bsv.prepareTokenRevocation = function(tokenId, revocation, registryConfig) {
+  return bsv.LTP.Registry.prepareTokenRevocation(tokenId, revocation, registryConfig)
+}
+
+bsv.prepareTokenStatusQuery = function(tokenId, registryConfig) {
+  return bsv.LTP.Registry.prepareTokenStatusQuery(tokenId, registryConfig)
+}
+
+bsv.prepareTokenSearch = function(criteria, registryConfig) {
+  return bsv.LTP.Registry.prepareTokenSearch(criteria, registryConfig)
+}
+
+bsv.prepareStatisticsQuery = function(registryConfig) {
+  return bsv.LTP.Registry.prepareStatisticsQuery(registryConfig)
+}
+
+bsv.prepareAuditLogQuery = function(registryConfig, options) {
+  return bsv.LTP.Registry.prepareAuditLogQuery(registryConfig, options)
+}
+
+// LTP Blockchain Anchoring Primitives
+bsv.prepareTokenCommitment = function(token, options) {
+  return bsv.LTP.Anchor.prepareTokenCommitment(token, options)
+}
+
+bsv.prepareBatchCommitment = function(tokens, options) {
+  return bsv.LTP.Anchor.prepareBatchCommitment(tokens, options)
+}
+
+bsv.verifyTokenAnchor = function(token, txid, txData) {
+  return bsv.LTP.Anchor.verifyTokenAnchor(token, txid, txData)
+}
+
+bsv.formatRevocation = function(tokenId, revocationData) {
+  return bsv.LTP.Anchor.formatRevocation(tokenId, revocationData)
+}
+
+// LTP Static Data Access (unchanged)
+bsv.getRightTypes = function() {
+  return bsv.LTP.Right.getRightTypes()
+}
+
+bsv.getObligationTypes = function() {
+  return bsv.LTP.Obligation.getObligationTypes()
+}
+
+bsv.getObligationPriority = function() {
+  return bsv.LTP.Obligation.getObligationPriority()
+}
+
+bsv.getObligationStatus = function() {
+  return bsv.LTP.Obligation.getObligationStatus()
+}
+
+bsv.getClaimSchemas = function() {
+  return bsv.LTP.Claim.getSchemas()
+}
+
+bsv.getClaimSchemaNames = function() {
+  return bsv.LTP.Claim.getSchemaNames()
+}
+
+bsv.getClaimSchema = function(schemaName) {
+  return bsv.LTP.Claim.getSchema(schemaName)
+}
+
+bsv.createClaimTemplate = function(schemaName) {
+  return bsv.LTP.Claim.createTemplate(schemaName)
+}
+
+// LTP Utility Functions
+bsv.canonicalizeClaim = function(claim) {
+  return bsv.LTP.Claim.canonicalize(claim)
+}
+
+bsv.hashClaim = function(claim) {
+  return bsv.LTP.Claim.hash(claim)
+}
+
+bsv.addCustomClaimSchema = function(name, schema) {
+  return bsv.LTP.Claim.addSchema(name, schema)
+}
+
 // Internal usage, exposed for testing/advanced tweaking
 bsv.Transaction.sighash = require('./lib/transaction/sighash')