@ledgerhq/coin-stellar
Version:
Ledger Stellar Coin integration
173 lines • 7.15 kB
JavaScript
import { LedgerAPI4xx } from "@ledgerhq/errors";
import { log } from "@ledgerhq/logs";
import { xdr } from "@stellar/stellar-sdk";
import { getEnv } from "@ledgerhq/live-env";
import coinConfig from "../config";
import { broadcast, combine, craftTransaction, estimateFees, getBalance, validateIntent, lastBlock, listOperations, STELLAR_BURN_ADDRESS, getTokenFromAsset, getAssetFromToken, } from "../logic";
import { StellarBurnAddressError } from "../types";
import { fetchSequence } from "../network";
export function createApi(config) {
coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
return {
broadcast,
combine: compose,
craftTransaction: craft,
craftRawTransaction: (_transaction, _sender, _publicKey, _sequence) => {
throw new Error("craftRawTransaction is not supported");
},
estimateFees: estimate,
getBalance,
lastBlock,
listOperations: operations,
getBlock(_height) {
throw new Error("getBlock is not supported");
},
getBlockInfo(_height) {
throw new Error("getBlockInfo is not supported");
},
getStakes(_address, _cursor) {
throw new Error("getStakes is not supported");
},
getRewards(_address, _cursor) {
throw new Error("getRewards is not supported");
},
validateIntent,
getSequence: async (address) => {
const sequence = await fetchSequence(address);
// NOTE: might not do plus one here, or if we do, rename to getNextValidSequence
return BigInt(sequence.plus(1).toFixed());
},
getTokenFromAsset,
getAssetFromToken,
getChainSpecificRules: () => ({
getAccountShape: (address) => {
// NOTE: https://github.com/LedgerHQ/ledger-live/pull/2058
if (address === STELLAR_BURN_ADDRESS) {
throw new StellarBurnAddressError();
}
},
getTransactionStatus: {
throwIfPendingOperation: true,
},
}),
getValidators(_cursor) {
throw new Error("getValidators is not supported");
},
};
}
async function craft(transactionIntent, customFees) {
const fees = customFees?.value || (await estimateFees());
// NOTE: check how many memos, throw if more than one?
// if (transactionIntent.memos && transactionIntent.memos.length > 1) {
// throw new Error("Stellar only supports one memo per transaction.");
// }
const memo = "memo" in transactionIntent ? transactionIntent.memo : undefined;
const hasMemoValue = memo && memo.type !== "NO_MEMO";
const tx = await craftTransaction({ address: transactionIntent.sender }, {
type: transactionIntent.type,
recipient: transactionIntent.recipient,
amount: transactionIntent.amount,
fee: fees,
...(transactionIntent.asset.type !== "native" && "assetReference" in transactionIntent.asset
? {
assetCode: transactionIntent.asset.assetReference,
assetIssuer: transactionIntent.asset.assetOwner,
}
: {}),
memoType: memo?.type,
...(hasMemoValue ? { memoValue: memo.value } : {}),
});
// Note: the API returns the signature base, not the full XDR, see BACK-8727 for more context
return { transaction: tx.signatureBase };
}
function compose(tx, signature, pubkey) {
if (!pubkey) {
throw new Error("Missing pubkey");
}
// note: accept here `TransactionEnvelope` or `TransactionSignaturePayload`, see BACK-8727 for more context
return combine(envelopeFromAnyXDR(tx, "base64"), signature, pubkey);
}
async function estimate(_transactionIntent) {
const value = await estimateFees();
return { value };
}
async function operations(address, pagination) {
const minHeight = pagination.minHeight;
const lastPagingToken = pagination.lastPagingToken ?? "";
if (minHeight) {
return operationsFromHeight(address, minHeight);
}
const isInitSync = lastPagingToken === "";
// FIXME: why bother creating limit and pagingToken here, something is off?!
const newPagination = isInitSync
? { limit: getEnv("API_STELLAR_HORIZON_INITIAL_FETCH_MAX_OPERATIONS"), minHeight: 0 }
: { pagingToken: lastPagingToken, minHeight: 0 };
return operationsFromHeight(address, newPagination.minHeight);
}
async function operationsFromHeight(address, minHeight) {
const state = {
pageSize: 200,
heightLimit: minHeight,
continueIterations: true,
accumulator: [],
};
// unfortunately, the stellar API does not support an option to filter by min height
// so the only strategy to get ALL operations is to iterate over all of them in descending order
// until we reach the desired minHeight
while (state.continueIterations) {
const options = { limit: state.pageSize, order: "desc", minHeight };
if (state.apiNextCursor) {
options.cursor = state.apiNextCursor;
}
try {
const [operations, nextCursor] = await listOperations(address, options);
state.accumulator.push(...operations);
state.apiNextCursor = nextCursor;
state.continueIterations = nextCursor !== "";
}
catch (e) {
if (e instanceof LedgerAPI4xx && e.status === 429) {
log("coin:stellar", "(api/operations): TooManyRequests, retrying in 4s");
await new Promise(resolve => setTimeout(resolve, 4000));
}
else {
throw e;
}
}
}
return [state.accumulator, state.apiNextCursor ? state.apiNextCursor : ""];
}
/**
* Deserialize a transaction envelope, also accepting transaction signature payload form.
*
* @param input serialized `TransactionEnvelope` or `TransactionSignaturePayload`
* @param format serialization encoding
*/
export function envelopeFromAnyXDR(input, format) {
try {
return xdr.TransactionEnvelope.fromXDR(input, format);
}
catch (envelopeError) {
try {
return signatureBaseToEnvelope(xdr.TransactionSignaturePayload.fromXDR(input, format));
}
catch (signatureBaseError) {
throw new Error(`Failed decoding transaction as an envelope (${envelopeError}) or as a signature base: (${signatureBaseError})`);
}
}
}
/**
* Convert a `TransactionSignaturePayload` into a `TransactionEnvelope`.
*
* @param signatureBase deserialized `TransactionSignaturePayload`
*/
function signatureBaseToEnvelope(signatureBase) {
const tx = signatureBase.taggedTransaction().value();
if (tx instanceof xdr.Transaction) {
return xdr.TransactionEnvelope.envelopeTypeTx(new xdr.TransactionV1Envelope({ tx, signatures: [] }));
}
else {
return xdr.TransactionEnvelope.envelopeTypeTxFeeBump(new xdr.FeeBumpTransactionEnvelope({ tx, signatures: [] }));
}
}
//# sourceMappingURL=index.js.map