@open-rights-exchange/orejs
Version:
Orejs is a Javascript helper library to provide simple high-level access to the ore-protocol. Orejs uses eosJS as a wrapper to the EOS blockchain.
818 lines • 43.3 kB
JavaScript
"use strict";
var __assign = (this && this.__assign) || function () {
__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;
};
return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
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) : adopt(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 __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spread = (this && this.__spread) || function () {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};
var Keygen = require('eosjs-keygen').Keygen;
var isValidPublicKey = require('./eos').isValidPublicKey;
var _a = require('./compose'), ChainAction = _a.ChainAction, composeAction = _a.composeAction;
var ACCOUNT_NAME_MAX_LENGTH = 12;
var BASE = 31; // Base 31 allows us to leave out '.', as it's used for account scope
/* Private */
// gets the input values(blocksToCheck, checkInterval, getBlockAttempts) required for the awaitTranaction method
function getAwaitTransactionOptions(options) {
var awaitTransactionOptions = {};
(awaitTransactionOptions.blocksToCheck = options.blocksToCheck, awaitTransactionOptions.checkInterval = options.checkInterval, awaitTransactionOptions.getBlockAttempts = options.getBlockAttempts);
return awaitTransactionOptions;
}
function newAccountTransaction(name, ownerPublicKey, activePublicKey, orePayerAccountName, options) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var _a, broadcast, permission, tokenSymbol, _b, pricekey, _c, referral, args, action;
return __generator(this, function (_d) {
_a = __assign({ broadcast: true, permission: 'active', tokenSymbol: this.chainName === 'ore' ? 'ORE' : 'EOS' }, options), broadcast = _a.broadcast, permission = _a.permission, tokenSymbol = _a.tokenSymbol, _b = _a.pricekey, pricekey = _b === void 0 ? 1 : _b, _c = _a.referral, referral = _c === void 0 ? '' : _c;
args = { activePublicKey: activePublicKey, name: name, orePayerAccountName: orePayerAccountName, ownerPublicKey: ownerPublicKey, permission: permission, pricekey: pricekey, referral: referral };
action = composeAction(ChainAction.Ore_CreateAccount, args);
return [2 /*return*/, this.transact([action], 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];
}
newPerm = newPermission.bind(this)(keys, permName, parent, threshold, weights);
return [2 /*return*/, newPerm];
}
});
});
}
// 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', false, 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, confirm, awaitTransactionOptions, 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;
confirm = options.confirm;
awaitTransactionOptions = getAwaitTransactionOptions(options);
return [4 /*yield*/, this.sendTransaction(function () { return newAccountTransaction.bind(_this)(oreAccountName, ownerPublicKey, activePublicKey, orePayerAccountName, options); }, confirm, awaitTransactionOptions)];
case 3:
transaction = _b.sent();
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, newAccountName, _a, oreAccountName, transaction, keys;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
options = __assign({ broadcast: true }, options);
broadcast = options.broadcast, newAccountName = options.oreAccountName;
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
}];
}
});
});
}
// returns an array of actions to delete permissions
// every permission input is being deleted
function composeDeleteAuthActions(permissions, authAccountName, authPermission) {
return __awaiter(this, void 0, void 0, function () {
var actions;
return __generator(this, function (_a) {
actions = [];
permissions.forEach(function (permission) {
var args = { authAccountName: authAccountName, authPermission: authPermission, permission: permission };
var action = composeAction(ChainAction.Account_DeleteAuth, args);
actions.push(action);
});
return [2 /*return*/, actions];
});
});
}
// returns an array of actions to link to an app permission
// every { contract, action } input pair is linked to the app permission
function composeLinkActions(links, permission, authAccountName, authPermission) {
return __awaiter(this, void 0, void 0, function () {
var actions;
return __generator(this, function (_a) {
actions = [];
links.forEach(function (link) {
var code = link.code, type = link.type;
var args = { authAccountName: authAccountName, authPermission: authPermission, code: code, permission: permission, type: type };
var action = composeAction(ChainAction.Account_LinkAuth, args);
actions.push(action);
});
return [2 /*return*/, actions];
});
});
}
// returns a list of actions to unlink to an app permission
// every { contract, action } input pair is linked to the app permission
function composeUnlinkActions(links, authAccountName, authPermission) {
return __awaiter(this, void 0, void 0, function () {
var actions;
return __generator(this, function (_a) {
actions = [];
links.forEach(function (link) {
var code = link.code, type = link.type;
var args = { authAccountName: authAccountName, authPermission: authPermission, code: code, type: type };
var action = composeAction(ChainAction.Account_UnlinkAuth, args);
actions.push(action);
});
return [2 /*return*/, actions];
});
});
}
function addFirstAuthAction(actions, firstAuthorizerAction) {
if (!this.isNullOrEmpty(firstAuthorizerAction)) {
actions = __spread([firstAuthorizerAction], actions);
}
return actions;
}
/* Public */
// gets the account details from the chain network and checks if the account has a specific permission
function checkIfAccountHasPermission(oreAccountName, permName) {
return __awaiter(this, void 0, void 0, function () {
var perms;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, getAccountPermissions.bind(this)(oreAccountName)];
case 1:
perms = _a.sent();
return [2 /*return*/, !!(perms.find(function (perm) { return perm.perm_name === permName; }))];
}
});
});
}
function addPermission(authAccountName, keys, permissionName, parentPermission, overridePermission, options) {
if (overridePermission === void 0) { overridePermission = false; }
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var perm, _a, authPermission, _b, links, _c, broadcast, _d, confirm, _e, firstAuthorizerAction, permission, parent, auth, args, action, actions, linkActions, awaitTransactionOptions, transaction;
var _this = this;
return __generator(this, function (_f) {
switch (_f.label) {
case 0:
_a = options.authPermission, authPermission = _a === void 0 ? 'active' : _a, _b = options.links, links = _b === void 0 ? [] : _b, _c = options.broadcast, broadcast = _c === void 0 ? true : _c, _d = options.confirm, confirm = _d === void 0 ? true : _d, _e = options.firstAuthorizerAction, firstAuthorizerAction = _e === void 0 ? {} : _e;
if (!overridePermission) return [3 /*break*/, 2];
return [4 /*yield*/, newPermission.bind(this)(keys, permissionName, parentPermission)];
case 1:
perm = _f.sent();
return [3 /*break*/, 4];
case 2: return [4 /*yield*/, appendPermission.bind(this)(authAccountName, keys, permissionName, parentPermission)];
case 3:
perm = _f.sent();
_f.label = 4;
case 4:
permission = perm.perm_name, parent = perm.parent, auth = perm.required_auth;
args = { auth: auth, authAccountName: authAccountName, authPermission: authPermission, parent: parent, permission: permission };
action = composeAction(ChainAction.Account_UpdateAuth, args);
actions = [action];
(actions = addFirstAuthAction.bind(this)(actions, firstAuthorizerAction));
if (!(links.length > 0)) return [3 /*break*/, 6];
return [4 /*yield*/, composeLinkActions(links, permission, authAccountName, authPermission)];
case 5:
linkActions = _f.sent();
actions = actions.concat(linkActions);
_f.label = 6;
case 6:
awaitTransactionOptions = getAwaitTransactionOptions(options);
return [4 /*yield*/, this.sendTransaction(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
return [2 /*return*/, this.transact(actions, broadcast)];
}); }); }, confirm, awaitTransactionOptions)];
case 7:
transaction = _f.sent();
return [2 /*return*/, transaction];
}
});
});
}
function deletePermissions(authAccountName, permissions, options) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var authPermission, _a, links, _b, broadcast, _c, confirm, firstAuthorizerAction, deleteActions, awaitTransactionOptions, transaction;
var _this = this;
return __generator(this, function (_d) {
switch (_d.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, _c = options.confirm, confirm = _c === void 0 ? true : _c, firstAuthorizerAction = options.firstAuthorizerAction;
return [4 /*yield*/, composeDeleteAuthActions(permissions, authAccountName, authPermission)];
case 1:
deleteActions = _d.sent();
(deleteActions = addFirstAuthAction.bind(this)(deleteActions, firstAuthorizerAction));
awaitTransactionOptions = getAwaitTransactionOptions(options);
return [4 /*yield*/, this.sendTransaction(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
return [2 /*return*/, this.transact(deleteActions, broadcast)];
}); }); }, confirm, awaitTransactionOptions)];
case 2:
transaction = _d.sent();
return [2 /*return*/, transaction];
}
});
});
}
// links actions for a given account to an app permission
function linkActionsToPermission(links, permission, authAccountName, authPermission, broadcast, options) {
if (broadcast === void 0) { broadcast = true; }
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var _a, confirm, _b, firstAuthorizerAction, actions, awaitTransactionOptions, transaction;
var _this = this;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_a = options.confirm, confirm = _a === void 0 ? true : _a, _b = options.firstAuthorizerAction, firstAuthorizerAction = _b === void 0 ? {} : _b;
return [4 /*yield*/, composeLinkActions(links, permission, authAccountName, authPermission)];
case 1:
actions = _c.sent();
(actions = addFirstAuthAction.bind(this)(actions, firstAuthorizerAction));
awaitTransactionOptions = getAwaitTransactionOptions(options);
return [4 /*yield*/, this.sendTransaction(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
return [2 /*return*/, this.transact(actions, broadcast)];
}); }); }, confirm, awaitTransactionOptions)];
case 2:
transaction = _c.sent();
return [2 /*return*/, transaction];
}
});
});
}
function unlinkActionsToPermission(links, authAccountName, authPermission, broadcast, options) {
if (broadcast === void 0) { broadcast = true; }
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var _a, confirm, firstAuthorizerAction, actions, awaitTransactionOptions, transaction;
var _this = this;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
_a = options.confirm, confirm = _a === void 0 ? true : _a, firstAuthorizerAction = options.firstAuthorizerAction;
return [4 /*yield*/, composeUnlinkActions(links, authAccountName, authPermission)];
case 1:
actions = _b.sent();
(actions = addFirstAuthAction.bind(this)(actions, firstAuthorizerAction));
awaitTransactionOptions = getAwaitTransactionOptions(options);
return [4 /*yield*/, this.sendTransaction(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
return [2 /*return*/, this.transact(actions, broadcast)];
}); }); }, confirm, awaitTransactionOptions)];
case 2:
transaction = _b.sent();
return [2 /*return*/, transaction];
}
});
});
}
// If account already exists, check if active keys on-chain are null. If so, the account name is usable
// If account already exists but active keys are not null, throw an error
function checkIfAccountNameUsable(accountName) {
return __awaiter(this, void 0, void 0, function () {
var key, permissions, activePermission, requiredAuth, keys;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
key = null;
return [4 /*yield*/, getAccountPermissions.bind(this)(accountName)];
case 1:
permissions = _a.sent();
activePermission = permissions.find(function (perm) { return perm.perm_name === 'active'; });
requiredAuth = activePermission.required_auth;
keys = requiredAuth.keys;
key = keys.find(function (k) { return k.key === _this.unusedAccountPubKey; });
// only unusedAccountPubKey should exist in the active key
if (!this.isNullOrEmpty(key) && keys.length === 1) {
return [2 /*return*/, true];
}
throw new Error("Account already in use: " + accountName);
}
});
});
}
// replace the unusedAccountPubKey with the new user's key for the active permission
// any account with active key set to unusedAccountPubKey means that account can be reused
function reuseAccount(authAccountName, keys, authPermission, parentPermission, permissionName, options) {
if (authPermission === void 0) { authPermission = 'owner'; }
if (parentPermission === void 0) { parentPermission = 'owner'; }
if (permissionName === void 0) { permissionName = 'active'; }
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var transaction, _a, confirm_1, awaitTransactionOptions, error_1;
var _this = this;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
transaction = null;
_b.label = 1;
case 1:
_b.trys.push([1, 3, , 4]);
options = __assign({ confirm: true, authPermission: authPermission }, options);
_a = options.confirm, confirm_1 = _a === void 0 ? true : _a;
awaitTransactionOptions = getAwaitTransactionOptions(options);
return [4 /*yield*/, this.sendTransaction(function () { return addPermission.bind(_this)(authAccountName, [keys.publicKeys.active], permissionName, parentPermission, true, options); }, confirm_1, awaitTransactionOptions)];
case 2:
transaction = _b.sent();
return [3 /*break*/, 4];
case 3:
error_1 = _b.sent();
throw new Error("Error in reuseAccount: " + error_1);
case 4: return [2 /*return*/, transaction];
}
});
});
}
function exportAccount(authAccountName, publicKeys) {
return __awaiter(this, void 0, void 0, function () {
var owner, active, activeTransaction, ownerTransaction, options_1, _a, confirm_2, awaitTransactionOptions, error_2;
var _this = this;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
owner = publicKeys.owner, active = publicKeys.active;
activeTransaction = null;
ownerTransaction = null;
if (!isValidPublicKey(active) || !isValidPublicKey(owner)) {
throw new Error('Error in exportAccount: Valid public keys needs to be provided for both active and owner keys.');
}
_b.label = 1;
case 1:
_b.trys.push([1, 4, , 5]);
options_1 = {
confirm: true,
authPermission: 'owner'
};
_a = options_1.confirm, confirm_2 = _a === void 0 ? true : _a;
awaitTransactionOptions = getAwaitTransactionOptions(options_1);
return [4 /*yield*/, this.sendTransaction(function () { return addPermission.bind(_this)(authAccountName, [active], 'active', 'owner', true, options_1); }, confirm_2, awaitTransactionOptions)];
case 2:
activeTransaction = _b.sent();
return [4 /*yield*/, this.sendTransaction(function () { return addPermission.bind(_this)(authAccountName, [owner], 'owner', '', true, options_1); }, confirm_2, awaitTransactionOptions)];
case 3:
ownerTransaction = _b.sent();
return [3 /*break*/, 5];
case 4:
error_2 = _b.sent();
throw new Error("Error in exportAccount: " + error_2);
case 5: return [2 /*return*/, { activeTransaction: activeTransaction, ownerTransaction: ownerTransaction }];
}
});
});
}
// 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, transaction;
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;
return [4 /*yield*/, addPermission.bind(this)(authAccountName, [keys.publicKeys.active], permissionName, parentPermission, false, options)];
case 2:
transaction = _b.sent();
return [2 /*return*/, keys];
}
});
});
}
function createBridgeAccount(password, salt, authorizingAccount, options) {
return __awaiter(this, void 0, void 0, function () {
var oreAccountName, isAccountUsable, transaction, nameAlreadyExists, _a, confirm, newAccountName, keys, error_3, awaitTransactionOptions, error_4;
var _this = this;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
oreAccountName = null;
isAccountUsable = false;
transaction = null;
nameAlreadyExists = false;
_a = options.confirm, confirm = _a === void 0 ? true : _a, newAccountName = options.oreAccountName;
return [4 /*yield*/, generateEncryptedKeys.bind(this)(password, salt, options.keys)];
case 1:
keys = _b.sent();
if (!newAccountName) return [3 /*break*/, 3];
return [4 /*yield*/, getNameAlreadyExists.bind(this)(newAccountName)];
case 2:
nameAlreadyExists = _b.sent();
_b.label = 3;
case 3:
if (!nameAlreadyExists) return [3 /*break*/, 9];
oreAccountName = newAccountName;
_b.label = 4;
case 4:
_b.trys.push([4, 8, , 9]);
return [4 /*yield*/, checkIfAccountNameUsable.bind(this)(newAccountName)];
case 5:
isAccountUsable = _b.sent();
if (!isAccountUsable) return [3 /*break*/, 7];
return [4 /*yield*/, reuseAccount.bind(this)(oreAccountName, keys, 'owner', 'owner', 'active', options)];
case 6:
transaction = _b.sent();
_b.label = 7;
case 7: return [3 /*break*/, 9];
case 8:
error_3 = _b.sent();
throw new Error("Error creating bridge account: Provided account name cannot be used for the new account: " + newAccountName + " " + error_3);
case 9:
if (!(!nameAlreadyExists || this.isNullOrEmpty(newAccountName))) return [3 /*break*/, 16];
_b.label = 10;
case 10:
_b.trys.push([10, 15, , 16]);
if (!(!this.isNullOrEmpty(newAccountName) && !nameAlreadyExists)) return [3 /*break*/, 11];
oreAccountName = newAccountName;
return [3 /*break*/, 13];
case 11: return [4 /*yield*/, generateAccountName.bind(this)(options.accountNamePrefix)];
case 12:
oreAccountName = _b.sent();
_b.label = 13;
case 13:
options = __assign(__assign({}, options), { oreAccountName: oreAccountName,
confirm: confirm });
awaitTransactionOptions = getAwaitTransactionOptions(options);
return [4 /*yield*/, this.sendTransaction(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
return [2 /*return*/, this.createNewAccount(authorizingAccount, keys, options)];
}); }); }, confirm, awaitTransactionOptions)];
case 14:
transaction = _b.sent();
return [3 /*break*/, 16];
case 15:
error_4 = _b.sent();
throw new Error("Error creating bridge account: " + oreAccountName + " " + error_4);
case 16: return [2 /*return*/, {
oreAccountName: 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 oreAccountName, transaction, verifierAuthKey, verifierAuthPublicKey, isAccountUsable, keys, broadcast, _a, confirm, newAccountName, nameAlreadyExists, error_5, activePublicKey_1, awaitTransactionOptions, error_6, verifierAuthKeys;
var _this = this;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
isAccountUsable = false;
return [4 /*yield*/, generateEncryptedKeys.bind(this)(password, salt, options.keys)];
case 1:
keys = _b.sent();
broadcast = options.broadcast, _a = options.confirm, confirm = _a === void 0 ? true : _a, newAccountName = options.oreAccountName;
return [4 /*yield*/, getNameAlreadyExists.bind(this)(newAccountName)];
case 2:
nameAlreadyExists = _b.sent();
if (!nameAlreadyExists) return [3 /*break*/, 8];
oreAccountName = newAccountName;
_b.label = 3;
case 3:
_b.trys.push([3, 7, , 8]);
return [4 /*yield*/, checkIfAccountNameUsable.bind(this)(newAccountName)];
case 4:
isAccountUsable = _b.sent();
if (!isAccountUsable) return [3 /*break*/, 6];
return [4 /*yield*/, reuseAccount.bind(this)(oreAccountName, keys, 'owner', 'owner', 'active', options)];
case 5:
transaction = _b.sent();
_b.label = 6;
case 6: return [3 /*break*/, 8];
case 7:
error_5 = _b.sent();
throw new Error("Error creating account: Provided account name cannot be used for the new account: " + newAccountName + " " + error_5);
case 8:
if (!(!nameAlreadyExists || this.isNullOrEmpty(newAccountName))) return [3 /*break*/, 15];
_b.label = 9;
case 9:
_b.trys.push([9, 14, , 15]);
activePublicKey_1 = keys.publicKeys.active;
if (!(!this.isNullOrEmpty(newAccountName) && !nameAlreadyExists)) return [3 /*break*/, 10];
oreAccountName = newAccountName;
return [3 /*break*/, 12];
case 10: return [4 /*yield*/, generateAccountName.bind(this)(options.accountNamePrefix)];
case 11:
oreAccountName = _b.sent();
_b.label = 12;
case 12:
awaitTransactionOptions = getAwaitTransactionOptions(options);
return [4 /*yield*/, this.sendTransaction(function () { return newAccountTransaction.bind(_this)(oreAccountName, ownerPublicKey, activePublicKey_1, orePayerAccountName, options); }, confirm, awaitTransactionOptions)];
case 13:
transaction = _b.sent();
return [3 /*break*/, 15];
case 14:
error_6 = _b.sent();
throw new Error("Error creating account: " + newAccountName + " " + error_6);
case 15:
if (!(this.chainName === 'ore')) return [3 /*break*/, 17];
return [4 /*yield*/, generateAuthKeys.bind(this)(oreAccountName, 'authverifier', 'token.ore', 'approve', broadcast)];
case 16:
verifierAuthKeys = _b.sent();
verifierAuthKey = verifierAuthKeys.privateKeys.active;
verifierAuthPublicKey = verifierAuthKeys.publicKeys.active;
_b.label = 17;
case 17: return [2 /*return*/, {
oreAccountName: oreAccountName,
privateKey: keys.privateKeys.active,
publicKey: keys.publicKeys.active,
keys: keys,
transaction: transaction,
verifierAuthKey: verifierAuthKey,
verifierAuthPublicKey: verifierAuthPublicKey
}];
}
});
});
}
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)()];
}
return [2 /*return*/, accountName];
}
});
});
}
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(__assign({}, keys), { publicKeys: __assign(__assign({}, keys.publicKeys), publicKeys), privateKeys: __assign(__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,
checkIfAccountHasPermission: checkIfAccountHasPermission,
createKeyPair: createKeyPair,
createBridgeAccount: createBridgeAccount,
createOreAccount: createOreAccount,
deletePermissions: deletePermissions,
eosBase32: eosBase32,
exportAccount: exportAccount,
getAccountPermissions: getAccountPermissions,
generateAccountName: generateAccountName,
generateAccountNameString: generateAccountNameString,
generateEncryptedKeys: generateEncryptedKeys,
getNameAlreadyExists: getNameAlreadyExists,
linkActionsToPermission: linkActionsToPermission,
unlinkActionsToPermission: unlinkActionsToPermission
};
//# sourceMappingURL=accounts.js.map