smartledger-sdk/dist/SmartLedger.js

A comprehensive blockchain and cryptographic operations SDK for JavaScript

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.SmartLedger = void 0;
var _Keys = _interopRequireDefault(require("./Keys.js"));
var _Signature = _interopRequireDefault(require("./Signature.js"));
var _Encryption = _interopRequireDefault(require("./Encryption.js"));
var _SecretSharer = _interopRequireDefault(require("./SecretSharer.js"));
var _Hashes = _interopRequireDefault(require("./Hashes.js"));
var _uuid = require("uuid");
var _bsv = _interopRequireDefault(require("bsv"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
class SmartLedger {
  constructor() {
    this.encryption = new _Encryption.default();
    this.signature = new _Signature.default();
    this.keys = new _Keys.default();
    this.secretSharer = new _SecretSharer.default();
    this.hash = _Hashes.default;
    this.uuid = (0, _uuid.v4)();
    this.bsv = _bsv.default;
  }

  // Key Management Methods
  static generateMnemonic() {
    return _Keys.default.generateMnemonic();
  }
  static generateKeyPair() {
    return _Keys.default.generateKeyPair();
  }
  static fromWIF(wif) {
    return _Keys.default.fromWIF(wif);
  }
  static fromMnemonic(mnemonic, purpose = "financial") {
    return _Keys.default.fromMnemonic(mnemonic, purpose);
  }
  generateAllKeys(mnemonic) {
    const keys = _Keys.default.generateAllKeys(mnemonic);
    return keys.keys; // Return just the array of keys
  }

  // Signature Methods
  static signWithWIF(data, wif) {
    const signer = _Signature.default.fromWIF(wif);
    return signer.sign(data);
  }
  static signWithMnemonic(data, mnemonic, purpose = "document") {
    const signer = _Signature.default.fromMnemonic(mnemonic, purpose);
    return signer.sign(data);
  }
  static verifySignature(data, signature, publicKey) {
    const verifier = _Signature.default.fromPublicKey(publicKey);
    return verifier.verify(data, signature, publicKey);
  }

  // Encryption Methods
  static encrypt(data, key) {
    return _Encryption.default.encrypt(data, key);
  }
  static decrypt(ciphertext, key) {
    return _Encryption.default.decrypt(ciphertext, key);
  }

  // Secret Sharing Methods
  splitSecret(secret, shares, threshold) {
    return this.secretSharer.splitSecret(secret, shares, threshold);
  }
  combineShares(shares) {
    return this.secretSharer.combineShares(shares);
  }
  shareToHex(share) {
    return this.secretSharer.shareToHex(share);
  }
  hexToShare(hexShare) {
    return this.secretSharer.hexToShare(hexShare);
  }

  // Hash Methods
  static hash256(data) {
    return _Hashes.default.hash256(data);
  }
  static hash512(data) {
    return _Hashes.default.hash512(data);
  }
  static doubleHash256(data) {
    return _Hashes.default.doubleHash256(data);
  }
  static hash160(data) {
    return _Hashes.default.hash160(data);
  }
  static verifyHash(data, hash, algorithm = "256") {
    return _Hashes.default.verifyHash(data, hash, algorithm);
  }

  // Instance Hash Methods
  hash256(data) {
    return this.hash.hash256(data);
  }
  hash512(data) {
    return this.hash.hash512(data);
  }
  doubleHash256(data) {
    return this.hash.doubleHash256(data);
  }
  hash160(data) {
    return this.hash.hash160(data);
  }
  verifyHash(data, hash, algorithm = "256") {
    return this.hash.verifyHash(data, hash, algorithm);
  }

  // UUID Methods
  getUUID() {
    return this.uuid;
  }
  static generateUUIDv5(name, namespace = "smartledger.example.com") {
    // Create a namespace UUID using a domain
    const namespaceUUID = (0, _uuid.v5)(namespace, _uuid.v5.DNS);
    // Generate a v5 UUID using the namespace and name
    return (0, _uuid.v5)(name, namespaceUUID);
  }

  // BSV Library Access
  getBSV() {
    return this.bsv;
  }
}
exports.SmartLedger = SmartLedger;
var _default = exports.default = SmartLedger;
// Example usage
const ledger = new SmartLedger();
const mnemonic = SmartLedger.generateMnemonic();
const keys = ledger.generateAllKeys(mnemonic);
console.log(keys);

// Encryption example
const encryptedData = SmartLedger.encrypt({
  message: "Hello, World!"
}, "my-secret-key");
console.log("Encrypted:", encryptedData);
const decryptedData = SmartLedger.decrypt(encryptedData, "my-secret-key");
console.log("Decrypted:", decryptedData);

// Hash example
const message = "Hello, SmartLedger!";
console.log("SHA256:", SmartLedger.hash256(message));
console.log("Double SHA256:", SmartLedger.doubleHash256(message));
console.log("HASH160:", SmartLedger.hash160(message));

// UUID examples
console.log("\nUUID Examples:");
console.log("Random UUIDv4:", ledger.getUUID());

// UUIDv5 examples
const resourceName = "transaction/123";
const uuidForResource = SmartLedger.generateUUIDv5(resourceName);
console.log("UUIDv5 for resource:", uuidForResource);

// Example of consistent UUIDs
const repeatedUuid1 = SmartLedger.generateUUIDv5(resourceName);
const repeatedUuid2 = SmartLedger.generateUUIDv5(resourceName);
console.log("UUIDv5 consistency check:", repeatedUuid1 === repeatedUuid2 ? "✓ Matching" : "✗ Not matching");

// Example with custom namespace
const customNamespace = "myapp.smartledger.com";
const customResource = "user/456";
const uuidWithCustomNamespace = SmartLedger.generateUUIDv5(customResource, customNamespace);
console.log("UUIDv5 with custom namespace:", uuidWithCustomNamespace);