gitmark 0.0.23

package/CNAME

@@ -0,0 +1 @@
+git-mark.com

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 solidpayorg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,156 @@
+<div align="center">
+  <h1>gitmark</h1>
+</div>
+
+<div align="center">  
+Mark your git commits, to create global consensus, and a definitive project history
+</div>
+
+---
+
+<div align="center">
+<h4>Getting Started</h4>
+</div>
+  
+---
+  
+
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/solidpayorg/git-mark/blob/gh-pages/LICENSE)
+![npm](https://img.shields.io/npm/v/gitmark)
+[![npm](https://img.shields.io/npm/dw/gitmark.svg)](https://npmjs.com/package/gitmark)
+  
+  
+## Introduction
+
+Gitmark extends git to allow commits to be "marked" (using the command `git mark`) by a supporting block chain. This "reinforces" or "finalizes" a given commit, to determine global consensus and a definitive project history
+
+## Installation
+
+```sh
+sudo npm install -g gitmark
+```
+
+## Usage
+
+```bash
+git mark # marks the current commit
+
+git mark [--genesis txoutput] # used for the genesis commit
+```
+
+## Motivation
+
+Gitmark, was originally created to facilitate the [marking](https://github.com/project-bitmark/marking/wiki) use case, which aims to allow global, distributed, reputation trees, to be grounded in a block chain
+
+What is made possible, is a way to provide consensus on a definitive git branch/chain, in order to ensure that the history has not been tampered with
+
+One can reconstruct the current state from the history, and this can also be used to preserve your reputation at any given time, say, if any provider ceases to operate
+
+It's also possible to audit and verify the integrity of the git chain, to create a secure, finalized, state machine, with a definitive head, that is globally synced
+
+The system can be extended beyond reputation trees, to use any git based store, and anchor it to a secure, verifyable chain of blocks, to determine the definitve history
+
+Many thanks go to Peter Todd for his work on [single use seals](https://petertodd.org/2017/scalable-single-use-seal-asset-transfer) and Dr Maxim Orlovsky for his work on [RGB](https://rgb-org.github.io/)
+
+_Gitmark is pre-alpha software, it should be considered experimental, and used at your own risk_
+
+## Prerequisites
+
+Because gitmark was designed to anchor reputation trees, the reputation of the underlying block chain must be unimpared.  Gitmark only supports block chains that are provably fair.  Bitcoin is regarded as the most secure and fairest of all block chains, and should be used for high value projects where cost is not an issue
+
+Gitmark does not support projects that are premines, instamines, ICOs, have developer taxes or provably unfair consensus, such as proof of stake
+
+In solving the reputation use case, we aim to innovate in the space, contribute back code, and operate as a testing ground
+
+Bearing in mind that this is experimental software, the [bitmark](https://bitmark.rocks/) block chain, is the first chain on which gitmark is tested and implemented.  As it inexpensive, easily obitained, and was designed for the grounding of reputation trees (gitmark is a play on the word bitmark). This also provides a testing ground for developers to get started.  The Liquid network is also a possible target, and Litecoin appears to be another good possibility, as well as the various testnets
+
+The first prerequisite is to obtain an unspent transaction on a supporting block chain. This can be in any coin, but to get started we suggest, getting hold of one Bitmark, which can be obtained inexpensively for example in the [chat room](https://projectbitmark.slack.com/) as it is designed to be spread between helpful actors, to foster innovation
+
+## Getting started
+
+After you have obtained some block chain currency, send those coins to an address for which you have the keypair. That becomes the genesis unspent transaction
+
+Having created a genesis transaction, and recording the key pair safely, you are ready to start marking!
+
+Install gitmark globally via npm, the executables will be in the bin directory which can be located with `which git-mark`
+
+The genesis transaction provides the first input to the `git mark` command, and the private key (secret exponent in hex) is needed to advance the genesis transaction in line with the current git HEAD
+
+## Git mark
+
+Simply running `git mark` on a repo will create your first marking
+
+You will need a genesis address for the first run of the form `tx:output` and supply that with the argument --genesis [tx]
+
+You will also need the private key from that tx, which is an argument to the gitmark script, but can be also saved in a location as directed by the output from the git mark command. The key (ie 64 char hex secret exponent) should be stored in the indicated file with the json key "privkey"
+
+_Warning: do not use the default private key, that is set, in the script!_
+
+Git mark will generate a new address to send to, a fee, an amount, a spending private key and unspent tx data as inputs to an rpc or a simple script `tx.sh` that lives in the bin directory. Future versions will use a transaction builder to send to a network directly
+
+After running this script, an empty commit message is generated which you can check in, and points to the latest new unspent transaction, creating a two way link
+
+Congratulations! You have now marked your first git repo!
+
+## How it works
+
+Gitmark simply uses [single use seals](https://petertodd.org/2017/scalable-single-use-seal-asset-transfer) to tweak the initial public key address of the genesis transaction by the commit hash of the git tree. The current git hash is added to the original, genesis, public key in the output transaction, creating a chain of commits in the block chain
+
+In this way the block chain points to git. It then points the next commit back to the block chain tx, creating two way link, and therefore, strong binding, at one particular point in time
+
+Similarly the definitive git tree forms a chain of commits that go forward in time, and so do the new transaction on the block chain. Further commits are periodically marked in time proving an auditable trail in both time on-chain of the evolution of the git tree. It also shows the latest confirmed state of a git tree that can be used for trading or in safe or smart contracts
+
+The first use case for gitmark is marking of reputation trees, but it can be applied to any git system where the history is important
+
+## Recent git marks
+
+- [Github](https://github.com/search?o=desc&q=%22gitmark+%22&s=committer-date&type=Commits)
+
+## Use Cases
+
+- Distributed Reputation Trees
+- Distributed Ledgers
+- Registries
+- Safe or Smart Contracts
+- Asset Issuance
+- Distributed Exchanges
+- Reconstruct histories from Genesis
+- Distributed Global Consensus
+- Domain independent web sites
+- Archiving and Time Travel through History
+- Distributed Identity and PKI
+- Federated Side Chains
+- Auditing Histories
+- Fraud Detection
+- Supply Chains
+
+## Related work
+
+- [Single Use Seals](https://petertodd.org/2017/scalable-single-use-seal-asset-transfer)
+- [RGB](https://rgb-org.github.io/)
+- [Commerce Block Mainstay](https://www.commerceblock.com/mainstay/) [[White Paper](https://cloudflare-ipfs.com/ipns/ipfs.commerceblock.com/commerceblock-whitepaper-mainstay.pdf)]
+- [BIP 175 - Pay to Contract Protocol](https://github.com/bitcoin/bips/blob/master/bip-0175.mediawiki)
+
+## Source code
+
+- [Source](https://github.com/solidpayorg/gitmark)
+- [Issue Tracker](https://github.com/solidpayorg/gitmark/issues)
+- [NPM](https://www.npmjs.com/package/gitmark)
+
+## Future work
+
+- Git marks can be extended to further layers by using git submodules hence creating almost unlimited space
+
+- Private git repositories can be supported out of the box, and given that private keys are used in each seal, encrypted backups can be made
+
+- The project git tree can be backed up or archived using git clone in multiple locations. It is natural that popular projects are cloned often in any case
+
+- Seals can be opened and closed using a federation, in order to try out multiple consensus and vefification methods
+
+- More robust verification frameworks can be built using node testing frameworks, and continusous integration, tho currently the distribution contains a git-mark-verify script
+
+- Lightweight Autonomous Marking Agents (LAMAs) can be created that listen to communities for marks and just work, without needing a human operator. The service can be deployed on a server or container, and be designed to bring itself up if it goes down in any one location
+
+## License
+
+- MIT

package/bin/addpub.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+// USAGE: git-mark [privkeyhex] [$(git rev-parse HEAD)]
+
+// IMPORTS
+var bitcoin = require('bitcoinjs-lib')
+var tiny = require('tiny-secp256k1')
+var argv = require('minimist')(process.argv.slice(2))
+const gitlog = require('gitlog').default
+const fs = require('fs')
+const homedir = require('os').homedir()
+
+// MODEL
+// default privkey = brain for urn:json:bitmark
+globalThis.data = {
+  privkey: '132e7465a63e30a74c5b0deae3573033319e9de18a84878613eaa21878b2b56b',
+  hash: 'b3e8f5735849af7f18a13ead08532043a7f82153',
+  genesis: null
+}
+
+// FUNCTIONS
+const BITMARK = {
+  messagePrefix: '\x19BITMARK Signed Message:\n',
+  bech32: 'btm',
+  bip32: {
+    public: 0x019da462,
+    private: 0x019d9cfe
+  },
+  pubKeyHash: 85,
+  scriptHash: 0x32,
+  wif: 213
+}
+
+const options = {
+  repo: './',
+  fields: ['subject', 'authorName', 'authorDate'],
+  execOptions: { maxBuffer: 1000 * 1024 },
+  number: 1000,
+  fields: ['hash', 'subject']
+}
+
+function getPrivKey () {
+  try {
+    const fetchHeadDir = './.git/'
+    var fetchHeadFile = fetchHeadDir + 'FETCH_HEAD'
+
+    var fetchHead = fs.readFileSync(fetchHeadFile).toString()
+
+    var repo = fetchHead
+      .split(' ')
+      .pop()
+      .replace(':', '/')
+      .replace('\n', '')
+
+    const gitmarkRepoBase = homedir + '/.gitmark/repo'
+
+    const gitmarkFile = gitmarkRepoBase + '/' + repo + '/gitmark.json'
+
+    return require(gitmarkFile).privkey
+  } catch (e) {
+    const fetchHeadDir = './.git/'
+    var fetchHeadFile = fetchHeadDir + 'FETCH_HEAD'
+
+    var fetchHead = fs.readFileSync(fetchHeadFile).toString()
+
+    var repo = fetchHead
+      .split(' ')
+      .pop()
+      .replace(':', '/')
+      .replace('\n', '')
+
+    const gitmarkRepoBase = homedir + '/.gitmark/repo'
+
+    const gitmarkFile = gitmarkRepoBase + '/' + repo + '/gitmark.json'
+
+    console.log('no priv key found in', gitmarkFile)
+    return undefined
+  }
+}
+
+// INIT
+data.hash = argv._[0] || data.hash
+data.privkey = argv._[1] || getPrivKey() || data.privkey
+
+console.log('data', data)
+
+
+const POINT = Buffer.from(data.privkey.padStart(64, 0), 'hex')
+
+const OFFSET = Buffer.from(data.hash.padStart(64, 0), 'hex')
+
+// MAIN
+// priv keys
+const b1 = BigInt('0x' + data.privkey)
+const b2 = BigInt('0x' + data.hash)
+const b3 = BigInt.asUintN(256, b1 + b2)
+
+// print priv keys
+console.log('private keys hex')
+console.log(b1.toString(16))
+console.log(b2.toString(16))
+console.log(b3.toString(16))
+
+
+// pub keys
+var keyPair1 = bitcoin.ECPair.fromPrivateKey(POINT)
+var keyPair2 = bitcoin.ECPair.fromPrivateKey(OFFSET)
+var keyPair3 = bitcoin.ECPair.fromPrivateKey(
+  Buffer.from(b3.toString(16).padStart(64, 0), 'hex')
+)
+
+// add pub keys together
+const SUM = tiny.pointAdd(keyPair1.publicKey, keyPair2.publicKey)
+
+// print pub keys
+console.log('public keys hex buffer')
+console.log(keyPair1.publicKey)
+console.log(keyPair2.publicKey)
+console.log(SUM)
+
+// address from priv key addition
+var { address } = bitcoin.payments.p2pkh({
+  pubkey: keyPair3.publicKey,
+  network: BITMARK
+})
+console.log('address computed from private', address)
+
+// address from pub key addition
+var { address } = bitcoin.payments.p2pkh({
+  pubkey: SUM,
+  network: BITMARK
+})
+console.log('address computed from public', address)
+

package/bin/git-mark

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+
+// USAGE: git-mark [privkeyhex] [$(git rev-parse HEAD)]
+
+// IMPORTS
+const bitcoin = require('bitcoinjs-lib')
+const tiny = require('tiny-secp256k1')
+const argv = require('minimist')(process.argv.slice(2))
+const gitlog = require('gitlog').default
+const fs = require('fs')
+const homedir = require('os').homedir()
+const exec = require('child_process').exec
+
+// MODEL
+// default privkey = brain for urn:json:bitmark
+globalThis.data = {
+  privkey: '132e7465a63e30a74c5b0deae3573033319e9de18a84878613eaa21878b2b56b',
+  hash: 'b3e8f5735849af7f18a13ead08532043a7f82153',
+  genesis: null
+}
+
+// FUNCTIONS
+const options = {
+  repo: './',
+  fields: ['subject', 'authorName', 'authorDate'],
+  execOptions: { maxBuffer: 1000 * 1024 },
+  number: 1000,
+  fields: ['hash', 'subject']
+}
+
+function getPrivKey() {
+  try {
+    const fetchHeadDir = './.git/'
+    var fetchHeadFile = fetchHeadDir + 'FETCH_HEAD'
+
+    var fetchHead = fs.readFileSync(fetchHeadFile).toString()
+
+    var repo = fetchHead
+      .split(' ')
+      .pop()
+      .replace(':', '/')
+      .replace('\n', '')
+
+    const gitmarkRepoBase = homedir + '/.gitmark/repo'
+
+    const gitmarkFile = gitmarkRepoBase + '/' + repo + '/gitmark.json'
+
+    return require(gitmarkFile).privkey
+  } catch (e) {
+    const fetchHeadDir = './.git/'
+    var fetchHeadFile = fetchHeadDir + 'FETCH_HEAD'
+
+    var fetchHead = fs.readFileSync(fetchHeadFile).toString()
+
+    var repo = fetchHead
+      .split(' ')
+      .pop()
+      .replace(':', '/')
+      .replace('\n', '')
+
+    const gitmarkRepoBase = homedir + '/.gitmark/repo'
+
+    const gitmarkFile = gitmarkRepoBase + '/' + repo + '/gitmark.json'
+
+    console.log('no priv key found in', gitmarkFile)
+    return undefined
+  }
+}
+
+// INIT
+let NETWORK = require('../lib/networks.js').BITMARK
+if (process.env.NETWORK) {
+  NETWORK = require('../lib/networks.js')[process.env.NETWORK] || NETWORK
+}
+console.log('NETWORK', NETWORK)
+
+const commits = gitlog(options)
+var head = commits[0].hash
+console.log('current head', head)
+
+data.privkey = argv._[0] || getPrivKey() || data.privkey
+data.hash = argv._[1] || head || data.hash
+data.genesis = argv.genesis || data.genesis
+
+console.log('data', data)
+
+var lastCommit = commits.filter(i => {
+  return i.subject.match(/^gitmark/)
+})
+if (lastCommit && lastCommit[0] && lastCommit[0].subject) {
+  lastCommit = lastCommit[0].subject
+  lastCommit = lastCommit.split(' ').pop()
+  lastCommit = lastCommit.split(':')
+  console.log('lastCommit', lastCommit)
+} else {
+  console.log('New repo, set up first gitmark')
+  console.log('Add private key')
+  console.log('Fund genesis tx with genesis hash')
+  console.log('Add --gensis and run')
+  lastCommit = data.genesis.split(':')
+  console.log('data.genesis', data.genesis)
+  if (!data.genesis) {
+    process.exit(-1)
+  }
+}
+
+const POINT = Buffer.from(data.privkey, 'hex')
+
+const OFFSET = Buffer.from('000000000000000000000000' + data.hash, 'hex')
+
+// MAIN
+function findLastCommitHash() {
+  var i
+  for (i = 0; i < commits.length; i++) {
+    if (commits[i].subject.match(/^gitmark/)) break
+  }
+  if (i === commits.length) {
+    return head
+  } else {
+    return commits[i + 1].hash
+  }
+}
+var lastCommitHash = findLastCommitHash()
+console.log('lastCommitHash', lastCommitHash)
+
+// priv keys
+const b1 = BigInt('0x' + data.privkey)
+const b2 = BigInt('0x' + data.hash)
+const b3 = BigInt.asUintN(256, b1 + b2)
+const b4 = BigInt('0x' + lastCommitHash)
+const b5 = BigInt.asUintN(256, b1 + b4)
+
+// pub keys
+var keyPair1 = bitcoin.ECPair.fromPrivateKey(POINT)
+var keyPair2 = bitcoin.ECPair.fromPrivateKey(OFFSET)
+var keyPair3 = bitcoin.ECPair.fromPrivateKey(
+  Buffer.from(b3.toString(16).padStart(64, 0), 'hex')
+)
+
+// add pub keys together
+const SUM = tiny.pointAdd(keyPair1.publicKey, keyPair2.publicKey)
+
+// print pub keys
+console.log('public keys hex buffer')
+console.log(keyPair1.publicKey)
+console.log(keyPair2.publicKey)
+console.log(SUM)
+
+// print priv keys
+console.log('private keys hex')
+console.log(b1.toString(16))
+console.log(b2.toString(16))
+console.log(b3.toString(16))
+console.log(b4.toString(16))
+console.log(b5.toString(16))
+
+// address from priv key addition
+var { address } = bitcoin.payments.p2pkh({
+  pubkey: keyPair3.publicKey,
+  network: NETWORK
+})
+console.log('address computed from private', address)
+
+// address from pub key addition
+var { address } = bitcoin.payments.p2pkh({
+  pubkey: SUM,
+  network: NETWORK
+})
+console.log('address computed from public', address)
+
+var fee = 1000
+var tx
+const gitmarkTxBase = homedir + '/.gitmark/tx'
+
+try {
+  if (data.genesis) {
+    tx = { total_output: '1', fees: '0.00001' }
+  } else {
+    tx = require(gitmarkTxBase + '/' + lastCommit[0] + '.json')
+  }
+} catch (e) {
+  console.error(e)
+  console.error(
+    'error: need tx: ' +
+    lastCommit[0] +
+    'in ' +
+    gitmarkTxBase +
+    '/' +
+    lastCommit[0] +
+    '.json'
+  )
+  console.log('trying:')
+  var command = `curl "https://chainz.cryptoid.info/marks/api.dws?q=txinfo&t=${lastCommit[0]}" > ${gitmarkTxBase}/${lastCommit[0]}.json`
+  console.log(command)
+  exec(command, console.log)
+  console.log('do not run more than once per 10s')
+  process.exit(-1)
+}
+
+var nextfee = tx.total_output - tx.fees
+nextfee = Math.round((nextfee + Number.EPSILON) * 100000000) / 100000000
+
+var priv = data.genesis ? b1 : b5
+var keyPair1 = bitcoin.ECPair.fromPrivateKey(
+  Buffer.from(priv.toString(16).padStart(64, 0), 'hex'),
+  { network: NETWORK }
+)
+console.log('private key WIF:', keyPair1.toWIF())
+
+console.log('last commit hash', lastCommit.hash)
+
+console.log(nextfee)
+console.log('console commands')
+// console.log(
+//   'createrawtransaction',
+//   lastCommit[0],
+//   lastCommit[1],
+//   address,
+//   nextfee
+// )
+lastCommit[1] = lastCommit[1] || 0
+console.log(
+  `createrawtransaction '[{"txid": "${lastCommit[0]}", "vout": ${lastCommit[1]}}]' '{"${address}": ${nextfee}}'`
+)
+var hex = `1234`
+// console.log('signrawtransaction', keyPair1.toWIF())
+console.log(`signrawtransaction ${hex} null '["${keyPair1.toWIF()}"]'`)
+console.log('sendrawtransaction')
+console.log(
+  `bin/tx.sh ${lastCommit[0]} ${lastCommit[1]
+  } ${address} ${nextfee} ${keyPair1.toWIF()}`
+)

package/bin/git-mark-verify

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+// USAGE: git-mark-verify
+
+// IMPORTS
+const gitlog = require('gitlog').default
+var bitcoin = require('bitcoinjs-lib')
+var argv = require('minimist')(process.argv.slice(2))
+const fs = require('fs')
+const homedir = require('os').homedir()
+
+// MODEL
+// default privkey = brain for urn:json:bitmark
+globalThis.data = {
+  privkey: '132e7465a63e30a74c5b0deae3573033319e9de18a84878613eaa21878b2b56b'
+}
+
+// console.log('data', data)
+
+// FUNCTIONS
+const BITMARK = {
+  messagePrefix: '\x19BITMARK Signed Message:\n',
+  bech32: 'btm',
+  bip32: {
+    public: 0x019da462,
+    private: 0x019d9cfe
+  },
+  pubKeyHash: 85,
+  wif: 213,
+  scriptHash: 0x32
+}
+
+const options = {
+  repo: './',
+  fields: ['subject', 'authorName', 'authorDate'],
+  execOptions: { maxBuffer: 1000 * 1024 },
+  number: 1000,
+  fields: ['hash', 'subject']
+}
+
+function getPrivKey () {
+  try {
+    const fetchHeadDir = './.git/'
+    var fetchHeadFile = fetchHeadDir + 'FETCH_HEAD'
+
+    var fetchHead = fs.readFileSync(fetchHeadFile).toString()
+
+    var repo = fetchHead
+      .split(' ')
+      .pop()
+      .replace(':', '/')
+      .replace('\n', '')
+
+    const gitmarkRepoBase = homedir + '/.gitmark/repo'
+
+    const gitmarkFile = gitmarkRepoBase + '/' + repo + '/gitmark.json'
+
+    return require(gitmarkFile).privkey
+  } catch {
+    return undefined
+  }
+}
+
+// INIT
+data.privkey = argv._[0] || getPrivKey() || data.privkey
+
+var POINT = Buffer.from(data.privkey, 'hex')
+
+var OFFSET = Buffer.from('000000000000000000000000' + data.hash, 'hex')
+
+// MAIN
+// priv keys
+var b1 = BigInt('0x' + data.privkey)
+var b2
+var b3
+
+// commits
+const commits = gitlog(options)
+if (commits.length === 1) {
+  console.log('Set up new repository with a gitmark')
+  process.exit()
+}
+
+console.log('Genesis tx need not be verified\n')
+for (var i = commits.length-1; i >= 0; i--) {
+  var subject = commits[i].subject
+  if (subject.match(/^gitmark/)) {
+    var hash = commits[i + 1].hash
+    console.log()
+    console.log(subject)
+    console.log('hash:', hash)
+    b2 = BigInt('0x' + hash)
+    b3 = BigInt.asUintN(256, b1 + b2)
+    console.log(b3.toString(16))
+    var keyPair1 = bitcoin.ECPair.fromPrivateKey(
+      Buffer.from(b3.toString(16), 'hex'),
+      { network: BITMARK }
+    )
+    console.log('private key WIF:', keyPair1.toWIF())
+
+    var { address } = bitcoin.payments.p2pkh({
+      pubkey: keyPair1.publicKey,
+      network: BITMARK
+    })
+    console.log('verify address computed from private key:', address)
+
+    console.log(
+      'https://chainz.cryptoid.info/marks/tx.dws?' +
+        subject.split(' ')[1].split(':')[0] +
+        '.htm'
+    )
+  }
+}
+

package/bin/tx.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+RAWTX=$(bitmark-cli createrawtransaction '[{"txid": "'$1'", "vout": '$2'}]' '{"'$3'": '$4'}')
+
+SENDTX=$(bitmark-cli signrawtransaction $RAWTX null '["'$5'"]' | grep ffff | sed 's/.*: "\(.*\)".*/\1/')
+
+NEWTX=$(bitmark-cli sendrawtransaction $SENDTX)
+
+echo $NEWTX
+
+echo "git commit --allow-empty -m 'gitmark $NEWTX'"

package/lib/networks.js

@@ -0,0 +1,80 @@
+// network
+exports.BITCOIN = {
+  baseNetwork: 'bitcoin',
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  bech32: 'bc',
+  bip32: {
+    public: 0x04b24746,
+    private: 0x04b2430c
+  },
+  pubKeyHash: 0x00,
+  scriptHash: 0x05,
+  wif: 0x80
+}
+
+exports.BITMARK = {
+  messagePrefix: '\x19BITMARK Signed Message:\n',
+  bech32: 'btm',
+  bip32: {
+    public: 0x019da462,
+    private: 0x019d9cfe
+  },
+  pubKeyHash: 85,
+  scriptHash: 0x32,
+  wif: 213
+}
+
+exports.LIQUID = {
+  messagePrefix: '\x18Liquid Signed Message:\n',
+  bech32: 'ex',
+  blech32: 'lq',
+  bip32: {
+    public: 0x0488b21e,
+    private: 0x0488ade4
+  },
+  pubKeyHash: 57,
+  scriptHash: 39,
+  wif: 0x80,
+  confidentialPrefix: 12,
+  assetHash: '6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d'
+}
+
+exports.TESTNET3 = {
+  baseNetwork: 'testnet',
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  bech32: 'tb',
+  bip32: {
+    public: 0x045f1cf6,
+    private: 0x045f18bc
+  },
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef
+}
+
+exports.REGTEST = {
+  baseNetwork: 'regtest',
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  bech32: 'bcrt',
+  bip32: {
+    public: 0x045f1cf6,
+    private: 0x045f18bc
+  },
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef
+}
+
+exports.LITECOIN = {
+  coin: 'ltc',
+  bech32: 'ltc',
+  bip32: {
+    private: 27106558, // xprv_magic
+    public: 28471030 // xpub_magic_segwit_p2sh
+  },
+  dustThreshold: 0, // doesn't matter, for type correctness,
+  messagePrefix: 'Litecoin Signed Message:\n',
+  pubKeyHash: 48, // address_type
+  scriptHash: 50, // address_type_p2sh
+  wif: 128 // doesn't matter, for type correctness
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "gitmark",
+  "version": "0.0.23",
+  "description": "gitmark",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/solidpayorg/gitmark.git"
+  },
+  "keywords": [
+    "gitmark"
+  ],
+  "bin": {
+    "git-mark": "bin/git-mark"
+  },
+  "author": "Melvin Carvalho",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/solidpayorg/gitmark/issues"
+  },
+  "homepage": "https://github.com/solidpayorg/gitmark#readme",
+  "dependencies": {
+    "bitcoinjs-lib": "^5.2.0",
+    "child_process": "^1.0.2",
+    "fs": "^0.0.1-security",
+    "gitlog": "^4.0.4",
+    "minimist": "^1.2.5",
+    "tiny-secp256k1": "^1.1.6"
+  }
+}

package/resitry.json

@@ -0,0 +1,3 @@
+{
+  "gitmark:48a5e0fbf0cf4e660d10d20544e67e003eb973bdb80589cc6560d1bd6c6f1cbb:1": "https://github.com/melvincarvalho/chores"
+}