@ledgerhq/coin-stellar
Version:
Ledger Stellar Coin integration
181 lines • 7.72 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.envelopeFromAnyXDR = exports.createApi = void 0;
const errors_1 = require("@ledgerhq/errors");
const logs_1 = require("@ledgerhq/logs");
const stellar_sdk_1 = require("@stellar/stellar-sdk");
const live_env_1 = require("@ledgerhq/live-env");
const config_1 = __importDefault(require("../config"));
const logic_1 = require("../logic");
const types_1 = require("../types");
const network_1 = require("../network");
function createApi(config) {
config_1.default.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
return {
broadcast: logic_1.broadcast,
combine: compose,
craftTransaction: craft,
craftRawTransaction: (_transaction, _sender, _publicKey, _sequence) => {
throw new Error("craftRawTransaction is not supported");
},
estimateFees: estimate,
getBalance: logic_1.getBalance,
lastBlock: logic_1.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: logic_1.validateIntent,
getSequence: async (address) => {
const sequence = await (0, network_1.fetchSequence)(address);
// NOTE: might not do plus one here, or if we do, rename to getNextValidSequence
return BigInt(sequence.plus(1).toFixed());
},
getTokenFromAsset: logic_1.getTokenFromAsset,
getAssetFromToken: logic_1.getAssetFromToken,
getChainSpecificRules: () => ({
getAccountShape: (address) => {
// NOTE: https://github.com/LedgerHQ/ledger-live/pull/2058
if (address === logic_1.STELLAR_BURN_ADDRESS) {
throw new types_1.StellarBurnAddressError();
}
},
getTransactionStatus: {
throwIfPendingOperation: true,
},
}),
getValidators(_cursor) {
throw new Error("getValidators is not supported");
},
};
}
exports.createApi = createApi;
async function craft(transactionIntent, customFees) {
const fees = customFees?.value || (await (0, logic_1.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 (0, logic_1.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 (0, logic_1.combine)(envelopeFromAnyXDR(tx, "base64"), signature, pubkey);
}
async function estimate(_transactionIntent) {
const value = await (0, logic_1.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: (0, live_env_1.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 (0, logic_1.listOperations)(address, options);
state.accumulator.push(...operations);
state.apiNextCursor = nextCursor;
state.continueIterations = nextCursor !== "";
}
catch (e) {
if (e instanceof errors_1.LedgerAPI4xx && e.status === 429) {
(0, logs_1.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
*/
function envelopeFromAnyXDR(input, format) {
try {
return stellar_sdk_1.xdr.TransactionEnvelope.fromXDR(input, format);
}
catch (envelopeError) {
try {
return signatureBaseToEnvelope(stellar_sdk_1.xdr.TransactionSignaturePayload.fromXDR(input, format));
}
catch (signatureBaseError) {
throw new Error(`Failed decoding transaction as an envelope (${envelopeError}) or as a signature base: (${signatureBaseError})`);
}
}
}
exports.envelopeFromAnyXDR = envelopeFromAnyXDR;
/**
* Convert a `TransactionSignaturePayload` into a `TransactionEnvelope`.
*
* @param signatureBase deserialized `TransactionSignaturePayload`
*/
function signatureBaseToEnvelope(signatureBase) {
const tx = signatureBase.taggedTransaction().value();
if (tx instanceof stellar_sdk_1.xdr.Transaction) {
return stellar_sdk_1.xdr.TransactionEnvelope.envelopeTypeTx(new stellar_sdk_1.xdr.TransactionV1Envelope({ tx, signatures: [] }));
}
else {
return stellar_sdk_1.xdr.TransactionEnvelope.envelopeTypeTxFeeBump(new stellar_sdk_1.xdr.FeeBumpTransactionEnvelope({ tx, signatures: [] }));
}
}
//# sourceMappingURL=index.js.map