PHP WebShell
Текущая директория: /usr/lib/node_modules/bitgo/node_modules/@bitgo/sdk-coin-xlm/dist/src
Просмотр файла: xlm.js
"use strict";
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.Xlm = void 0;
const assert_1 = __importDefault(require("assert"));
const _ = __importStar(require("lodash"));
const querystring = __importStar(require("querystring"));
const url = __importStar(require("url"));
const request = __importStar(require("superagent"));
const stellar = __importStar(require("stellar-sdk"));
const bignumber_js_1 = require("bignumber.js");
const Utils = __importStar(require("./lib/utils"));
const keyPair_1 = require("./lib/keyPair");
const sdk_core_1 = require("@bitgo/sdk-core");
const sdk_api_1 = require("@bitgo/sdk-api");
const getStellarKeys_1 = require("./getStellarKeys");
class Xlm extends sdk_core_1.BaseCoin {
constructor(bitgo) {
super(bitgo);
this.homeDomain = 'bitgo.com'; // used for reverse federation lookup
}
static createInstance(bitgo) {
return new Xlm(bitgo);
}
getStellarNetwork() {
return stellar.Networks.PUBLIC;
}
/**
* Factor between the base unit and its smallest subdivison
*/
getBaseFactor() {
return 1e7;
}
/**
* Identifier for the blockchain which supports this coin
*/
getChain() {
return 'xlm';
}
/**
* Identifier for the coin family
*/
getFamily() {
return 'xlm';
}
/**
* Complete human-readable name of this coin
*/
getFullName() {
return 'Stellar';
}
/**
* Url at which the stellar federation server can be reached
*/
getFederationServerUrl() {
return sdk_core_1.common.Environments[this.bitgo.getEnv()].stellarFederationServerUrl;
}
/**
* Url at which horizon can be reached
*/
getHorizonUrl() {
return 'https://horizon.stellar.org';
}
/** inheritdoc */
generateKeyPair(seed) {
const keyPair = seed ? new keyPair_1.KeyPair({ seed }) : new keyPair_1.KeyPair();
const keys = keyPair.getKeys();
if (!keys.prv) {
throw new Error('Missing prv in key generation.');
}
return { pub: keys.pub, prv: keys.prv };
}
generateRootKeyPair(seed) {
const keyPair = seed ? new keyPair_1.KeyPair({ seed }) : new keyPair_1.KeyPair();
const keys = keyPair.getKeys(true);
if (!keys.prv) {
throw new Error('Missing prv in key generation.');
}
return { prv: keys.prv + keys.pub, pub: keys.pub };
}
/**
* Get encoded ed25519 public key from raw data
*
* @param pub Raw public key
* @returns Encoded public key
*/
getPubFromRaw(pub) {
return Utils.encodePublicKey(Buffer.from(pub, 'hex'));
}
/**
* Get encoded ed25519 private key from raw data
*
* @param prv Raw private key
* @returns Encoded private key
*/
getPrvFromRaw(prv) {
return Utils.encodePrivateKey(Buffer.from(prv, 'hex'));
}
/**
* Return boolean indicating whether input is valid public key for the coin.
*
* @param pub the pub to be checked
* @returns is it valid?
*/
isValidPub(pub) {
// Stellar's validation method only allows keys in Stellar-specific format, with a 'G' prefix
// We need to allow for both Stellar and raw root keys
return Utils.isValidRootPublicKey(pub) || Utils.isValidStellarPublicKey(pub);
}
/**
* Return boolean indicating whether input is valid private key for the coin
*
* @param prv the prv to be checked
* @returns is it valid?
*/
isValidPrv(prv) {
// Stellar's validation method only allows keys in Stellar-specific format, with an 'S' prefix
// We need to allow for both Stellar and raw root private keys
return Utils.isValidRootPrivateKey(prv) || Utils.isValidStellarPrivateKey(prv);
}
/**
* Return boolean indicating whether a memo id is valid
*
* @param memoId memo id
* @returns true if memo id is valid
*/
isValidMemoId(memoId) {
let memoIdNumber;
try {
stellar.Memo.id(memoId); // throws if the value is not valid memo id
memoIdNumber = new bignumber_js_1.BigNumber(memoId);
}
catch (e) {
return false;
}
return memoIdNumber.gte(0) && memoIdNumber.lt(Xlm.maxMemoId);
}
supportsDeriveKeyWithSeed() {
return false;
}
/** inherited doc */
getDefaultMultisigType() {
return sdk_core_1.multisigTypes.onchain;
}
/**
* Evaluates whether a memo is valid
*
* @param value value of the memo
* @param type type of the memo
* @returns true if value and type are a valid
*/
isValidMemo({ value, type }) {
if (!value || !type) {
return false;
}
try {
// throws if the value is not valid for the type
// valid types are: 'id', 'text', 'hash', 'return'
// See https://www.stellar.org/developers/guides/concepts/transactions.html#memo
stellar.Memo[type](value);
}
catch (e) {
return false;
}
return true;
}
/**
* Create instance of stellar.MuxedAccount from M address
* See: https://developers.stellar.org/docs/glossary/muxed-accounts
*/
getMuxedAccount(address) {
try {
return stellar.MuxedAccount.fromAddress(address, '0');
}
catch (e) {
throw new Error(`invalid muxed address: ${address}`);
}
}
/**
* Return boolean indicating whether a muxed address is valid
* See: https://developers.stellar.org/docs/glossary/muxed-accounts
*
* @param address
* @returns {boolean}
*/
isValidMuxedAddress(address) {
if (!_.isString(address) || !address.startsWith('M')) {
return false;
}
try {
// return true if muxed account is valid or throw
return !!stellar.MuxedAccount.fromAddress(address, '0');
}
catch (e) {
return false;
}
}
/**
* Minimum balance of a 2-of-3 multisig wallet
* @returns minimum balance in stroops
*/
async getMinimumReserve() {
const server = new stellar.Server(this.getHorizonUrl());
const horizonLedgerInfo = await server.ledgers().order('desc').limit(1).call();
if (!horizonLedgerInfo) {
throw new Error('unable to connect to Horizon for reserve requirement data');
}
const baseReserve = horizonLedgerInfo.records[0].base_reserve_in_stroops;
// 2-of-3 wallets have a minimum reserve of 5x the base reserve
return 5 * baseReserve;
}
/**
* Transaction fee for each operation
* @returns transaction fee in stroops
*/
async getBaseTransactionFee() {
const server = new stellar.Server(this.getHorizonUrl());
const horizonLedgerInfo = await server.ledgers().order('desc').limit(1).call();
if (!horizonLedgerInfo) {
throw new Error('unable to connect to Horizon for reserve requirement data');
}
return horizonLedgerInfo.records[0].base_fee_in_stroops;
}
/**
* Process address into address and memo id
*
* @param address the address
* @returns object containing address and memo id
*/
getAddressDetails(address) {
if (address.startsWith('M')) {
if (this.isValidMuxedAddress(address)) {
const muxedAccount = this.getMuxedAccount(address);
return {
baseAddress: muxedAccount.baseAccount().accountId(),
address,
id: muxedAccount.id(),
memoId: undefined,
};
}
else {
throw new sdk_core_1.InvalidAddressError(`invalid muxed address: ${address}`);
}
}
const destinationDetails = url.parse(address);
const destinationAddress = destinationDetails.pathname || '';
if (!destinationAddress || !stellar.StrKey.isValidEd25519PublicKey(destinationAddress)) {
throw new Error(`invalid address: ${address}`);
}
// address doesn't have a memo id
if (destinationDetails.pathname === address) {
return {
baseAddress: address,
address: address,
id: undefined,
memoId: undefined,
};
}
if (!destinationDetails.query) {
throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
}
const queryDetails = querystring.parse(destinationDetails.query);
if (!queryDetails.memoId) {
// if there are more properties, the query details need to contain the memo id property
throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
}
if (Array.isArray(queryDetails.memoId)) {
throw new sdk_core_1.InvalidAddressError(`memoId may only be given at most once, but found ${queryDetails.memoId.length} instances in address ${address}`);
}
if (Array.isArray(queryDetails.memoId) && queryDetails.memoId.length !== 1) {
// valid addresses can only contain one memo id
throw new sdk_core_1.InvalidAddressError(`invalid address '${address}', must contain exactly one memoId`);
}
const [memoId] = _.castArray(queryDetails.memoId) || undefined;
if (!this.isValidMemoId(memoId)) {
throw new sdk_core_1.InvalidMemoIdError(`invalid address: '${address}', memoId is not valid`);
}
return {
baseAddress: destinationAddress,
address: destinationAddress,
id: undefined,
memoId,
};
}
/**
* Validate and return address with appended memo id or muxed address
*
* @param address address
* @param memoId memo id
* @returns address with memo id
*/
normalizeAddress({ address, memoId }) {
if (this.isValidMuxedAddress(address)) {
return address;
}
if (!stellar.StrKey.isValidEd25519PublicKey(address)) {
throw new Error(`invalid address details: ${address}`);
}
if (memoId && this.isValidMemoId(memoId)) {
return `${address}?memoId=${memoId}`;
}
return address;
}
/**
* Return boolean indicating whether input is valid public key for the coin
*
* @param address the pub to be checked
* @returns is it valid?
*/
isValidAddress(address) {
try {
const addressDetails = this.getAddressDetails(address);
return address === this.normalizeAddress(addressDetails);
}
catch (e) {
return false;
}
}
/**
* Return a Stellar Asset in coin:token form (i.e. (t)xlm:<code>-<issuer>)
* If the asset is XLM, return the chain
* @param {stellar.Asset} asset - instance of Stellar Asset
*/
getTokenNameFromStellarAsset(asset) {
const code = asset.getCode();
const issuer = asset.getIssuer();
if (asset.isNative()) {
return this.getChain();
}
return `${this.getChain()}${sdk_core_1.BaseCoin.coinTokenPatternSeparator}${code}${Xlm.tokenPatternSeparator}${issuer}`;
}
/**
* Evaluate whether a stellar username has valid format
* This method is used by the client when a stellar address is being added to a wallet
* Example of a common stellar username: foo@bar.baz
* The above example would result in the Stellar address: foo@bar.baz*bitgo.com
*
* @param username - stellar username
* @return true if stellar username is valid
*/
isValidStellarUsername(username) {
return /^[a-z0-9\-_.+@]+$/.test(username);
}
/**
* Get an instance of FederationServer for BitGo lookups
*
* @returns instance of BitGo Federation Server
*/
getBitGoFederationServer() {
// Identify the URI scheme in case we need to allow connecting to HTTP server.
const isNonSecureEnv = !_.startsWith(sdk_core_1.common.Environments[this.bitgo.env].uri, 'https');
const federationServerOptions = { allowHttp: isNonSecureEnv };
return new stellar.FederationServer(this.getFederationServerUrl(), 'bitgo.com', federationServerOptions);
}
/**
* Perform federation lookups
* Our federation server handles lookups for bitgo as well as for other federation domains
*
* @param {String} [address] - address to look up
* @param {String} [accountId] - account id to look up
*/
async federationLookup({ address, accountId, }) {
try {
const federationServer = this.getBitGoFederationServer();
if (address) {
return await federationServer.resolveAddress(address);
}
else if (accountId) {
return await federationServer.resolveAccountId(accountId);
}
else {
throw new Error('invalid argument - must provide Stellar address or account id');
}
}
catch (e) {
const error = _.get(e, 'response.data.detail');
if (error) {
throw new sdk_core_1.StellarFederationUserNotFoundError(error);
}
else {
throw e;
}
}
}
/**
* Attempt to resolve a stellar address into a stellar account
*
* @param {String} address - stellar address to look for
*/
async federationLookupByName(address) {
if (!address) {
throw new Error('invalid Stellar address');
}
return this.federationLookup({ address });
}
/**
* Attempt to resolve an account id into a stellar account
* Only works for accounts that can be resolved by our federation server
*
* @param {String} accountId - stellar account id
*/
async federationLookupByAccountId(accountId) {
if (!accountId) {
throw new Error('invalid Stellar account');
}
return this.federationLookup({ accountId });
}
/**
* Check if address is a valid XLM address, and then make sure it matches the root address.
*
* @param address {String} the address to verify
* @param rootAddress {String} the wallet's root address
*/
async isWalletAddress({ address, rootAddress }) {
if (!this.isValidAddress(address)) {
throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
}
const addressDetails = this.getAddressDetails(address);
const rootAddressDetails = this.getAddressDetails(rootAddress);
if (addressDetails.baseAddress !== rootAddressDetails.address) {
throw new sdk_core_1.UnexpectedAddressError(`address validation failure: ${addressDetails.baseAddress} vs ${rootAddressDetails.address}`);
}
return true;
}
/**
* Get extra parameters for prebuilding a tx
* Set empty recipients array in trustline txs
*/
async getExtraPrebuildParams(buildParams) {
const params = {};
if (buildParams.type === 'trustline') {
params.recipients = [];
}
return params;
}
/**
* @deprecated
*/
initiateRecovery(params) {
throw new Error('deprecated method');
}
/**
* Builds a funds recovery transaction without BitGo
* @param params
* - userKey: [encrypted] Stellar private key
* - backupKey: [encrypted] Stellar private key, or public key if the private key is held by a KRS provider
* - walletPassphrase: necessary if one of the private keys is encrypted
* - rootAddress: base address of the wallet to recover funds from
* - krsProvider: necessary if backup key is held by KRS
* - recoveryDestination: target address to send recovered funds to
*/
async recover(params) {
// Check if unencrypted root keys were provided, convert to Stellar format if necessary
if (Utils.isValidRootPrivateKey(params.userKey)) {
params.userKey = Utils.encodePrivateKey(Buffer.from(params.userKey.slice(0, 64), 'hex'));
}
else if (Utils.isValidRootPublicKey(params.userKey)) {
params.userKey = Utils.encodePublicKey(Buffer.from(params.userKey, 'hex'));
}
if (Utils.isValidRootPrivateKey(params.backupKey)) {
params.backupKey = Utils.encodePrivateKey(Buffer.from(params.backupKey.slice(0, 64), 'hex'));
}
else if (Utils.isValidRootPublicKey(params.backupKey)) {
params.backupKey = Utils.encodePublicKey(Buffer.from(params.backupKey, 'hex'));
}
// Stellar's Ed25519 public keys start with a G, while private keys start with an S
const isKrsRecovery = params.backupKey.startsWith('G') && !params.userKey.startsWith('G');
const isUnsignedSweep = params.backupKey.startsWith('G') && params.userKey.startsWith('G');
if (isKrsRecovery) {
(0, sdk_core_1.checkKrsProvider)(this, params.krsProvider);
}
if (!this.isValidAddress(params.recoveryDestination)) {
throw new sdk_core_1.InvalidAddressError('Invalid destination address!');
}
const [userKey, backupKey] = (0, getStellarKeys_1.getStellarKeys)(this.bitgo, params);
if (!params.rootAddress || !stellar.StrKey.isValidEd25519PublicKey(params.rootAddress)) {
throw new Error(`Invalid wallet address: ${params.rootAddress}`);
}
const accountDataUrl = `${this.getHorizonUrl()}/accounts/${params.rootAddress}`;
const destinationUrl = `${this.getHorizonUrl()}/accounts/${params.recoveryDestination}`;
let accountData;
try {
accountData = await (0, sdk_api_1.toBitgoRequest)(request.get(accountDataUrl)).result();
}
catch (e) {
throw new Error('Unable to reach the Stellar network via Horizon.');
}
// Now check if the destination account is empty or not
let unfundedDestination = false;
try {
await request.get(destinationUrl);
}
catch (e) {
if (e.status === 404) {
// If the destination account does not yet exist, horizon responds with 404
unfundedDestination = true;
}
}
if (!accountData.sequence || !accountData.balances) {
throw new Error('Horizon server error - unable to retrieve sequence ID or account balance');
}
const account = new stellar.Account(params.rootAddress, accountData.sequence);
// Stellar supports multiple assets on chain, we're only interested in the balances entry whose type is "native" (XLM)
const nativeBalanceInfo = accountData.balances.find((assetBalance) => assetBalance['asset_type'] === 'native');
if (!nativeBalanceInfo) {
throw new Error('Provided wallet has a balance of 0 XLM, recovery aborted');
}
const walletBalance = Number(this.bigUnitsToBaseUnits(nativeBalanceInfo.balance));
const minimumReserve = await this.getMinimumReserve();
const baseTxFee = await this.getBaseTransactionFee();
const recoveryAmount = walletBalance - minimumReserve - baseTxFee;
const formattedRecoveryAmount = this.baseUnitsToBigUnits(recoveryAmount).toString();
const txBuilder = new stellar.TransactionBuilder(account, {
fee: baseTxFee.toFixed(0),
networkPassphrase: this.getStellarNetwork(),
});
const operation = unfundedDestination
? // In this case, we need to create the account
stellar.Operation.createAccount({
destination: params.recoveryDestination,
startingBalance: formattedRecoveryAmount,
})
: // Otherwise if the account already exists, we do a normal send
stellar.Operation.payment({
destination: params.recoveryDestination,
asset: stellar.Asset.native(),
amount: formattedRecoveryAmount,
});
const tx = txBuilder.addOperation(operation).setTimeout(stellar.TimeoutInfinite).build();
const feeInfo = {
fee: new bignumber_js_1.BigNumber(tx.fee).toNumber(),
feeString: tx.fee,
};
if (!isUnsignedSweep) {
tx.sign(userKey);
}
if (!isKrsRecovery && !isUnsignedSweep) {
tx.sign(backupKey);
}
const transaction = {
txBase64: Xlm.txToString(tx),
recoveryAmount,
};
if (isKrsRecovery) {
transaction.backupKey = params.backupKey;
}
transaction.coin = this.getChain();
transaction.feeInfo = feeInfo;
return transaction;
}
/**
* Assemble keychain and half-sign prebuilt transaction
*
* @param params
* @param params.txPrebuild {Object} prebuild object returned by platform
* @param params.prv {String} user prv
* @returns {Promise<HalfSignedTransaction>}
*/
async signTransaction(params) {
const { txPrebuild, prv } = params;
if (_.isUndefined(txPrebuild)) {
throw new Error('missing txPrebuild parameter');
}
if (!_.isObject(txPrebuild)) {
throw new Error(`txPrebuild must be an object, got type ${typeof txPrebuild}`);
}
if (_.isUndefined(prv)) {
throw new Error('missing prv parameter to sign transaction');
}
if (!_.isString(prv)) {
throw new Error(`prv must be a string, got type ${typeof prv}`);
}
const keyPair = Utils.createStellarKeypairFromPrv(prv);
const tx = new stellar.Transaction(txPrebuild.txBase64, this.getStellarNetwork());
tx.sign(keyPair);
const txBase64 = Xlm.txToString(tx);
const type = txPrebuild?.buildParams?.type;
const recipients = txPrebuild?.buildParams?.recipients;
if (type === 'enabletoken') {
return {
halfSigned: { txBase64 },
type,
recipients,
};
}
else {
return { halfSigned: { txBase64 } };
}
}
/**
* Extend walletParams with extra params required for generating an XLM wallet
*
* Stellar wallets have three keychains on them. Two are generated by the platform, and the last is generated by the user.
* Initially, we need a root prv to generate the account, which must be distinct from all three keychains on the wallet.
* If a root prv is not provided, a random one is generated.
*/
async supplementGenerateWallet(walletParams) {
let seed;
const rootPrv = walletParams.rootPrivateKey;
if (rootPrv) {
if (!this.isValidPrv(rootPrv)) {
throw new Error('rootPrivateKey needs to be valid ed25519 secret seed');
}
seed = stellar.StrKey.decodeEd25519SecretSeed(rootPrv);
}
const keyPair = this.generateKeyPair(seed);
// extend the wallet initialization params
walletParams.rootPrivateKey = keyPair.prv;
return walletParams;
}
/**
* Sign message with private key
*
* @param key
* @param message
*/
async signMessage(key, message) {
if (!this.isValidPrv(key.prv)) {
throw new Error(`invalid prv: ${key.prv}`);
}
if (!Buffer.isBuffer(message)) {
message = Buffer.from(message);
}
const keypair = Utils.createStellarKeypairFromPrv(key.prv);
return keypair.sign(message);
}
/**
* Verifies if signature for message is valid.
*
* @param pub public key
* @param message signed message
* @param signature signature to verify
* @returns true if signature is valid.
*/
verifySignature(pub, message, signature) {
if (!this.isValidPub(pub)) {
throw new Error(`invalid pub: ${pub}`);
}
if (!Buffer.isBuffer(message)) {
message = Buffer.from(message);
}
const keyPair = Utils.createStellarKeypairFromPub(pub);
return keyPair.verify(message, signature);
}
/**
* Explain/parse transaction
* @param params
*/
async explainTransaction(params) {
const { txHex, txBase64 } = params;
let tx = undefined;
if (!txHex && !txBase64) {
throw new Error('explainTransaction missing txHex or txBase64 parameter, must have at least one');
}
try {
if (txHex) {
tx = new stellar.Transaction(Buffer.from(txHex, 'hex').toString('base64'), this.getStellarNetwork());
}
else if (txBase64) {
tx = new stellar.Transaction(txBase64, this.getStellarNetwork());
}
}
catch (e) {
throw new Error('txBase64 needs to be a valid tx encoded as base64 string');
}
if (!tx) {
throw new Error('tx needs to be defined in order to explain transaction');
}
const id = tx.hash().toString('hex');
// In a Stellar tx, the _memo property is an object with the methods:
// value() and arm() that provide memo value and type, respectively.
const memo = _.result(tx, '_memo.value') && _.result(tx, '_memo.arm')
? {
value: _.result(tx, '_memo.value').toString(),
type: _.result(tx, '_memo.arm'),
}
: {};
let spendAmount = new bignumber_js_1.BigNumber(0); // amount of XLM used in XLM-only txs
const spendAmounts = {}; // track both xlm and token amounts
if (_.isEmpty(tx.operations)) {
throw new Error('missing operations');
}
const outputs = [];
const operations = []; // non-payment operations
_.forEach(tx.operations, (op) => {
if (op.type === 'createAccount' || op.type === 'payment') {
// TODO Remove memoId from address
// Get memo to attach to address, if type is 'id'
const memoId = _.get(memo, 'type') === 'id' && !_.get(memo, 'value') ? `?memoId=${memo.value}` : '';
let asset;
if (op.type === 'payment') {
if (op.asset.getAssetType() === 'liquidity_pool_shares') {
throw new Error('Invalid asset type');
}
asset = op.asset;
}
else {
asset = stellar.Asset.native();
}
const coin = this.getTokenNameFromStellarAsset(asset); // coin or token id
const output = {
amount: this.bigUnitsToBaseUnits(op.startingBalance || op.amount),
address: op.destination + memoId,
coin,
};
if (!_.isUndefined(spendAmounts[coin])) {
spendAmounts[coin] = spendAmounts[coin].plus(output.amount);
}
else {
spendAmounts[coin] = new bignumber_js_1.BigNumber(output.amount);
}
if (asset.isNative()) {
spendAmount = spendAmount.plus(output.amount);
}
outputs.push(output);
}
else if (op.type === 'changeTrust') {
if (op.line.getAssetType() === 'liquidity_pool_shares') {
throw new Error('Invalid asset type');
}
const asset = op.line;
operations.push({
type: op.type,
coin: this.getTokenNameFromStellarAsset(asset),
asset,
limit: this.bigUnitsToBaseUnits(op.limit),
});
}
});
const outputAmount = spendAmount.toFixed(0);
const outputAmounts = _.mapValues(spendAmounts, (amount) => amount.toFixed(0));
const fee = {
fee: new bignumber_js_1.BigNumber(tx.fee).toFixed(0),
feeRate: null,
size: null,
};
return {
displayOrder: [
'id',
'outputAmount',
'outputAmounts',
'changeAmount',
'outputs',
'changeOutputs',
'fee',
'memo',
'operations',
],
id,
outputs,
outputAmount,
outputAmounts,
changeOutputs: [],
changeAmount: '0',
memo,
fee,
operations,
};
}
/**
* Verify that a tx prebuild's operations comply with the original intention
* @param {stellar.Operation} operations - tx operations
* @param {TransactionParams} txParams - params used to build the tx
*/
verifyEnableTokenTxOperations(operations, txParams) {
const trustlineOperations = _.filter(operations, ['type', 'changeTrust']);
if (trustlineOperations.length !== _.get(txParams, 'recipients', []).length) {
throw new Error('transaction prebuild does not match expected trustline operations');
}
_.forEach(trustlineOperations, (op) => {
if (op.type !== 'changeTrust') {
throw new Error('Invalid asset type');
}
if (op.line.getAssetType() === 'liquidity_pool_shares') {
throw new Error('Invalid asset type');
}
const asset = op.line;
const opToken = this.getTokenNameFromStellarAsset(asset);
const tokenTrustline = _.find(txParams.recipients, (recipient) => {
// trustline params use limits in base units
const opLimitBaseUnits = this.bigUnitsToBaseUnits(op.limit);
// Enable token limit is set to Xlm.maxTrustlineLimit by default
return recipient.tokenName === opToken && opLimitBaseUnits === Xlm.maxTrustlineLimit;
});
if (!tokenTrustline) {
throw new Error('transaction prebuild does not match expected trustline tokens');
}
});
}
/**
* Verify that a tx prebuild's operations comply with the original intention
* @param {stellar.Operation} operations - tx operations
* @param {TransactionParams} txParams - params used to build the tx
*/
verifyTrustlineTxOperations(operations, txParams) {
const trustlineOperations = _.filter(operations, ['type', 'changeTrust']);
if (trustlineOperations.length !== _.get(txParams, 'trustlines', []).length) {
throw new Error('transaction prebuild does not match expected trustline operations');
}
_.forEach(trustlineOperations, (op) => {
if (op.type !== 'changeTrust') {
throw new Error('Invalid asset type');
}
if (op.line.getAssetType() === 'liquidity_pool_shares') {
throw new Error('Invalid asset type');
}
const asset = op.line;
const opToken = this.getTokenNameFromStellarAsset(asset);
const tokenTrustline = _.find(txParams.trustlines, (trustline) => {
// trustline params use limits in base units
const opLimitBaseUnits = this.bigUnitsToBaseUnits(op.limit);
// Prepare the conditions to check for
// Limit will always be set in the operation, even if it was omitted from txParams in the following cases:
// 1. Action is 'add' - limit is set to Xlm.maxTrustlineLimit by default
// 2. Action is 'remove' - limit is set to '0'
const noLimit = _.isUndefined(trustline.limit);
const addTrustlineWithDefaultLimit = trustline.action === 'add' && opLimitBaseUnits === Xlm.maxTrustlineLimit;
const removeTrustline = trustline.action === 'remove' && opLimitBaseUnits === '0';
return (trustline.token === opToken &&
(trustline.limit === opLimitBaseUnits || (noLimit && (addTrustlineWithDefaultLimit || removeTrustline))));
});
if (!tokenTrustline) {
throw new Error('transaction prebuild does not match expected trustline tokens');
}
});
}
/**
* Verify that a transaction prebuild complies with the original intention
*
* @param options
* @param options.txPrebuild prebuild object returned by platform
* @param options.txPrebuild.txBase64 prebuilt transaction encoded as base64 string
* @param options.wallet wallet object to obtain keys to verify against
* @param options.verification specifying some verification parameters
* @param options.verification.disableNetworking Disallow fetching any data from the internet for verification purposes
* @param options.verification.keychains Pass keychains manually rather than fetching them by id
*/
async verifyTransaction(options) {
// TODO BG-5600 Add parseTransaction / improve verification
const { txParams, txPrebuild, wallet, verification = {} } = options;
const disableNetworking = !!verification.disableNetworking;
if (!txPrebuild.txBase64) {
throw new Error('missing required tx prebuild property txBase64');
}
const tx = new stellar.Transaction(txPrebuild.txBase64, this.getStellarNetwork());
if (txParams.recipients && txParams.recipients.length > 1) {
throw new Error('cannot specify more than 1 recipient');
}
// Stellar txs are made up of operations. We only care about Create Account and Payment for sending funds.
const outputOperations = _.filter(tx.operations, (operation) => operation.type === 'createAccount' || operation.type === 'payment');
if (txParams.type === 'enabletoken') {
this.verifyEnableTokenTxOperations(tx.operations, txParams);
}
else if (txParams.type === 'trustline') {
this.verifyTrustlineTxOperations(tx.operations, txParams);
}
else {
if (_.isEmpty(outputOperations)) {
throw new Error('transaction prebuild does not have any operations');
}
_.forEach(txParams.recipients, (expectedOutput, index) => {
const expectedOutputAddressDetails = this.getAddressDetails(expectedOutput.address);
const expectedOutputAddress = expectedOutputAddressDetails.address;
const output = outputOperations[index];
if (output.destination !== expectedOutputAddress) {
throw new Error('transaction prebuild does not match expected recipient');
}
const expectedOutputAmount = new bignumber_js_1.BigNumber(expectedOutput.amount);
// The output amount is expressed as startingBalance in createAccount operations and as amount in payment operations.
const outputAmountString = output.type === 'createAccount' ? output.startingBalance : output.amount;
const outputAmount = new bignumber_js_1.BigNumber(this.bigUnitsToBaseUnits(outputAmountString));
if (!outputAmount.eq(expectedOutputAmount)) {
throw new Error('transaction prebuild does not match expected amount');
}
});
}
// Verify the user signature, if the tx is half-signed
if (!_.isEmpty(tx.signatures)) {
const userSignature = tx.signatures[0].signature();
// obtain the keychains and key signatures
let keychains = verification.keychains;
if (!keychains && disableNetworking) {
throw new Error('cannot fetch keychains without networking');
}
else if (!keychains) {
keychains = await (0, sdk_core_1.promiseProps)({
user: this.keychains().get({ id: wallet.keyIds()[sdk_core_1.KeyIndices.USER] }),
backup: this.keychains().get({ id: wallet.keyIds()[sdk_core_1.KeyIndices.BACKUP] }),
});
}
if (!keychains || !keychains.backup || !keychains.user) {
throw new Error('keychains are required, but could not be fetched');
}
(0, assert_1.default)(keychains.backup.pub);
if (this.verifySignature(keychains.backup.pub, tx.hash(), userSignature)) {
throw new Error('transaction signed with wrong key');
}
(0, assert_1.default)(keychains.user.pub);
if (!this.verifySignature(keychains.user.pub, tx.hash(), userSignature)) {
throw new Error('transaction signature invalid');
}
}
return true;
}
/** inheritdoc */
deriveKeyWithSeed() {
throw new sdk_core_1.NotSupported('method deriveKeyWithSeed not supported for eddsa curve');
}
async parseTransaction(params) {
return {};
}
/**
* Gets config for how token enablements work for this coin
* @returns
* requiresTokenEnablement: True if tokens need to be enabled for this coin
* supportsMultipleTokenEnablements: True if multiple tokens can be enabled in one transaction
*/
getTokenEnablementConfig() {
return {
requiresTokenEnablement: true,
supportsMultipleTokenEnablements: false,
};
}
/** @inheritDoc */
auditDecryptedKey({ publicKey, prv, multiSigType }) {
if (multiSigType === 'tss') {
throw new Error('Unsupported multiSigType');
}
let xlmKeyPair;
try {
xlmKeyPair = new keyPair_1.KeyPair({ prv });
}
catch (e) {
// Avoid adding the error message to the thrown error because it can contain sensitive information
throw new Error(`Invalid private key: Unable to generate keypair from prv`);
}
if (publicKey && publicKey !== xlmKeyPair.getKeys().pub) {
throw new Error('Invalid public key');
}
}
}
exports.Xlm = Xlm;
Xlm.tokenPatternSeparator = '-'; // separator for token code and issuer
Xlm.maxMemoId = '0xFFFFFFFFFFFFFFFF'; // max unsigned 64-bit number = 18446744073709551615
// max int64 number supported by the network (2^63)-1
// See: https://www.stellar.org/developers/guides/concepts/assets.html#amount-precision-and-representation
Xlm.maxTrustlineLimit = '9223372036854775807';
/**
* stellar-sdk has two overloads for toXDR, and typescript can't seem to figure out the
* correct one to use, so we have to be very explicit as to which one we want.
* @param tx transaction to convert
*/
Xlm.txToString = (tx) => tx.toEnvelope().toXDR('base64');
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xlm.js","sourceRoot":"","sources":["../../src/xlm.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport * as _ from 'lodash';\nimport * as querystring from 'querystring';\nimport * as url from 'url';\nimport * as request from 'superagent';\nimport * as stellar from 'stellar-sdk';\nimport { BigNumber } from 'bignumber.js';\nimport * as Utils from './lib/utils';\nimport { KeyPair as StellarKeyPair } from './lib/keyPair';\n\nimport {\n  BaseCoin,\n  BitGoBase,\n  checkKrsProvider,\n  common,\n  ExtraPrebuildParamsOptions,\n  InvalidAddressError,\n  InvalidMemoIdError,\n  ITransactionRecipient,\n  KeyIndices,\n  KeyPair,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  promiseProps,\n  SignTransactionOptions as BaseSignTransactionOptions,\n  StellarFederationUserNotFoundError,\n  TokenEnablementConfig,\n  TransactionExplanation as BaseTransactionExplanation,\n  TransactionParams as BaseTransactionParams,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  TransactionRecipient as BaseTransactionOutput,\n  UnexpectedAddressError,\n  VerifyAddressOptions as BaseVerifyAddressOptions,\n  VerifyTransactionOptions as BaseVerifyTransactionOptions,\n  Wallet,\n  NotSupported,\n  MultisigType,\n  multisigTypes,\n  AuditDecryptedKeyParams,\n} from '@bitgo/sdk-core';\nimport { toBitgoRequest } from '@bitgo/sdk-api';\nimport { getStellarKeys } from './getStellarKeys';\n\n/**\n * XLM accounts support virtual (muxed) addresses\n * A base address starts with \"G\" and is tied to the underlying \"real\" account\n * A muxed address starts with \"M\" and combines the base address with a 64-bit integer ID in order to provide\n * an alternative to memo ids.\n */\ninterface AddressDetails {\n  baseAddress: string;\n  address: string;\n  id?: string;\n  memoId?: string | undefined;\n}\n\ninterface Memo {\n  type: stellar.MemoType;\n  value: string;\n}\n\ninterface InitiateRecoveryOptions {\n  userKey: string;\n  backupKey: string;\n  recoveryDestination: string;\n  krsProvider?: string;\n  walletPassphrase?: string;\n}\n\ninterface RecoveryOptions extends InitiateRecoveryOptions {\n  rootAddress?: string;\n}\n\ninterface RecoveryTransaction {\n  txBase64: string;\n  recoveryAmount: number;\n  coin?: string;\n  backupKey?: string;\n  txInfo?: any;\n  feeInfo?: any;\n}\n\ninterface BuildOptions {\n  wallet?: Wallet;\n  recipients?: Record<string, string>[];\n  type?: string;\n  walletPassphrase?: string;\n  [index: string]: unknown;\n}\n\ninterface TransactionPrebuild extends BaseTransactionPrebuild {\n  txBase64: string;\n}\n\ninterface SignTransactionOptions extends BaseSignTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  prv: string;\n}\n\ninterface HalfSignedTransaction {\n  halfSigned: {\n    txBase64: string;\n  };\n  recipients?: ITransactionRecipient[];\n  type?: string;\n}\n\ninterface SupplementGenerateWalletOptions {\n  rootPrivateKey?: string;\n}\n\ninterface ExplainTransactionOptions {\n  txHex?: string;\n  txBase64?: string;\n}\n\ninterface TransactionMemo {\n  value?: string;\n  type?: string;\n}\n\ninterface TransactionOperation {\n  type: string;\n  coin: string;\n  limit?: string;\n  asset?: stellar.Asset;\n}\n\ninterface TransactionOutput extends BaseTransactionOutput {\n  coin: string;\n}\n\ninterface TransactionExplanation extends BaseTransactionExplanation {\n  memo: TransactionMemo;\n}\n\ninterface VerifyAddressOptions extends BaseVerifyAddressOptions {\n  rootAddress: string;\n}\n\ninterface TrustlineOptions {\n  token: string;\n  action: string;\n  limit?: string;\n}\n\ninterface TransactionParams extends BaseTransactionParams {\n  trustlines?: TrustlineOptions[];\n}\n\ninterface VerifyTransactionOptions extends BaseVerifyTransactionOptions {\n  txParams: TransactionParams;\n}\n\nexport class Xlm extends BaseCoin {\n  public readonly homeDomain: string;\n  public static readonly tokenPatternSeparator = '-'; // separator for token code and issuer\n  static readonly maxMemoId: string = '0xFFFFFFFFFFFFFFFF'; // max unsigned 64-bit number = 18446744073709551615\n  // max int64 number supported by the network (2^63)-1\n  // See: https://www.stellar.org/developers/guides/concepts/assets.html#amount-precision-and-representation\n  static readonly maxTrustlineLimit: string = '9223372036854775807';\n\n  constructor(bitgo: BitGoBase) {\n    super(bitgo);\n    this.homeDomain = 'bitgo.com'; // used for reverse federation lookup\n  }\n\n  static createInstance(bitgo: BitGoBase): BaseCoin {\n    return new Xlm(bitgo);\n  }\n\n  protected getStellarNetwork(): stellar.Networks {\n    return stellar.Networks.PUBLIC;\n  }\n\n  /**\n   * Factor between the base unit and its smallest subdivison\n   */\n  getBaseFactor() {\n    return 1e7;\n  }\n\n  /**\n   * Identifier for the blockchain which supports this coin\n   */\n  getChain(): string {\n    return 'xlm';\n  }\n\n  /**\n   * Identifier for the coin family\n   */\n  getFamily(): string {\n    return 'xlm';\n  }\n\n  /**\n   * Complete human-readable name of this coin\n   */\n  getFullName(): string {\n    return 'Stellar';\n  }\n\n  /**\n   * Url at which the stellar federation server can be reached\n   */\n  getFederationServerUrl(): string {\n    return common.Environments[this.bitgo.getEnv()].stellarFederationServerUrl;\n  }\n\n  /**\n   * Url at which horizon can be reached\n   */\n  getHorizonUrl(): string {\n    return 'https://horizon.stellar.org';\n  }\n\n  /** inheritdoc */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new StellarKeyPair({ seed }) : new StellarKeyPair();\n    const keys = keyPair.getKeys();\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n    return { pub: keys.pub, prv: keys.prv };\n  }\n\n  generateRootKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new StellarKeyPair({ seed }) : new StellarKeyPair();\n    const keys = keyPair.getKeys(true);\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n    return { prv: keys.prv + keys.pub, pub: keys.pub };\n  }\n\n  /**\n   * Get encoded ed25519 public key from raw data\n   *\n   * @param pub Raw public key\n   * @returns Encoded public key\n   */\n  getPubFromRaw(pub: string): string {\n    return Utils.encodePublicKey(Buffer.from(pub, 'hex'));\n  }\n\n  /**\n   * Get encoded ed25519 private key from raw data\n   *\n   * @param prv Raw private key\n   * @returns Encoded private key\n   */\n  getPrvFromRaw(prv: string): string {\n    return Utils.encodePrivateKey(Buffer.from(prv, 'hex'));\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin.\n   *\n   * @param pub the pub to be checked\n   * @returns is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    // Stellar's validation method only allows keys in Stellar-specific format, with a 'G' prefix\n    // We need to allow for both Stellar and raw root keys\n    return Utils.isValidRootPublicKey(pub) || Utils.isValidStellarPublicKey(pub);\n  }\n\n  /**\n   * Return boolean indicating whether input is valid private key for the coin\n   *\n   * @param prv the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPrv(prv: string): boolean {\n    // Stellar's validation method only allows keys in Stellar-specific format, with an 'S' prefix\n    // We need to allow for both Stellar and raw root private keys\n    return Utils.isValidRootPrivateKey(prv) || Utils.isValidStellarPrivateKey(prv);\n  }\n\n  /**\n   * Return boolean indicating whether a memo id is valid\n   *\n   * @param memoId memo id\n   * @returns true if memo id is valid\n   */\n  isValidMemoId(memoId: string): boolean {\n    let memoIdNumber;\n    try {\n      stellar.Memo.id(memoId); // throws if the value is not valid memo id\n      memoIdNumber = new BigNumber(memoId);\n    } catch (e) {\n      return false;\n    }\n\n    return memoIdNumber.gte(0) && memoIdNumber.lt(Xlm.maxMemoId);\n  }\n\n  supportsDeriveKeyWithSeed(): boolean {\n    return false;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.onchain;\n  }\n\n  /**\n   * Evaluates whether a memo is valid\n   *\n   * @param value value of the memo\n   * @param type type of the memo\n   * @returns true if value and type are a valid\n   */\n  isValidMemo({ value, type }: Memo): boolean {\n    if (!value || !type) {\n      return false;\n    }\n    try {\n      // throws if the value is not valid for the type\n      // valid types are: 'id', 'text', 'hash', 'return'\n      // See https://www.stellar.org/developers/guides/concepts/transactions.html#memo\n      stellar.Memo[type](value);\n    } catch (e) {\n      return false;\n    }\n    return true;\n  }\n\n  /**\n   * Create instance of stellar.MuxedAccount from M address\n   * See: https://developers.stellar.org/docs/glossary/muxed-accounts\n   */\n  getMuxedAccount(address: string): stellar.MuxedAccount {\n    try {\n      return stellar.MuxedAccount.fromAddress(address, '0');\n    } catch (e) {\n      throw new Error(`invalid muxed address: ${address}`);\n    }\n  }\n\n  /**\n   * Return boolean indicating whether a muxed address is valid\n   * See: https://developers.stellar.org/docs/glossary/muxed-accounts\n   *\n   * @param address\n   * @returns {boolean}\n   */\n  isValidMuxedAddress(address: string): boolean {\n    if (!_.isString(address) || !address.startsWith('M')) {\n      return false;\n    }\n\n    try {\n      // return true if muxed account is valid or throw\n      return !!stellar.MuxedAccount.fromAddress(address, '0');\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Minimum balance of a 2-of-3 multisig wallet\n   * @returns minimum balance in stroops\n   */\n  async getMinimumReserve(): Promise<number> {\n    const server = new stellar.Server(this.getHorizonUrl());\n\n    const horizonLedgerInfo = await server.ledgers().order('desc').limit(1).call();\n\n    if (!horizonLedgerInfo) {\n      throw new Error('unable to connect to Horizon for reserve requirement data');\n    }\n\n    const baseReserve = horizonLedgerInfo.records[0].base_reserve_in_stroops;\n\n    // 2-of-3 wallets have a minimum reserve of 5x the base reserve\n    return 5 * baseReserve;\n  }\n\n  /**\n   * Transaction fee for each operation\n   * @returns transaction fee in stroops\n   */\n  async getBaseTransactionFee(): Promise<number> {\n    const server = new stellar.Server(this.getHorizonUrl());\n\n    const horizonLedgerInfo = await server.ledgers().order('desc').limit(1).call();\n\n    if (!horizonLedgerInfo) {\n      throw new Error('unable to connect to Horizon for reserve requirement data');\n    }\n\n    return horizonLedgerInfo.records[0].base_fee_in_stroops;\n  }\n\n  /**\n   * Process address into address and memo id\n   *\n   * @param address the address\n   * @returns object containing address and memo id\n   */\n  getAddressDetails(address: string): AddressDetails {\n    if (address.startsWith('M')) {\n      if (this.isValidMuxedAddress(address)) {\n        const muxedAccount = this.getMuxedAccount(address);\n        return {\n          baseAddress: muxedAccount.baseAccount().accountId(),\n          address,\n          id: muxedAccount.id(),\n          memoId: undefined,\n        };\n      } else {\n        throw new InvalidAddressError(`invalid muxed address: ${address}`);\n      }\n    }\n\n    const destinationDetails = url.parse(address);\n    const destinationAddress = destinationDetails.pathname || '';\n    if (!destinationAddress || !stellar.StrKey.isValidEd25519PublicKey(destinationAddress)) {\n      throw new Error(`invalid address: ${address}`);\n    }\n    // address doesn't have a memo id\n    if (destinationDetails.pathname === address) {\n      return {\n        baseAddress: address,\n        address: address,\n        id: undefined,\n        memoId: undefined,\n      };\n    }\n\n    if (!destinationDetails.query) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    const queryDetails = querystring.parse(destinationDetails.query);\n    if (!queryDetails.memoId) {\n      // if there are more properties, the query details need to contain the memo id property\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    if (Array.isArray(queryDetails.memoId)) {\n      throw new InvalidAddressError(\n        `memoId may only be given at most once, but found ${queryDetails.memoId.length} instances in address ${address}`\n      );\n    }\n\n    if (Array.isArray(queryDetails.memoId) && queryDetails.memoId.length !== 1) {\n      // valid addresses can only contain one memo id\n      throw new InvalidAddressError(`invalid address '${address}', must contain exactly one memoId`);\n    }\n\n    const [memoId] = _.castArray(queryDetails.memoId) || undefined;\n    if (!this.isValidMemoId(memoId)) {\n      throw new InvalidMemoIdError(`invalid address: '${address}', memoId is not valid`);\n    }\n\n    return {\n      baseAddress: destinationAddress,\n      address: destinationAddress,\n      id: undefined,\n      memoId,\n    };\n  }\n\n  /**\n   * Validate and return address with appended memo id or muxed address\n   *\n   * @param address address\n   * @param memoId memo id\n   * @returns address with memo id\n   */\n  normalizeAddress({ address, memoId }: AddressDetails): string {\n    if (this.isValidMuxedAddress(address)) {\n      return address;\n    }\n    if (!stellar.StrKey.isValidEd25519PublicKey(address)) {\n      throw new Error(`invalid address details: ${address}`);\n    }\n    if (memoId && this.isValidMemoId(memoId)) {\n      return `${address}?memoId=${memoId}`;\n    }\n    return address;\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param address the pub to be checked\n   * @returns is it valid?\n   */\n  isValidAddress(address: string): boolean {\n    try {\n      const addressDetails = this.getAddressDetails(address);\n      return address === this.normalizeAddress(addressDetails);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Return a Stellar Asset in coin:token form (i.e. (t)xlm:<code>-<issuer>)\n   * If the asset is XLM, return the chain\n   * @param {stellar.Asset} asset - instance of Stellar Asset\n   */\n  getTokenNameFromStellarAsset(asset: stellar.Asset): string {\n    const code = asset.getCode();\n    const issuer = asset.getIssuer();\n    if (asset.isNative()) {\n      return this.getChain();\n    }\n    return `${this.getChain()}${BaseCoin.coinTokenPatternSeparator}${code}${Xlm.tokenPatternSeparator}${issuer}`;\n  }\n\n  /**\n   * Evaluate whether a stellar username has valid format\n   * This method is used by the client when a stellar address is being added to a wallet\n   * Example of a common stellar username: foo@bar.baz\n   * The above example would result in the Stellar address: foo@bar.baz*bitgo.com\n   *\n   * @param username - stellar username\n   * @return true if stellar username is valid\n   */\n  isValidStellarUsername(username: string): boolean {\n    return /^[a-z0-9\\-_.+@]+$/.test(username);\n  }\n\n  /**\n   * Get an instance of FederationServer for BitGo lookups\n   *\n   * @returns instance of BitGo Federation Server\n   */\n  getBitGoFederationServer(): stellar.FederationServer {\n    // Identify the URI scheme in case we need to allow connecting to HTTP server.\n    const isNonSecureEnv = !_.startsWith(common.Environments[this.bitgo.env].uri, 'https');\n    const federationServerOptions = { allowHttp: isNonSecureEnv };\n    return new stellar.FederationServer(this.getFederationServerUrl(), 'bitgo.com', federationServerOptions);\n  }\n\n  /**\n   * Perform federation lookups\n   * Our federation server handles lookups for bitgo as well as for other federation domains\n   *\n   * @param {String} [address] - address to look up\n   * @param {String} [accountId] - account id to look up\n   */\n  private async federationLookup({\n    address,\n    accountId,\n  }: {\n    address?: string;\n    accountId?: string;\n  }): Promise<stellar.FederationServer.Record> {\n    try {\n      const federationServer = this.getBitGoFederationServer();\n      if (address) {\n        return await federationServer.resolveAddress(address);\n      } else if (accountId) {\n        return await federationServer.resolveAccountId(accountId);\n      } else {\n        throw new Error('invalid argument - must provide Stellar address or account id');\n      }\n    } catch (e) {\n      const error = _.get(e, 'response.data.detail');\n      if (error) {\n        throw new StellarFederationUserNotFoundError(error);\n      } else {\n        throw e;\n      }\n    }\n  }\n\n  /**\n   * Attempt to resolve a stellar address into a stellar account\n   *\n   * @param {String} address - stellar address to look for\n   */\n  async federationLookupByName(address: string): Promise<stellar.FederationServer.Record> {\n    if (!address) {\n      throw new Error('invalid Stellar address');\n    }\n\n    return this.federationLookup({ address });\n  }\n\n  /**\n   * Attempt to resolve an account id into a stellar account\n   * Only works for accounts that can be resolved by our federation server\n   *\n   * @param {String} accountId - stellar account id\n   */\n  async federationLookupByAccountId(accountId: string): Promise<stellar.FederationServer.Record> {\n    if (!accountId) {\n      throw new Error('invalid Stellar account');\n    }\n    return this.federationLookup({ accountId });\n  }\n\n  /**\n   * Check if address is a valid XLM address, and then make sure it matches the root address.\n   *\n   * @param address {String} the address to verify\n   * @param rootAddress {String} the wallet's root address\n   */\n  async isWalletAddress({ address, rootAddress }: VerifyAddressOptions): Promise<boolean> {\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    const addressDetails = this.getAddressDetails(address);\n    const rootAddressDetails = this.getAddressDetails(rootAddress);\n    if (addressDetails.baseAddress !== rootAddressDetails.address) {\n      throw new UnexpectedAddressError(\n        `address validation failure: ${addressDetails.baseAddress} vs ${rootAddressDetails.address}`\n      );\n    }\n\n    return true;\n  }\n\n  /**\n   * Get extra parameters for prebuilding a tx\n   * Set empty recipients array in trustline txs\n   */\n  async getExtraPrebuildParams(buildParams: ExtraPrebuildParamsOptions): Promise<BuildOptions> {\n    const params: { recipients?: Record<string, string>[] } = {};\n    if (buildParams.type === 'trustline') {\n      params.recipients = [];\n    }\n    return params;\n  }\n\n  /**\n   * @deprecated\n   */\n  initiateRecovery(params: RecoveryOptions): never {\n    throw new Error('deprecated method');\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param params\n   * - userKey: [encrypted] Stellar private key\n   * - backupKey: [encrypted] Stellar private key, or public key if the private key is held by a KRS provider\n   * - walletPassphrase: necessary if one of the private keys is encrypted\n   * - rootAddress: base address of the wallet to recover funds from\n   * - krsProvider: necessary if backup key is held by KRS\n   * - recoveryDestination: target address to send recovered funds to\n   */\n  async recover(params: RecoveryOptions): Promise<RecoveryTransaction> {\n    // Check if unencrypted root keys were provided, convert to Stellar format if necessary\n    if (Utils.isValidRootPrivateKey(params.userKey)) {\n      params.userKey = Utils.encodePrivateKey(Buffer.from(params.userKey.slice(0, 64), 'hex'));\n    } else if (Utils.isValidRootPublicKey(params.userKey)) {\n      params.userKey = Utils.encodePublicKey(Buffer.from(params.userKey, 'hex'));\n    }\n\n    if (Utils.isValidRootPrivateKey(params.backupKey)) {\n      params.backupKey = Utils.encodePrivateKey(Buffer.from(params.backupKey.slice(0, 64), 'hex'));\n    } else if (Utils.isValidRootPublicKey(params.backupKey)) {\n      params.backupKey = Utils.encodePublicKey(Buffer.from(params.backupKey, 'hex'));\n    }\n\n    // Stellar's Ed25519 public keys start with a G, while private keys start with an S\n    const isKrsRecovery = params.backupKey.startsWith('G') && !params.userKey.startsWith('G');\n    const isUnsignedSweep = params.backupKey.startsWith('G') && params.userKey.startsWith('G');\n\n    if (isKrsRecovery) {\n      checkKrsProvider(this, params.krsProvider);\n    }\n\n    if (!this.isValidAddress(params.recoveryDestination)) {\n      throw new InvalidAddressError('Invalid destination address!');\n    }\n\n    const [userKey, backupKey] = getStellarKeys(this.bitgo, params);\n\n    if (!params.rootAddress || !stellar.StrKey.isValidEd25519PublicKey(params.rootAddress)) {\n      throw new Error(`Invalid wallet address: ${params.rootAddress}`);\n    }\n\n    const accountDataUrl = `${this.getHorizonUrl()}/accounts/${params.rootAddress}`;\n    const destinationUrl = `${this.getHorizonUrl()}/accounts/${params.recoveryDestination}`;\n\n    let accountData;\n    try {\n      accountData = await toBitgoRequest(request.get(accountDataUrl)).result();\n    } catch (e) {\n      throw new Error('Unable to reach the Stellar network via Horizon.');\n    }\n\n    // Now check if the destination account is empty or not\n    let unfundedDestination = false;\n    try {\n      await request.get(destinationUrl);\n    } catch (e) {\n      if (e.status === 404) {\n        // If the destination account does not yet exist, horizon responds with 404\n        unfundedDestination = true;\n      }\n    }\n\n    if (!accountData.sequence || !accountData.balances) {\n      throw new Error('Horizon server error - unable to retrieve sequence ID or account balance');\n    }\n\n    const account = new stellar.Account(params.rootAddress, accountData.sequence);\n\n    // Stellar supports multiple assets on chain, we're only interested in the balances entry whose type is \"native\" (XLM)\n    const nativeBalanceInfo = accountData.balances.find((assetBalance) => assetBalance['asset_type'] === 'native');\n\n    if (!nativeBalanceInfo) {\n      throw new Error('Provided wallet has a balance of 0 XLM, recovery aborted');\n    }\n\n    const walletBalance = Number(this.bigUnitsToBaseUnits(nativeBalanceInfo.balance));\n    const minimumReserve = await this.getMinimumReserve();\n    const baseTxFee = await this.getBaseTransactionFee();\n    const recoveryAmount = walletBalance - minimumReserve - baseTxFee;\n    const formattedRecoveryAmount = this.baseUnitsToBigUnits(recoveryAmount).toString();\n\n    const txBuilder = new stellar.TransactionBuilder(account, {\n      fee: baseTxFee.toFixed(0),\n      networkPassphrase: this.getStellarNetwork(),\n    });\n    const operation = unfundedDestination\n      ? // In this case, we need to create the account\n        stellar.Operation.createAccount({\n          destination: params.recoveryDestination,\n          startingBalance: formattedRecoveryAmount,\n        })\n      : // Otherwise if the account already exists, we do a normal send\n        stellar.Operation.payment({\n          destination: params.recoveryDestination,\n          asset: stellar.Asset.native(),\n          amount: formattedRecoveryAmount,\n        });\n    const tx = txBuilder.addOperation(operation).setTimeout(stellar.TimeoutInfinite).build();\n\n    const feeInfo = {\n      fee: new BigNumber(tx.fee).toNumber(),\n      feeString: tx.fee,\n    };\n\n    if (!isUnsignedSweep) {\n      tx.sign(userKey);\n    }\n\n    if (!isKrsRecovery && !isUnsignedSweep) {\n      tx.sign(backupKey);\n    }\n\n    const transaction: RecoveryTransaction = {\n      txBase64: Xlm.txToString(tx),\n      recoveryAmount,\n    };\n\n    if (isKrsRecovery) {\n      transaction.backupKey = params.backupKey;\n    }\n\n    transaction.coin = this.getChain();\n    transaction.feeInfo = feeInfo;\n\n    return transaction;\n  }\n\n  /**\n   * Assemble keychain and half-sign prebuilt transaction\n   *\n   * @param params\n   * @param params.txPrebuild {Object} prebuild object returned by platform\n   * @param params.prv {String} user prv\n   * @returns {Promise<HalfSignedTransaction>}\n   */\n  async signTransaction(params: SignTransactionOptions): Promise<HalfSignedTransaction> {\n    const { txPrebuild, prv } = params;\n\n    if (_.isUndefined(txPrebuild)) {\n      throw new Error('missing txPrebuild parameter');\n    }\n    if (!_.isObject(txPrebuild)) {\n      throw new Error(`txPrebuild must be an object, got type ${typeof txPrebuild}`);\n    }\n\n    if (_.isUndefined(prv)) {\n      throw new Error('missing prv parameter to sign transaction');\n    }\n    if (!_.isString(prv)) {\n      throw new Error(`prv must be a string, got type ${typeof prv}`);\n    }\n\n    const keyPair = Utils.createStellarKeypairFromPrv(prv);\n    const tx = new stellar.Transaction(txPrebuild.txBase64, this.getStellarNetwork());\n    tx.sign(keyPair);\n    const txBase64 = Xlm.txToString(tx);\n\n    const type = txPrebuild?.buildParams?.type;\n    const recipients = txPrebuild?.buildParams?.recipients;\n    if (type === 'enabletoken') {\n      return {\n        halfSigned: { txBase64 },\n        type,\n        recipients,\n      };\n    } else {\n      return { halfSigned: { txBase64 } };\n    }\n  }\n\n  /**\n   * Extend walletParams with extra params required for generating an XLM wallet\n   *\n   * Stellar wallets have three keychains on them. Two are generated by the platform, and the last is generated by the user.\n   * Initially, we need a root prv to generate the account, which must be distinct from all three keychains on the wallet.\n   * If a root prv is not provided, a random one is generated.\n   */\n  async supplementGenerateWallet(\n    walletParams: SupplementGenerateWalletOptions\n  ): Promise<SupplementGenerateWalletOptions> {\n    let seed;\n    const rootPrv = walletParams.rootPrivateKey;\n    if (rootPrv) {\n      if (!this.isValidPrv(rootPrv)) {\n        throw new Error('rootPrivateKey needs to be valid ed25519 secret seed');\n      }\n      seed = stellar.StrKey.decodeEd25519SecretSeed(rootPrv);\n    }\n    const keyPair = this.generateKeyPair(seed);\n    // extend the wallet initialization params\n    walletParams.rootPrivateKey = keyPair.prv;\n    return walletParams;\n  }\n\n  /**\n   * Sign message with private key\n   *\n   * @param key\n   * @param message\n   */\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    if (!this.isValidPrv(key.prv)) {\n      throw new Error(`invalid prv: ${key.prv}`);\n    }\n    if (!Buffer.isBuffer(message)) {\n      message = Buffer.from(message);\n    }\n\n    const keypair = Utils.createStellarKeypairFromPrv(key.prv);\n    return keypair.sign(message);\n  }\n\n  /**\n   * Verifies if signature for message is valid.\n   *\n   * @param pub public key\n   * @param message signed message\n   * @param signature signature to verify\n   * @returns true if signature is valid.\n   */\n  verifySignature(pub: string, message: string | Buffer, signature: Buffer) {\n    if (!this.isValidPub(pub)) {\n      throw new Error(`invalid pub: ${pub}`);\n    }\n    if (!Buffer.isBuffer(message)) {\n      message = Buffer.from(message);\n    }\n\n    const keyPair = Utils.createStellarKeypairFromPub(pub);\n    return keyPair.verify(message, signature);\n  }\n\n  /**\n   * Explain/parse transaction\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    const { txHex, txBase64 } = params;\n    let tx: stellar.Transaction | undefined = undefined;\n\n    if (!txHex && !txBase64) {\n      throw new Error('explainTransaction missing txHex or txBase64 parameter, must have at least one');\n    }\n\n    try {\n      if (txHex) {\n        tx = new stellar.Transaction(Buffer.from(txHex, 'hex').toString('base64'), this.getStellarNetwork());\n      } else if (txBase64) {\n        tx = new stellar.Transaction(txBase64, this.getStellarNetwork());\n      }\n    } catch (e) {\n      throw new Error('txBase64 needs to be a valid tx encoded as base64 string');\n    }\n\n    if (!tx) {\n      throw new Error('tx needs to be defined in order to explain transaction');\n    }\n    const id = tx.hash().toString('hex');\n\n    // In a Stellar tx, the _memo property is an object with the methods:\n    // value() and arm() that provide memo value and type, respectively.\n    const memo: TransactionMemo =\n      _.result(tx, '_memo.value') && _.result(tx, '_memo.arm')\n        ? {\n            value: (_.result(tx, '_memo.value') as any).toString(),\n            type: _.result(tx, '_memo.arm'),\n          }\n        : {};\n\n    let spendAmount = new BigNumber(0); // amount of XLM used in XLM-only txs\n    const spendAmounts = {}; // track both xlm and token amounts\n    if (_.isEmpty(tx.operations)) {\n      throw new Error('missing operations');\n    }\n\n    const outputs: TransactionOutput[] = [];\n    const operations: TransactionOperation[] = []; // non-payment operations\n\n    _.forEach(tx.operations, (op: stellar.Operation) => {\n      if (op.type === 'createAccount' || op.type === 'payment') {\n        // TODO Remove memoId from address\n        // Get memo to attach to address, if type is 'id'\n        const memoId = _.get(memo, 'type') === 'id' && !_.get(memo, 'value') ? `?memoId=${memo.value}` : '';\n        let asset;\n        if (op.type === 'payment') {\n          if (op.asset.getAssetType() === 'liquidity_pool_shares') {\n            throw new Error('Invalid asset type');\n          }\n          asset = op.asset as stellar.Asset;\n        } else {\n          asset = stellar.Asset.native();\n        }\n        const coin = this.getTokenNameFromStellarAsset(asset); // coin or token id\n        const output: TransactionOutput = {\n          amount: this.bigUnitsToBaseUnits(\n            (op as stellar.Operation.CreateAccount).startingBalance || (op as stellar.Operation.Payment).amount\n          ),\n          address: op.destination + memoId,\n          coin,\n        };\n\n        if (!_.isUndefined(spendAmounts[coin])) {\n          spendAmounts[coin] = spendAmounts[coin].plus(output.amount);\n        } else {\n          spendAmounts[coin] = new BigNumber(output.amount);\n        }\n        if (asset.isNative()) {\n          spendAmount = spendAmount.plus(output.amount);\n        }\n        outputs.push(output);\n      } else if (op.type === 'changeTrust') {\n        if (op.line.getAssetType() === 'liquidity_pool_shares') {\n          throw new Error('Invalid asset type');\n        }\n        const asset = op.line as stellar.Asset;\n\n        operations.push({\n          type: op.type,\n          coin: this.getTokenNameFromStellarAsset(asset),\n          asset,\n          limit: this.bigUnitsToBaseUnits(op.limit),\n        });\n      }\n    });\n\n    const outputAmount = spendAmount.toFixed(0);\n    const outputAmounts = _.mapValues(spendAmounts, (amount: BigNumber) => amount.toFixed(0));\n    const fee = {\n      fee: new BigNumber(tx.fee).toFixed(0),\n      feeRate: null,\n      size: null,\n    };\n\n    return {\n      displayOrder: [\n        'id',\n        'outputAmount',\n        'outputAmounts',\n        'changeAmount',\n        'outputs',\n        'changeOutputs',\n        'fee',\n        'memo',\n        'operations',\n      ],\n      id,\n      outputs,\n      outputAmount,\n      outputAmounts,\n      changeOutputs: [],\n      changeAmount: '0',\n      memo,\n      fee,\n      operations,\n    } as any;\n  }\n\n  /**\n   * Verify that a tx prebuild's operations comply with the original intention\n   * @param {stellar.Operation} operations - tx operations\n   * @param {TransactionParams} txParams - params used to build the tx\n   */\n  verifyEnableTokenTxOperations(operations: stellar.Operation[], txParams: TransactionParams): void {\n    const trustlineOperations = _.filter(operations, ['type', 'changeTrust']) as stellar.Operation.ChangeTrust[];\n    if (trustlineOperations.length !== _.get(txParams, 'recipients', []).length) {\n      throw new Error('transaction prebuild does not match expected trustline operations');\n    }\n    _.forEach(trustlineOperations, (op: stellar.Operation) => {\n      if (op.type !== 'changeTrust') {\n        throw new Error('Invalid asset type');\n      }\n      if (op.line.getAssetType() === 'liquidity_pool_shares') {\n        throw new Error('Invalid asset type');\n      }\n      const asset = op.line as stellar.Asset;\n      const opToken = this.getTokenNameFromStellarAsset(asset);\n      const tokenTrustline = _.find(txParams.recipients, (recipient) => {\n        // trustline params use limits in base units\n        const opLimitBaseUnits = this.bigUnitsToBaseUnits(op.limit);\n        // Enable token limit is set to Xlm.maxTrustlineLimit by default\n        return recipient.tokenName === opToken && opLimitBaseUnits === Xlm.maxTrustlineLimit;\n      });\n      if (!tokenTrustline) {\n        throw new Error('transaction prebuild does not match expected trustline tokens');\n      }\n    });\n  }\n\n  /**\n   * Verify that a tx prebuild's operations comply with the original intention\n   * @param {stellar.Operation} operations - tx operations\n   * @param {TransactionParams} txParams - params used to build the tx\n   */\n  verifyTrustlineTxOperations(operations: stellar.Operation[], txParams: TransactionParams): void {\n    const trustlineOperations = _.filter(operations, ['type', 'changeTrust']) as stellar.Operation.ChangeTrust[];\n    if (trustlineOperations.length !== _.get(txParams, 'trustlines', []).length) {\n      throw new Error('transaction prebuild does not match expected trustline operations');\n    }\n    _.forEach(trustlineOperations, (op: stellar.Operation) => {\n      if (op.type !== 'changeTrust') {\n        throw new Error('Invalid asset type');\n      }\n      if (op.line.getAssetType() === 'liquidity_pool_shares') {\n        throw new Error('Invalid asset type');\n      }\n      const asset = op.line as stellar.Asset;\n      const opToken = this.getTokenNameFromStellarAsset(asset);\n      const tokenTrustline = _.find(txParams.trustlines, (trustline) => {\n        // trustline params use limits in base units\n        const opLimitBaseUnits = this.bigUnitsToBaseUnits(op.limit);\n        // Prepare the conditions to check for\n        // Limit will always be set in the operation, even if it was omitted from txParams in the following cases:\n        // 1. Action is 'add' - limit is set to Xlm.maxTrustlineLimit by default\n        // 2. Action is 'remove' - limit is set to '0'\n        const noLimit = _.isUndefined(trustline.limit);\n        const addTrustlineWithDefaultLimit = trustline.action === 'add' && opLimitBaseUnits === Xlm.maxTrustlineLimit;\n        const removeTrustline = trustline.action === 'remove' && opLimitBaseUnits === '0';\n        return (\n          trustline.token === opToken &&\n          (trustline.limit === opLimitBaseUnits || (noLimit && (addTrustlineWithDefaultLimit || removeTrustline)))\n        );\n      });\n      if (!tokenTrustline) {\n        throw new Error('transaction prebuild does not match expected trustline tokens');\n      }\n    });\n  }\n\n  /**\n   * Verify that a transaction prebuild complies with the original intention\n   *\n   * @param options\n   * @param options.txPrebuild prebuild object returned by platform\n   * @param options.txPrebuild.txBase64 prebuilt transaction encoded as base64 string\n   * @param options.wallet wallet object to obtain keys to verify against\n   * @param options.verification specifying some verification parameters\n   * @param options.verification.disableNetworking Disallow fetching any data from the internet for verification purposes\n   * @param options.verification.keychains Pass keychains manually rather than fetching them by id\n   */\n  async verifyTransaction(options: VerifyTransactionOptions): Promise<boolean> {\n    // TODO BG-5600 Add parseTransaction / improve verification\n    const { txParams, txPrebuild, wallet, verification = {} } = options;\n    const disableNetworking = !!verification.disableNetworking;\n\n    if (!txPrebuild.txBase64) {\n      throw new Error('missing required tx prebuild property txBase64');\n    }\n\n    const tx = new stellar.Transaction(txPrebuild.txBase64, this.getStellarNetwork());\n\n    if (txParams.recipients && txParams.recipients.length > 1) {\n      throw new Error('cannot specify more than 1 recipient');\n    }\n\n    // Stellar txs are made up of operations. We only care about Create Account and Payment for sending funds.\n    const outputOperations = _.filter(\n      tx.operations,\n      (operation) => operation.type === 'createAccount' || operation.type === 'payment'\n    );\n\n    if (txParams.type === 'enabletoken') {\n      this.verifyEnableTokenTxOperations(tx.operations, txParams);\n    } else if (txParams.type === 'trustline') {\n      this.verifyTrustlineTxOperations(tx.operations, txParams);\n    } else {\n      if (_.isEmpty(outputOperations)) {\n        throw new Error('transaction prebuild does not have any operations');\n      }\n\n      _.forEach(txParams.recipients, (expectedOutput, index) => {\n        const expectedOutputAddressDetails = this.getAddressDetails(expectedOutput.address);\n        const expectedOutputAddress = expectedOutputAddressDetails.address;\n        const output = outputOperations[index] as stellar.Operation.Payment | stellar.Operation.CreateAccount;\n        if (output.destination !== expectedOutputAddress) {\n          throw new Error('transaction prebuild does not match expected recipient');\n        }\n\n        const expectedOutputAmount = new BigNumber(expectedOutput.amount);\n        // The output amount is expressed as startingBalance in createAccount operations and as amount in payment operations.\n        const outputAmountString = output.type === 'createAccount' ? output.startingBalance : output.amount;\n        const outputAmount = new BigNumber(this.bigUnitsToBaseUnits(outputAmountString));\n\n        if (!outputAmount.eq(expectedOutputAmount)) {\n          throw new Error('transaction prebuild does not match expected amount');\n        }\n      });\n    }\n\n    // Verify the user signature, if the tx is half-signed\n    if (!_.isEmpty(tx.signatures)) {\n      const userSignature = tx.signatures[0].signature();\n\n      // obtain the keychains and key signatures\n      let keychains = verification.keychains;\n      if (!keychains && disableNetworking) {\n        throw new Error('cannot fetch keychains without networking');\n      } else if (!keychains) {\n        keychains = await promiseProps({\n          user: this.keychains().get({ id: wallet.keyIds()[KeyIndices.USER] }),\n          backup: this.keychains().get({ id: wallet.keyIds()[KeyIndices.BACKUP] }),\n        });\n      }\n\n      if (!keychains || !keychains.backup || !keychains.user) {\n        throw new Error('keychains are required, but could not be fetched');\n      }\n\n      assert(keychains.backup.pub);\n      if (this.verifySignature(keychains.backup.pub, tx.hash(), userSignature)) {\n        throw new Error('transaction signed with wrong key');\n      }\n      assert(keychains.user.pub);\n      if (!this.verifySignature(keychains.user.pub, tx.hash(), userSignature)) {\n        throw new Error('transaction signature invalid');\n      }\n    }\n\n    return true;\n  }\n\n  /** inheritdoc */\n  deriveKeyWithSeed(): { derivationPath: string; key: string } {\n    throw new NotSupported('method deriveKeyWithSeed not supported for eddsa curve');\n  }\n\n  /**\n   * stellar-sdk has two overloads for toXDR, and typescript can't seem to figure out the\n   * correct one to use, so we have to be very explicit as to which one we want.\n   * @param tx transaction to convert\n   */\n  protected static txToString = (tx: stellar.Transaction): string =>\n    (tx.toEnvelope().toXDR as (_: string) => string)('base64');\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Gets config for how token enablements work for this coin\n   * @returns\n   *    requiresTokenEnablement: True if tokens need to be enabled for this coin\n   *    supportsMultipleTokenEnablements: True if multiple tokens can be enabled in one transaction\n   */\n  getTokenEnablementConfig(): TokenEnablementConfig {\n    return {\n      requiresTokenEnablement: true,\n      supportsMultipleTokenEnablements: false,\n    };\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ publicKey, prv, multiSigType }: AuditDecryptedKeyParams) {\n    if (multiSigType === 'tss') {\n      throw new Error('Unsupported multiSigType');\n    }\n\n    let xlmKeyPair;\n    try {\n      xlmKeyPair = new StellarKeyPair({ prv });\n    } catch (e) {\n      // Avoid adding the error message to the thrown error because it can contain sensitive information\n      throw new Error(`Invalid private key: Unable to generate keypair from prv`);\n    }\n\n    if (publicKey && publicKey !== xlmKeyPair.getKeys().pub) {\n      throw new Error('Invalid public key');\n    }\n  }\n}\n"]}Выполнить команду
Для локальной разработки. Не используйте в интернете!