@open-rights-exchange/orejs/dist/accounts.js

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var Keygen = require('eosjs-keygen').Keygen;
var ACCOUNT_NAME_MAX_LENGTH = 12;
var BASE = 31; // Base 31 allows us to leave out '.', as it's used for account scope
/* Private */
function newAccountTransaction(name, ownerPublicKey, activePublicKey, orePayerAccountName, options) {
    if (options === void 0) { options = {}; }
    var _a = __assign({ broadcast: true, bytes: 2048, permission: 'active', stakedCpu: '0.1000', stakedNet: '0.1000', tokenSymbol: this.chainName === 'ore' ? 'SYS' : 'EOS', transfer: false }, options), broadcast = _a.broadcast, bytes = _a.bytes, permission = _a.permission, stakedCpu = _a.stakedCpu, stakedNet = _a.stakedNet, transfer = _a.transfer, tokenSymbol = _a.tokenSymbol;
    var actions = [{
            account: 'eosio',
            name: 'newaccount',
            authorization: [{
                    actor: orePayerAccountName,
                    permission: permission,
                }],
            data: {
                creator: orePayerAccountName,
                name: name,
                newact: name,
                owner: {
                    threshold: 1,
                    keys: [{
                            key: ownerPublicKey,
                            weight: 1,
                        }],
                    accounts: [],
                    waits: [],
                },
                active: {
                    threshold: 1,
                    keys: [{
                            key: activePublicKey,
                            weight: 1,
                        }],
                    accounts: [],
                    waits: [],
                },
            },
        },
        {
            account: 'eosio',
            name: 'buyrambytes',
            authorization: [{
                    actor: orePayerAccountName,
                    permission: permission,
                }],
            data: {
                payer: orePayerAccountName,
                receiver: name,
                bytes: bytes,
            },
        },
        {
            account: 'eosio',
            name: 'delegatebw',
            authorization: [{
                    actor: orePayerAccountName,
                    permission: permission,
                }],
            data: {
                from: orePayerAccountName,
                receiver: name,
                stake_net_quantity: stakedNet + " " + tokenSymbol,
                stake_cpu_quantity: stakedCpu + " " + tokenSymbol,
                transfer: transfer,
            },
        }];
    return this.transact(actions, broadcast);
}
function timestampEosBase32() {
    // NOTE: Returns a UNIX timestamp, that is EOS base32 encoded
    return eosBase32(Date.now().toString(BASE));
}
function randomEosBase32() {
    // NOTE: Returns a random string, that is EOS base32 encoded
    return eosBase32(Math.random().toString(BASE).substr(2));
}
function generateAccountNameString(prefix) {
    if (prefix === void 0) { prefix = ''; }
    return (prefix + timestampEosBase32() + randomEosBase32()).substr(0, 12);
}
function encrypted(key) {
    if (key.match(/^\{.*\}$/)) {
        return true;
    }
    return false;
}
function encryptKeys(keys, password, salt) {
    var privateKeys = keys.privateKeys, publicKeys = keys.publicKeys;
    var encryptedKeys = {
        privateKeys: {
            owner: encrypted(keys.privateKeys.owner) ? keys.privateKeys.owner : this.encrypt(keys.privateKeys.owner, password, salt).toString(),
            active: encrypted(keys.privateKeys.active) ? keys.privateKeys.active : this.encrypt(keys.privateKeys.active, password, salt).toString()
        },
        publicKeys: __assign({}, publicKeys)
    };
    return encryptedKeys;
}
function getAccountPermissions(oreAccountName) {
    return __awaiter(this, void 0, void 0, function () {
        var account, permissions;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, this.eos.rpc.get_account(oreAccountName)];
                case 1:
                    account = _a.sent();
                    permissions = account.permissions;
                    return [2 /*return*/, permissions];
            }
        });
    });
}
function weightedKey(key, weight) {
    if (weight === void 0) { weight = 1; }
    return { key: key, weight: weight };
}
function weightKeys(keys, weight) {
    if (weight === void 0) { weight = 1; }
    return keys.map(function (key) { return weightedKey(key, weight); });
}
function newPermissionDetails(keys, threshold, weights) {
    if (threshold === void 0) { threshold = 1; }
    if (weights === void 0) { weights = 1; }
    return {
        accounts: [],
        keys: weightKeys.bind(this)(keys, weights),
        threshold: threshold,
        waits: [],
    };
}
function newPermission(keys, permName, parent, threshold, weights) {
    if (parent === void 0) { parent = 'active'; }
    if (threshold === void 0) { threshold = 1; }
    if (weights === void 0) { weights = 1; }
    return {
        parent: parent,
        perm_name: permName,
        required_auth: newPermissionDetails.bind(this)(keys, threshold, weights),
    };
}
function appendPermission(oreAccountName, keys, permName, parent, threshold, weights) {
    if (parent === void 0) { parent = 'active'; }
    if (threshold === void 0) { threshold = 1; }
    if (weights === void 0) { weights = 1; }
    return __awaiter(this, void 0, void 0, function () {
        var perms, existingPerm, weightedKeys, newPerm;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, getAccountPermissions.bind(this)(oreAccountName)];
                case 1:
                    perms = _a.sent();
                    existingPerm = perms.find(function (perm) { return perm.perm_name === permName; });
                    if (existingPerm) { // NOTE: Add new keys & update the parent permission
                        weightedKeys = weightKeys.bind(this)(keys, weights);
                        existingPerm.required_auth.keys = existingPerm.required_auth.keys.concat(weightedKeys);
                        existingPerm.parent = parent;
                        return [2 /*return*/, existingPerm];
                    }
                    else {
                        newPerm = newPermission.bind(this)(keys, permName, parent, threshold, weights);
                        return [2 /*return*/, newPerm];
                    }
                    return [2 /*return*/];
            }
        });
    });
}
// NOTE: This method is specific to creating authVerifier keys...
function generateAuthKeys(oreAccountName, permName, code, action, broadcast) {
    return __awaiter(this, void 0, void 0, function () {
        var authKeys, options;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, Keygen.generateMasterKeys()];
                case 1:
                    authKeys = _a.sent();
                    options = { broadcast: broadcast, authPermission: 'owner', links: [{ code: code, type: action }] };
                    return [4 /*yield*/, addPermission.bind(this)(oreAccountName, [authKeys.publicKeys.active], permName, 'active', options)];
                case 2:
                    _a.sent();
                    return [2 /*return*/, authKeys];
            }
        });
    });
}
function createOreAccountWithKeys(activePublicKey, ownerPublicKey, orePayerAccountName, options) {
    if (options === void 0) { options = {}; }
    return __awaiter(this, void 0, void 0, function () {
        var oreAccountName, _a, transaction;
        var _this = this;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    options = __assign({ confirm: true, accountNamePrefix: 'ore' }, options);
                    _a = options.oreAccountName;
                    if (_a) return [3 /*break*/, 2];
                    return [4 /*yield*/, generateAccountName.bind(this)(options.accountNamePrefix)];
                case 1:
                    _a = (_b.sent());
                    _b.label = 2;
                case 2:
                    oreAccountName = _a;
                    if (!options.confirm) return [3 /*break*/, 4];
                    return [4 /*yield*/, this.awaitTransaction(function () { return newAccountTransaction.bind(_this)(oreAccountName, ownerPublicKey, activePublicKey, orePayerAccountName, options); })];
                case 3:
                    transaction = _b.sent();
                    return [3 /*break*/, 6];
                case 4: return [4 /*yield*/, newAccountTransaction.bind(this)(oreAccountName, ownerPublicKey, activePublicKey, orePayerAccountName, options)];
                case 5:
                    transaction = _b.sent();
                    _b.label = 6;
                case 6: return [2 /*return*/, { oreAccountName: oreAccountName, transaction: transaction }];
            }
        });
    });
}
function generateOreAccountAndEncryptedKeys(password, salt, ownerPublicKey, orePayerAccountName, options) {
    if (options === void 0) { options = {}; }
    return __awaiter(this, void 0, void 0, function () {
        var keys, _a, oreAccountName, transaction;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0: return [4 /*yield*/, generateEncryptedKeys.bind(this)(password, salt, options.keys)];
                case 1:
                    keys = _b.sent();
                    return [4 /*yield*/, createOreAccountWithKeys.bind(this)(keys.publicKeys.active, ownerPublicKey, orePayerAccountName, options)];
                case 2:
                    _a = _b.sent(), oreAccountName = _a.oreAccountName, transaction = _a.transaction;
                    return [2 /*return*/, { oreAccountName: oreAccountName, transaction: transaction, keys: keys }];
            }
        });
    });
}
// Creates an account, without verifier auth keys
function createAccount(password, salt, ownerPublicKey, orePayerAccountName, options) {
    if (options === void 0) { options = {}; }
    return __awaiter(this, void 0, void 0, function () {
        var broadcast, _a, oreAccountName, transaction, keys;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    options = __assign({ broadcast: true }, options);
                    broadcast = options.broadcast;
                    return [4 /*yield*/, generateOreAccountAndEncryptedKeys.bind(this)(password, salt, ownerPublicKey, orePayerAccountName, options)];
                case 1:
                    _a = _b.sent(), oreAccountName = _a.oreAccountName, transaction = _a.transaction, keys = _a.keys;
                    return [2 /*return*/, {
                            oreAccountName: oreAccountName,
                            privateKey: keys.privateKeys.active,
                            publicKey: keys.publicKeys.active,
                            keys: keys,
                            transaction: transaction,
                        }];
            }
        });
    });
}
/* Public */
function addPermission(authAccountName, keys, permissionName, parentPermission, options) {
    if (options === void 0) { options = {}; }
    return __awaiter(this, void 0, void 0, function () {
        var authPermission, _a, links, _b, broadcast, perm, permission, parent, auth, actions;
        return __generator(this, function (_c) {
            switch (_c.label) {
                case 0:
                    options = __assign({ authPermission: 'active' }, options);
                    authPermission = options.authPermission, _a = options.links, links = _a === void 0 ? [] : _a, _b = options.broadcast, broadcast = _b === void 0 ? true : _b;
                    return [4 /*yield*/, appendPermission.bind(this)(authAccountName, keys, permissionName, parentPermission)];
                case 1:
                    perm = _c.sent();
                    permission = perm.perm_name, parent = perm.parent, auth = perm.required_auth;
                    actions = [{
                            account: 'eosio',
                            name: 'updateauth',
                            authorization: [{
                                    actor: authAccountName,
                                    permission: authPermission,
                                }],
                            data: {
                                account: authAccountName,
                                permission: permission,
                                parent: parent,
                                auth: auth,
                            },
                        }];
                    links.forEach(function (link) {
                        var code = link.code, type = link.type;
                        actions.push({
                            account: 'eosio',
                            name: 'linkauth',
                            authorization: [{
                                    actor: authAccountName,
                                    permission: authPermission,
                                }],
                            data: {
                                account: authAccountName,
                                code: code,
                                type: type,
                                requirement: permission,
                            }
                        });
                    });
                    return [2 /*return*/, this.transact(actions, broadcast)];
            }
        });
    });
}
// NOTE: When setting keys for `createKeyPair`, all keys are completely overriden, not just partially
function createKeyPair(password, salt, authAccountName, permissionName, options) {
    if (options === void 0) { options = {}; }
    return __awaiter(this, void 0, void 0, function () {
        var _a, keys, parentPermission;
        var _this = this;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    _a = { confirm: true, parentPermission: 'active' };
                    return [4 /*yield*/, generateEncryptedKeys.bind(this)(password, salt)];
                case 1:
                    options = __assign.apply(void 0, [(_a.keys = _b.sent(), _a), options]);
                    keys = options.keys, parentPermission = options.parentPermission;
                    if (!options.confirm) return [3 /*break*/, 3];
                    return [4 /*yield*/, this.awaitTransaction(function () {
                            return addPermission.bind(_this)(authAccountName, [keys.publicKeys.active], permissionName, parentPermission, options);
                        })];
                case 2:
                    _b.sent();
                    return [3 /*break*/, 5];
                case 3: return [4 /*yield*/, addPermission.bind(this)(authAccountName, [keys.publicKeys.active], permissionName, parentPermission, options)];
                case 4:
                    _b.sent();
                    _b.label = 5;
                case 5: return [2 /*return*/, keys];
            }
        });
    });
}
function createBridgeAccount(password, salt, authorizingAccount, options) {
    return __awaiter(this, void 0, void 0, function () {
        var _a, transaction, keys;
        var _this = this;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    _a = {};
                    return [4 /*yield*/, generateAccountName.bind(this)(options.accountNamePrefix)];
                case 1:
                    options = __assign.apply(void 0, [(_a.oreAccountName = _b.sent(), _a.confirm = true, _a), options]);
                    return [4 /*yield*/, generateEncryptedKeys.bind(this)(password, salt, options.keys)];
                case 2:
                    keys = _b.sent();
                    if (!options.confirm) return [3 /*break*/, 4];
                    return [4 /*yield*/, this.awaitTransaction(function () {
                            return _this.createNewAccount(authorizingAccount, keys, options);
                        })];
                case 3:
                    transaction = _b.sent();
                    return [3 /*break*/, 6];
                case 4: return [4 /*yield*/, this.createNewAccount(authorizingAccount, keys, options)];
                case 5:
                    transaction = _b.sent();
                    _b.label = 6;
                case 6: return [2 /*return*/, {
                        oreAccountName: options.oreAccountName,
                        privateKey: keys.privateKeys.active,
                        publicKey: keys.publicKeys.active,
                        keys: keys,
                        transaction: transaction,
                    }];
            }
        });
    });
}
// Creates an account, with verifier auth keys for ORE, and without for EOS
function createOreAccount(password, salt, ownerPublicKey, orePayerAccountName, options) {
    if (options === void 0) { options = {}; }
    return __awaiter(this, void 0, void 0, function () {
        var broadcast, returnInfo, verifierAuthKeys;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    broadcast = options.broadcast;
                    return [4 /*yield*/, createAccount.bind(this)(password, salt, ownerPublicKey, orePayerAccountName, options)];
                case 1:
                    returnInfo = _a.sent();
                    if (!(this.chainName === 'ore')) return [3 /*break*/, 3];
                    return [4 /*yield*/, generateAuthKeys.bind(this)(returnInfo.oreAccountName, 'authverifier', 'token.ore', 'approve', broadcast)];
                case 2:
                    verifierAuthKeys = _a.sent();
                    returnInfo.verifierAuthKey = verifierAuthKeys.privateKeys.active;
                    returnInfo.verifierAuthPublicKey = verifierAuthKeys.publicKeys.active;
                    _a.label = 3;
                case 3: return [2 /*return*/, returnInfo];
            }
        });
    });
}
function eosBase32(base32String) {
    // NOTE: Returns valid EOS base32, which is different than the standard JS base32 implementation
    return base32String
        .replace(/0/g, 'v')
        .replace(/6/g, 'w')
        .replace(/7/g, 'x')
        .replace(/8/g, 'y')
        .replace(/9/g, 'z');
}
// Recursively generates account names, until a uniq name is generated...
function generateAccountName(prefix, checkIfNameUsedOnChain) {
    if (prefix === void 0) { prefix = ''; }
    if (checkIfNameUsedOnChain === void 0) { checkIfNameUsedOnChain = true; }
    return __awaiter(this, void 0, void 0, function () {
        var accountName, nameAlreadyExists;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    accountName = generateAccountNameString.bind(this)(prefix);
                    nameAlreadyExists = false;
                    if (!checkIfNameUsedOnChain) return [3 /*break*/, 2];
                    return [4 /*yield*/, getNameAlreadyExists.bind(this)(accountName)];
                case 1:
                    nameAlreadyExists = _a.sent();
                    _a.label = 2;
                case 2:
                    if (nameAlreadyExists) {
                        return [2 /*return*/, generateAccountName.bind(this)()];
                    }
                    else {
                        return [2 /*return*/, accountName];
                    }
                    return [2 /*return*/];
            }
        });
    });
}
function generateEncryptedKeys(password, salt, predefinedKeys) {
    if (predefinedKeys === void 0) { predefinedKeys = {}; }
    return __awaiter(this, void 0, void 0, function () {
        var keys, _a, publicKeys, _b, privateKeys, encryptedKeys;
        return __generator(this, function (_c) {
            switch (_c.label) {
                case 0: return [4 /*yield*/, Keygen.generateMasterKeys()];
                case 1:
                    keys = _c.sent();
                    _a = predefinedKeys.publicKeys, publicKeys = _a === void 0 ? {} : _a, _b = predefinedKeys.privateKeys, privateKeys = _b === void 0 ? {} : _b;
                    keys = __assign({}, keys, { publicKeys: __assign({}, keys.publicKeys, publicKeys), privateKeys: __assign({}, keys.privateKeys, privateKeys) });
                    encryptedKeys = encryptKeys.bind(this)(keys, password, salt);
                    return [2 /*return*/, encryptedKeys];
            }
        });
    });
}
function getNameAlreadyExists(accountName) {
    return __awaiter(this, void 0, void 0, function () {
        var e_1;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    _a.trys.push([0, 2, , 3]);
                    return [4 /*yield*/, this.eos.rpc.get_account(accountName)];
                case 1:
                    _a.sent();
                    return [2 /*return*/, true];
                case 2:
                    e_1 = _a.sent();
                    return [2 /*return*/, false];
                case 3: return [2 /*return*/];
            }
        });
    });
}
module.exports = {
    addPermission: addPermission,
    createKeyPair: createKeyPair,
    createBridgeAccount: createBridgeAccount,
    createOreAccount: createOreAccount,
    eosBase32: eosBase32,
    generateAccountName: generateAccountName,
    generateEncryptedKeys: generateEncryptedKeys,
    getNameAlreadyExists: getNameAlreadyExists
};
//# sourceMappingURL=accounts.js.map