cipher-ethereum/dist/Message.js

An Ethereum library used by Cipher Browser, a mobile Ethereum client

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.Message = undefined;

var _util = require('./util');

var _Address = require('./Address');

var _elliptic = require('elliptic');

var secp256k1 = new _elliptic.ec('secp256k1');
var Message = /** @class */function () {
    function Message(message) {
        this._hash = null;
        this._message = message;
    }
    Object.defineProperty(Message.prototype, "message", {
        get: function () {
            return this._message;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Message.prototype, "hash", {
        get: function () {
            if (this._hash) {
                return this._hash;
            }
            var prefix = Buffer.from("\u0019Ethereum Signed Message:\n" + this._message.length, 'utf8');
            var messageToSign = Buffer.concat([prefix, this._message]);
            this._hash = (0, _util.keccak256)(messageToSign);
            return this._hash;
        },
        enumerable: false,
        configurable: true
    });
    Message.prototype.sign = function (privateKey) {
        var sig = secp256k1.keyFromPrivate(privateKey).sign(this.hash, { canonical: true });
        var sigBuf = Buffer.alloc(65);
        var offset = 0;
        // copy r
        var r = (0, _util.bnToBuffer)(sig.r);
        offset += 32 - r.length;
        offset += r.copy(sigBuf, offset);
        // copy s
        var s = (0, _util.bnToBuffer)(sig.s);
        offset += 32 - s.length;
        offset += s.copy(sigBuf, offset);
        // copy v
        sigBuf.writeUInt8((sig.recoveryParam || 0) + 27, offset);
        return sigBuf;
    };
    Message.prototype.ecRecover = function (signature) {
        if (signature.length !== 65) {
            throw new Error('Invalid signature');
        }
        var recoveryParam = signature[signature.length - 1] - 27;
        var sig = {
            r: signature.slice(0, 32),
            s: signature.slice(32, 64)
        };
        var point = secp256k1.recoverPubKey(this.hash, sig, recoveryParam);
        var pubKey = Buffer.from(point.encode('hex', true), 'hex');
        return _Address.Address.from(pubKey).address;
    };
    return Message;
}();
exports.Message = Message;