escrow2.jsx.exp

/* Lexon-generated Javascript 

   code:        Escrow

   file:        escrow2.lex

   compiler:    lexon 0.3 alpha 93 U

   grammar:     0.2.20 / subset 0.3.8 alpha 79 - English / Reyes

   backend:     javascript 0.3.93 U

   target:      node 14.1+

   parameters:  --javascript  --feedback  --log  --chaining  --signatures  --persistence  --comment 

*/

var fs = require('fs');
var crypto = require('crypto');
var serialize = require('serialize-javascript');
var prompt = require('prompt-sync')();
var last_caller;
var last_passphrase;

/**
 **
 ** Main Escrow contract system
 **
 **/

/** LEX Escrow.
 *
 *	"Payer" is	 a person.
 *	"Payee" is A person.
 *	"Arbiter" is  a person.
 *	"Fee" is	aN  amount.
 *
 *	The Payer pays an amount into escrow, appoints the Payee, appoints the Arbiter, and fixes the Fee.
**/

module.exports = class Escrow {

    constructor(payer, amount, payee, arbiter, fee) {

        let main = this;

        /* object members: skip for restoring serialized object */
        if(typeof payer !== 'undefined') {
            this._escrow = 0;
            this.payer = payer;
            this.payee = payee;
            this.arbiter = arbiter;
            this.fee = fee;
            this.logname = 'log';

            /* start log - overwrites previous by same name */
            fs.writeFileSync(this.logname, "Lexon log " + (new Date).toLocaleString('en-US') + "\n", ()=>{});
            this._pay(caller, this.payer, 'escrow', amount);
            this.log(payer, "✓ Payee appointed");
            this.log(payer, "✓ Arbiter appointed");
            this.log(payer, "✓ Fee fixed");
        }

        /* restore object from file - must be below class definition */
        if(typeof payer === 'undefined') {
            console.log("> restore from file 'state'");
            var data = fs.readFileSync('state', ()=>{});
            var live = eval('(' + data + ')');
            Object.assign(this, live);
        }
    }


    /* Pay Out clause */

    /*
     *  CLAUSE: Pay Out.
     *  The Arbiter may pay from escrow the Fee to themselves, and afterwards pay the remainder of the escrow to the Payee.
     */
    pay_out(caller)  {
        if(caller == this.arbiter) {
            this._pay(caller, 'escrow', this.arbiter, this.fee);
            this._pay(caller, 'escrow', this.payee, this._escrow);
        } else {
            return 'not permitted.';
        }
        return 'done.';
    }

    /* Pay Back clause */

    /*
     *  CLAUSE: Pay Back.
     *  The Arbiter may pay from escrow the Fee to themselves, and afterwards return the remainder of the escrow to the Payer.
     */
    pay_back(caller)  {
        if(caller == this.arbiter) {
            this._pay(caller, 'escrow', this.arbiter, this.fee);
            this._pay(caller, 'escrow', this.payer, this._escrow);
        } else {
            return 'not permitted.';
        }
        return 'done.';
    }

    /* built-in convenience function to view state change log. */
    history() {
        fs.readFile(this.logname, (e,d)=>{console.log(d.toString())});
    }

    /* built-in serialization and storage of entire contract system state. */
    persist() {
        console.log('> persisting');
        var data = serialize(this, {space: 4});
        fs.writeFileSync('state', data, ()=>{});
    }

    /* re-instate entire contract system from serialized file store */
    static load() {
        return new Escrow();
    }

    /* built-in logging of state changes. */
    log(caller, msg) {
        console.log(msg);
        let stamp = (new Date()).toLocaleString('en-US');
        var entry = `⌽  ${stamp} ✦ ${caller} ${msg}`;
        var passphrase = this.sync_passphrase(caller);
        var pem = fs.readFileSync(caller + '.key');
        var key = pem.toString('ascii');
        var sign = crypto.createSign('RSA-SHA256');
        sign.update(entry);
        var sig = sign.sign({ key: key, passphrase: passphrase }, 'hex');
        fs.appendFileSync(this.logname, `${entry} ❈ ${sig}\n`);
        let pay = fs.readFileSync(this.logname);
        let hash = crypto.createHash('sha256').update(pay);
        fs.appendFileSync(this.logname, '⧉ ' + hash.digest('hex').substr(0, 12) + " ");
    }

    /* built-in password query for private key file, with cache. */
    sync_passphrase(caller) {
        if(!caller) process.exit('no caller information');
        if(caller == last_caller) return last_passphrase;
        last_caller = caller;
        return last_passphrase = prompt('enter pass phrase for ' + caller + ': ', {echo: ''});
    }

    /* built-in convenience function to create keys for users. */
    static create_key(name, passphrase) {
        const { publicKey, privateKey } =
            crypto.generateKeyPairSync('rsa',
                { modulusLength: 2048,
                    publicKeyEncoding: { type: 'spki', format: 'pem' },
                    privateKeyEncoding: { type: 'pkcs8', format: 'pem', cipher: 'aes-256-cbc', passphrase: passphrase }});

        fs.writeFileSync(name+'.key', privateKey);
        fs.writeFileSync(name+'.pub', publicKey);
        return true;
    }

    /* built-in pay message */
    _pay(caller, from, to, amount) {
        this.log(caller, `➠ system message: pay ${amount} from ${from} to ${to}.`);
        if(from == 'escrow') main._escrow -= amount;
        if(to == 'escrow') main._escrow += amount;
    }
}

/* end */