@flarenetwork/flare-stake-tool
Version:
Utilities for staking on the Flare network
193 lines • 7.27 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isFlareApp = isFlareApp;
exports.getAddressAndPubKey = getAddressAndPubKey;
exports.getPublicKey = getPublicKey;
exports.getCAddress = getCAddress;
exports.getPAddress = getPAddress;
exports.sign = sign;
exports.signEvmTransaction = signEvmTransaction;
exports.signHash = signHash;
const ledger_flare_1 = require("@zondax/ledger-flare");
const hw_app_eth_1 = require("@ledgerhq/hw-app-eth");
const hw_transport_node_hid_1 = __importDefault(require("@ledgerhq/hw-transport-node-hid"));
const pubk = __importStar(require("../flare/pubk"));
const utils = __importStar(require("../utils"));
async function isFlareApp() {
let flare = false;
await _connect(async (app) => {
let info = await app.appInfo();
flare = info.appName === 'Flare Network';
});
return flare;
}
async function getAddressAndPubKey(bip44Path, hrp) {
let account;
await _connect(async (app) => {
account = await app.getAddressAndPubKey(bip44Path, hrp);
});
if (!account) {
throw Error('Failed to obtain public key from ledger');
}
else if (account.errorMessage != 'No errors') {
throw Error(`Failed to obtain public key from ledger: ${account.errorMessage}, code ${account.returnCode}`);
}
//let publicKey = pubk.normalizePublicKey(utils.toHex(account!.compressed_pk));
return {
publicKey: account.compressed_pk.toString('hex'),
address: account.bech32_address
};
}
async function getPublicKey(bip44Path, hrp) {
let account;
await _connect(async (app) => {
account = await app.getAddressAndPubKey(bip44Path, hrp);
});
if (!account) {
throw Error('Failed to obtain public key from ledger');
}
else if (account.errorMessage != 'No errors') {
throw Error(`Failed to obtain public key from ledger: ${account.errorMessage}, code ${account.returnCode}`);
}
let publicKey = pubk.normalizePublicKey(utils.toHex(account.compressed_pk));
return publicKey;
}
async function getCAddress(bip44Path, display) {
let account;
await _connect(async (app) => {
account = await app.getEVMAddress(bip44Path, display);
});
if (!account) {
throw Error(`Failed to obtain C-chain address from ledger`);
}
return account.address;
}
async function getPAddress(bip44Path, hrp, display) {
let account;
await _connect(async (app) => {
if (display) {
account = await app.showAddressAndPubKey(bip44Path, hrp);
}
else {
account = await app.getAddressAndPubKey(bip44Path, hrp);
}
});
if (!account) {
throw Error('Failed to obtain public key from ledger');
}
else if (account.errorMessage != 'No errors') {
throw Error(`Failed to obtain public key from ledger: ${account.errorMessage}, code ${account.returnCode}`);
}
return account.bech32_address;
}
async function sign(bip44Path, tx) {
let txBuffer = utils.toBuffer(tx);
let response;
await _connect(async (app) => {
response = await app.sign(bip44Path, txBuffer);
});
if (!response) {
throw new Error('Failed to sign message on ledger');
}
else if (response.errorMessage != 'No errors') {
throw new Error(`Failed to sign message on ledger: ${response.errorMessage}, code ${response.returnCode}`);
}
return _getSignatureFromResponse(response);
}
async function signEvmTransaction(bip44Path, txHex) {
let response;
let rawTx = utils.toHex(txHex, false);
let resolution = await hw_app_eth_1.ledgerService.resolveTransaction(rawTx, {}, {});
await _connect(async (app) => {
response = await app.signEVMTransaction(bip44Path, rawTx, resolution);
});
if (!response) {
throw new Error('Failed to sign EVM transaction on ledger');
}
if (!response.r || !response.s || !response.v) {
throw new Error('Failed to get signature from ledger device');
}
let r = Buffer.from(utils.toHex(response.r, false), 'hex');
let s = Buffer.from(utils.toHex(response.s, false), 'hex');
let recoveryParam = parseInt(utils.toHex(response.v, false), 16);
if (recoveryParam == 0 || recoveryParam == 1) {
recoveryParam += 27;
}
else if (recoveryParam > 28) {
recoveryParam = recoveryParam % 2 == 1 ? 27 : 28;
}
let v = Buffer.from(recoveryParam.toString(16), 'hex');
let signature = utils.toHex(Buffer.concat([r, s, v]), false);
return signature;
}
async function signHash(bip44Path, message) {
let messageBuffer = utils.toBuffer(message);
let response;
await _connect(async (app) => {
response = await (app).signHash(bip44Path, messageBuffer);
});
if (!response) {
if (response && response.errorMessage != 'No errors') {
throw new Error(`Failed to sign message on ledger: ${response.errorMessage}`);
}
throw new Error('Failed to sign message on ledger');
}
return _getSignatureFromResponse(response);
}
async function _connect(execute) {
let flare;
try {
let transport = await hw_transport_node_hid_1.default.open(undefined);
flare = new ledger_flare_1.FlareApp(transport);
await execute(flare);
}
finally {
if (flare && flare.transport) {
await flare.transport.close();
}
}
}
function _getSignatureFromResponse(response) {
if (!response.r || !response.s || !response.v) {
throw new Error('Failed to get signature from ledger device');
}
let signature = Buffer.concat([response.r, response.s, response.v]).toString('hex');
return signature;
}
//# sourceMappingURL=flare.js.map