psffpp 1.0.1 → 1.1.0

package/index.js

@@ -1,17 +1,18 @@
 /*
-  This library implement PS009 specification:
+  This library implement PS010 specification:
   https://github.com/Permissionless-Software-Foundation/specifications/blob/master/ps009-multisig-approval.md
 */
 
 // global libraries
-const bitcore = require('bitcore-lib-cash')
-const axios = require('axios')
+import MultisigApproval from 'psf-multisig-approval'
 
 // Local libraries
-const NFTs = require('./lib/nfts')
-const UtilLib = require('./lib/util')
 
-class MultisigApproval {
+// Constants
+const PSF_HARDCODE_WRITE_PRICE = 0.08335233
+const WRITE_PRICE_ADDR = 'bitcoincash:qrwe6kxhvu47ve6jvgrf2d93w0q38av7s5xm9xfehr'
+
+class PSFFPP {
   constructor (localConfig = {}) {
     // Dependency Injection
     this.wallet = localConfig.wallet
@@ -19,311 +20,228 @@ class MultisigApproval {
       throw new Error('Instance of minimal-slp-wallet must be passed in as a property called \'wallet\', when initializing the psf-multisig-approval library.')
     }
 
-    // The default IPFS gateway can be overwritten by the user when this library
-    // is instantiated.
-    this.ipfsGateway = localConfig.ipfsGateway
-    if (!this.ipfsGateway) {
-      this.ipfsGateway = 'https://p2wdb-gateway-678.fullstack.cash'
-    }
-
     // Encapsulate dependencies
     this.bchjs = this.wallet.bchjs
-    this.bitcore = bitcore
-    this.axios = axios
-    this.nfts = new NFTs(localConfig)
-    this.util = new UtilLib(localConfig)
+    this.ps009 = null // placeholder for Multisig Approval library.
 
     // Bind the this object to all subfunctions in this class
-    this.getNftHolderInfo = this.getNftHolderInfo.bind(this)
-    this.createMultisigAddress = this.createMultisigAddress.bind(this)
-    this.getApprovalTx = this.getApprovalTx.bind(this)
+    this._initPs009 = this._initPs009.bind(this)
+    this.getMcWritePrice = this.getMcWritePrice.bind(this)
+    this.createPinClaim = this.createPinClaim.bind(this)
 
-    // Create a transaction details cache, to reduce the number of API calls.
-    this.txCache = {}
+    // State
+    this.currentWritePrice = null
+    this.filterTxids = []
   }
 
-  // This function retrieves the NFTs associated with a Group token ID. It then
-  // tries to retrieve the BCH addresses and public keys of the holders of those
-  // NFTs. It returns an object with all that information in it.
-  // The function defaults to the PSF Minting Council, but any Group token ID
-  // can be used.
-  async getNftHolderInfo (groupTokenId = '8e8d90ebdb1791d58eba7acd428ff3b1e21c47fb7aba2ba3b5b815aa0fe7d6d5') {
-    try {
-      // console.log('groupTokenId: ', groupTokenId)
+  // Initialize the PS009 Multisig Approval library if it hasn't already been
+  // initialized.
+  async _initPs009 () {
+    if (!this.ps009) {
+      this.ps009 = new MultisigApproval({ wallet: this.wallet })
+    }
 
-      const nfts = await this.nfts.getNftsFromGroup()
-      // console.log('getNftHolderInfo() nfts: ', nfts)
+    return true
+  }
 
-      const addrs = await this.nfts.getAddrsFromNfts(nfts)
-      // console.log('getNftHolderInfo() addrs: ', addrs)
+  // Get the write price set by the PSF Minting Council.
+  // This function assumes the transaction history retrieved from the Cash
+  // Stack is sorted in descending order with the biggest (newest) block
+  // in the first element in the transaction history array.
+  async getMcWritePrice () {
+    // Hard codeded value. 3/2/24
+    // This value is returned if there are any issues returning the write price.
+    // It should be higher than actual fee, so that any writes will propegate to
+    // the nodes that successfully retrieved the current write price.
+    let writePrice = PSF_HARDCODE_WRITE_PRICE
 
-      const { keys, keysNotFound } = await this.nfts.findKeys(addrs, nfts)
+    try {
+      // Return the saved write price if this function has already been called once.
+      if (this.currentWritePrice) return this.currentWritePrice
 
-      return { keys, keysNotFound }
-    } catch (err) {
-      console.error('Error in getNftHolderInfo()')
-      throw err
-    }
-  }
+      await this._initPs009()
 
-  // Generate a P2SH multisignature wallet from the public keys of the NFT holders.
-  // The address for the wallet is returned.
-  // The input for this function should be the `keys` output from
-  // getNftHolderInfo()
-  createMultisigAddress (inObj = {}) {
-    try {
-      const { keys } = inObj
-      let requiredSigners = inObj.requiredSigners
+      // Find the PS009 approval transaction the addresses tx history.
+      console.log('\nSearching blockchain for updated write price...')
+      const approvalObj = await this.ps009.getApprovalTx({
+        address: WRITE_PRICE_ADDR,
+        filterTxids: this.filterTxids
+      })
+      // console.log('approvalObj: ', JSON.stringify(approvalObj, null, 2))
 
-      // Input validation
-      if (!Array.isArray(keys)) {
-        throw new Error('keys must be an array containing public keys')
+      // Throw an error if no approval transaction can be found in the
+      // transaction history.
+      if (approvalObj === null) {
+        throw new Error(`APPROVAL transaction could not be found in the TX history of ${WRITE_PRICE_ADDR}. Can not reach consensus on write price.`)
       }
 
-      // Isolate just an array of public keys.
-      const pubKeys = []
-      for (let i = 0; i < keys.length; i++) {
-        const thisPair = keys[i]
+      const { approvalTxid, updateTxid } = approvalObj
+      console.log(`New approval txid found (${approvalTxid}), validating...`)
 
-        pubKeys.push(thisPair.pubKey)
-      }
+      // Get the CID from the update transaction.
+      const updateObj = await this.ps009.getUpdateTx({ txid: updateTxid })
+      // console.log(`updateObj: ${JSON.stringify(updateObj, null, 2)}`)
+      const { cid } = updateObj
 
-      // If the number of required signers is not specified, then default to
-      // a 50% + 1 threashold.
-      if (!requiredSigners) {
-        requiredSigners = Math.floor(pubKeys.length / 2) + 1
-      }
+      // Resolve the CID into JSON data from the IPFS gateway.
+      const updateData = await this.ps009.getCidData({ cid })
+      // console.log(`updateData: ${JSON.stringify(updateData, null, 2)}`)
 
-      // Multisig Address
-      const msAddr = new bitcore.Address(pubKeys, requiredSigners)
+      // Validate the approval transaction
+      const approvalIsValid = await this.ps009.validateApproval({
+        approvalObj,
+        updateObj,
+        updateData
+      })
 
-      // Locking Script in hex representation.
-      const scriptHex = new bitcore.Script(msAddr).toHex()
+      if (approvalIsValid) {
+        console.log('Approval TXID validated.')
 
-      const walletObj = {
-        address: msAddr.toString(),
-        scriptHex,
-        publicKeys: pubKeys,
-        requiredSigners
-      }
+        // Return the write price from the update data.
+        writePrice = updateData.p2wdbWritePrice
+      } else {
+        // Approval transaction failed validation.
+        console.log(`Approval TXID was found to be invalid: ${approvalTxid}`)
 
-      return walletObj
+        // Add this invalid TXID to the filter array so that it is skipped.
+        this.filterTxids.push(approvalTxid)
+
+        // Continue looking for the correct approval transaction by recursivly
+        // calling this function.
+        writePrice = await this.getMcWritePrice()
+      }
     } catch (err) {
-      console.error('Error in createMultisigWallet()')
-      throw err
+      console.error('Error in getMcWritePrice()')
+      console.log(`Using hard-coded, safety value of ${writePrice} PSF tokens per write.`)
     }
+    // Save the curent write price to the state.
+    this.currentWritePrice = writePrice
+    return writePrice
   }
 
-  // Given a BCH address, scan its transaction history to find the latest
-  // APPROVAL transaction. This function returns the TXID of the UPDATE
-  // transaction that the APPROVAL transaction approves.
-  // If no APPROVAL transaction can be found, then function returns null.
-  // An optional input, filterTxids, is an array of transaction IDs to ignore. This can
-  // be used to ignore/skip any known, fake approval transactions.
-  async getApprovalTx (inObj = {}) {
+  // Given information about a file, this function will generate a Pin Claim.
+  // This function takes controls of the wallet and uses it to broadcast two
+  // transactions: a Proof-of-Burn (pobTxid) and a Pin Claim (climTxid). The
+  // function returns an object with the transaction ID of those two transacions.
+  async createPinClaim (inObj = {}) {
     try {
-      let address = inObj.address
-      const { filterTxids } = inObj
+      const { cid, filename, fileSizeInMegabytes } = inObj
 
       // Input validation
-      if (address.includes('simpleledger:')) {
-        address = this.bchjs.SLP.Address.toCashAddress(address)
+      if (!cid) {
+        throw new Error('cid required to generate pin claim.')
       }
-      if (!address.includes('bitcoincash:')) {
-        throw new Error('Input address must start with bitcoincash: or simpleledger:')
+      if (!filename) {
+        throw new Error('filename required to generate pin claim.')
       }
-
-      // Get the transaction history for the address
-      const txHistory = await this.wallet.getTransactions(address)
-      // console.log('txHistory: ', JSON.stringify(txHistory, null, 2))
-
-      // Loop through the transaction history
-      for (let i = 0; i < txHistory.length; i++) {
-        const thisTxid = txHistory[i]
-
-        // const height = thisTxid.height
-        const txid = thisTxid.tx_hash
-
-        // Skip the txid if it is in the filter list.
-        if (Array.isArray(filterTxids)) {
-          const txidFound = filterTxids.find(x => x === txid)
-          // console.log('txidFound: ', txidFound)
-          if (txidFound) {
-            continue
-          }
-        }
-
-        // Get the transaction details for the transaction
-        const txDetails = await this.util.getTxData(txid)
-        // console.log('txDetails: ', JSON.stringify(txDetails, null, 2))
-        // console.log(`txid: ${txid}`)
-
-        const out2ascii = Buffer.from(txDetails.vout[0].scriptPubKey.hex, 'hex').toString('ascii')
-        // console.log('out2ascii: ', out2ascii)
-
-        // If the first output is not an OP_RETURN, then the tx can be discarded.
-        if (!out2ascii.includes('APPROVE')) {
-          continue
-        }
-
-        const updateTxid = out2ascii.slice(10)
-        // console.log('updateTxid: ', updateTxid)
-
-        const outObj = {
-          approvalTxid: txid,
-          updateTxid,
-          approvalTxDetails: txDetails,
-          opReturn: out2ascii
-        }
-
-        return outObj
+      if (!fileSizeInMegabytes) {
+        throw new Error('fileSizeInMegabytes size in megabytes required to generate pin claim.')
       }
 
-      return null
-    } catch (err) {
-      console.error('Error in getApprovedData()')
-      throw err
-    }
-  }
-
-  // This function will retrieve an update transaction, given its txid. It will
-  // return an object with data about the transaction, including the CID and
-  // timestamp values encoded in the transactions OP_RETURN.
-  async getUpdateTx (inObj = {}) {
-    try {
-      const { txid } = inObj
+      // Initialize the wallet
+      await this.wallet.initialize()
 
-      // Input validation
-      if (!txid) {
-        throw new Error('txid required')
-      }
+      // Initialize the PS009 library
+      await this._initPs009()
 
-      // Get the transaction details for the transaction
-      const txDetails = await this.util.getTxData(txid)
-      // console.log('txDetails: ', JSON.stringify(txDetails, null, 2))
-      // console.log(`txid: ${txid}`)
+      // Get the cost in PSF tokens to store 1MB
+      const writePrice = await this.getMcWritePrice()
 
-      let updateObj = {}
-      try {
-        const out2ascii = Buffer.from(txDetails.vout[0].scriptPubKey.hex, 'hex').toString('ascii')
-        // console.log('out2ascii: ', out2ascii)
+      // Create a proof-of-burn (PoB) transaction
+      // const WRITE_PRICE = 0.08335233 // Cost in PSF tokens to pin 1MB
+      const PSF_TOKEN_ID = '38e97c5d7d3585a2cbf3f9580c82ca33985f9cb0845d4dcce220cb709f9538b0'
 
-        const jsonStr = out2ascii.slice(4)
-        // console.log('jsonStr: ', jsonStr)
+      // Calculate the write cost
+      const dataCost = writePrice * fileSizeInMegabytes
+      const minCost = writePrice
+      let actualCost = minCost
+      if (dataCost > minCost) actualCost = dataCost
+      console.log(`Burning ${actualCost} PSF tokens for ${fileSizeInMegabytes} MB of data.`)
 
-        updateObj = JSON.parse(jsonStr)
-      } catch (err) {
-        throw new Error('Could not parse JSON inside the transaction')
-      }
+      const pobTxid = await this.wallet.burnTokens(actualCost, PSF_TOKEN_ID)
+      // console.log(`Proof-of-burn TX: ${pobTxid}`)
 
-      updateObj.txid = txid
-      updateObj.txDetails = txDetails
+      // Get info and libraries from the wallet.
+      const addr = this.wallet.walletInfo.address
+      const bchjs = this.wallet.bchjs
+      const wif = this.wallet.walletInfo.privateKey
 
-      return updateObj
-    } catch (err) {
-      console.error('Error in getUpdateTx()')
-      throw err
-    }
-  }
+      // Get a UTXO to spend to generate the pin claim TX.
+      let utxos = await this.wallet.getUtxos()
+      utxos = utxos.bchUtxos
+      const utxo = bchjs.Utxo.findBiggestUtxo(utxos)
 
-  // Given an CID, this function will retrieve the update data from an IPFS
-  // gateway.
-  async getCidData (inObj = {}) {
-    try {
-      const { cid } = inObj
+      // instance of transaction builder
+      const transactionBuilder = new bchjs.TransactionBuilder()
 
-      // Input validation
-      if (!cid) {
-        throw new Error('cid a required input')
-      }
+      const originalAmount = utxo.value
+      const vout = utxo.tx_pos
+      const txid = utxo.tx_hash
 
-      const urlStr = `${this.ipfsGateway}/ipfs/${cid}/data.json`
-      // console.log('urlStr: ', urlStr)
+      // add input with txid and index of vout
+      transactionBuilder.addInput(txid, vout)
 
-      const request = await this.axios.get(urlStr)
+      // TODO: Compute the 1 sat/byte fee.
+      const fee = 500
 
-      return request.data
-    } catch (err) {
-      console.error('Error in getCidData()')
-      throw err
-    }
-  }
+      // BEGIN - Construction of OP_RETURN transaction.
 
-  // This function will validate the approval transaction.
-  // This function will return true or false, to indicate the validity of the
-  // approval transaction.
-  // The input to this function is the output of several of the above function:
-  // - approvalObj is the output of getApprovalTx()
-  // - updateObj is the output of getUpdateTx()
-  // - updateData is the IPFS CID data retrieved with getCidData()
-  // - groupTokenId is optional. If not specified, it will default to the Group
-  //   token used to generate the PSF Minting Council NFTs.
-  async validateApproval (inObj = {}) {
-    try {
-      // console.log('inObj: ', JSON.stringify(inObj, null, 2))
+      // Add the OP_RETURN to the transaction.
+      const script = [
+        bchjs.Script.opcodes.OP_RETURN,
+        Buffer.from('00510000', 'hex'),
+        Buffer.from(pobTxid, 'hex'),
+        Buffer.from(cid),
+        Buffer.from(filename)
+      ]
 
-      const { approvalObj, updateObj, updateData, groupTokenId } = inObj
+      // Compile the script array into a bitcoin-compliant hex encoded string.
+      const data = bchjs.Script.encode(script)
 
-      let validationResult = false
+      // Add the OP_RETURN output.
+      transactionBuilder.addOutput(data, 0)
 
-      // Input validation
-      if (!approvalObj) {
-        throw new Error('Output object of getApprovalTx() is expected as input to this function, as \'approvalObj\'')
-      }
-      if (!updateObj) {
-        throw new Error('Output object of getUpdateTx() is expected as input to this function, as \'updateObj\'')
-      }
-      if (!updateData) {
-        throw new Error('Update CID JSON data is expected as input to this function, as \'updateData\'')
-      }
+      // END - Construction of OP_RETURN transaction.
 
-      // Regenerate the multisig address from the pubkeys in the update data.
-      // Ensure it matches the input address to the approval transaction.
-      const pubKeys = updateData.walletObj.publicKeys
-      const requiredSigners = updateData.walletObj.requiredSigners
-      const approvalInputAddr = approvalObj.approvalTxDetails.vin[0].address
-      const msAddr = new this.bitcore.Address(pubKeys, requiredSigners).toString()
-      if (msAddr !== approvalInputAddr) {
-        console.log(`Approval TX input address (${approvalInputAddr}) does not match calculated multisig address ${msAddr}`)
-        return validationResult
-      }
+      // Send the same amount - fee.
+      transactionBuilder.addOutput(addr, originalAmount - fee)
 
-      // Get public key data for each NFT holder, from the blockchain.
-      const nftData = await this.getNftHolderInfo(groupTokenId)
-      const tokenPubKeys = nftData.keys
+      // Create an EC Key Pair from the user-supplied WIF.
+      const ecPair = bchjs.ECPair.fromWIF(wif)
 
-      // Loop through the public keys from the token data, and count the matches.
-      let matches = 0
-      for (let i = 0; i < tokenPubKeys.length; i++) {
-        const thisTokenPubKey = tokenPubKeys[i].pubKey
+      // Sign the transaction with the HD node.
+      let redeemScript
+      transactionBuilder.sign(
+        0,
+        ecPair,
+        redeemScript,
+        transactionBuilder.hashTypes.SIGHASH_ALL,
+        originalAmount
+      )
 
-        // Loop through the public keys from the update data
-        for (let j = 0; j < pubKeys.length; j++) {
-          const thisUpdatePubKey = pubKeys[j]
+      // build tx
+      const tx = transactionBuilder.build()
 
-          if (thisTokenPubKey === thisUpdatePubKey) {
-            matches++
-            break
-          }
-        }
-      }
+      // output rawhex
+      const hex = tx.toHex()
+      // console.log(`TX hex: ${hex}`);
+      // console.log(` `);
 
-      // Set a threshold for success.
-      let threshold = 2 // Minimum
-      if (requiredSigners > threshold) threshold = requiredSigners
+      // Broadcast transation to the network
+      const claimTxid = await this.wallet.broadcast({ hex })
+      // console.log(`Claim Transaction ID: ${claimTxid}`)
+      // console.log(`https://blockchair.com/bitcoin-cash/transaction/${claimTxid}`)
 
-      // If the threshold of public keys match, then the approval transaction
-      // has been validated.
-      if (matches >= threshold) {
-        validationResult = true
+      return {
+        pobTxid,
+        claimTxid
       }
-
-      return validationResult
     } catch (err) {
-      console.error('Error in validateApproval()')
+      console.error('Error in ps010/createPinClaim()')
       throw err
     }
   }
 }
 
-module.exports = MultisigApproval
+// module.exports = PSFFPP
+export default PSFFPP

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "psffpp",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "PS010 PSF File Pinning Protocol",
   "main": "index.js",
+  "type": "module",
   "scripts": {
     "start": "node index.js",
-    "test": "npm run lint && TEST=unit nyc mocha test/unit/",
+    "test": "npm run lint && TEST=unit c8 --reporter=text mocha test/unit/",
     "test:integration": "mocha --timeout 120000 test/integration/",
     "lint": "standard --env mocha --fix",
     "docs": "./node_modules/.bin/apidoc -i src/ -o docs",
-    "coverage:report": "nyc --reporter=html mocha test/unit/ --exit"
+    "coverage:report": "c8 --reporter=html mocha test/unit/ --exit"
   },
   "keywords": [
     "bitcoin",
@@ -33,16 +34,18 @@
   "repository": "Permissionless-Software-Foundation/psffpp",
   "dependencies": {
     "axios": "1.3.5",
-    "bitcore-lib-cash": "10.0.2"
+    "bitcore-lib-cash": "10.0.2",
+    "psf-multisig-approval": "2.0.3"
   },
   "devDependencies": {
+    "@psf/bch-js": "^6.7.4",
     "apidoc": "0.54.0",
+    "c8": "^9.1.0",
     "chai": "4.3.7",
     "husky": "8.0.3",
     "lodash.clonedeep": "4.5.0",
     "minimal-slp-wallet": "5.8.8",
     "mocha": "10.2.0",
-    "nyc": "15.1.0",
     "semantic-release": "19.0.5",
     "sinon": "15.0.3",
     "standard": "17.0.0"