@okxweb3/coin-stellar
Version:
@ok/coin-stellar is a Stellar SDK for building Web3 wallets and applications. It supports Stellar and PI blockchains, enabling private key management, address generation, transaction signing, trustline creation, and asset transfers
193 lines • 7.39 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.StellarWallet = void 0;
const coin_base_1 = require("@okxweb3/coin-base");
const lib_1 = require("./lib");
const crypto_lib_1 = require("@okxweb3/crypto-lib");
const utils_1 = require("./utils");
class StellarWallet extends coin_base_1.BaseWallet {
async getDerivedPath(param) {
return `m/44'/148'/${param.index}'`;
}
async getRandomPrivateKey() {
try {
let pri = crypto_lib_1.signUtil.ed25519.ed25519_getRandomPrivateKey(false, 'hex');
return Promise.resolve(lib_1.StrKey.encodeEd25519SecretSeed(coin_base_1.base.fromHex(pri)));
}
catch (e) {
return Promise.reject(coin_base_1.GenPrivateKeyError);
}
}
async getDerivedPrivateKey(param) {
try {
const key = await crypto_lib_1.signUtil.ed25519.ed25519_getDerivedPrivateKey(param.mnemonic, param.hdPath, false, 'hex');
return Promise.resolve(lib_1.StrKey.encodeEd25519SecretSeed(coin_base_1.base.fromHex(key)));
}
catch (e) {
return Promise.reject(coin_base_1.GenPrivateKeyError);
}
}
validPrivateKey(param) {
let isValid;
try {
let k = lib_1.Keypair.fromSecret(param.privateKey);
let rawKey = k.rawSecretKey();
if (rawKey.every((byte) => byte === 0)) {
isValid = false;
}
else {
isValid = true;
}
}
catch (e) {
isValid = false;
}
const data = {
isValid: isValid,
privateKey: param.privateKey,
};
return Promise.resolve(data);
}
getNewAddress(param) {
try {
let k = lib_1.Keypair.fromSecret(param.privateKey);
let rawKey = k.rawSecretKey();
if (rawKey.every((byte) => byte === 0)) {
throw new Error('invalid key');
}
return Promise.resolve({
address: k.publicKey(),
publicKey: coin_base_1.base.toHex(k.rawPublicKey()),
});
}
catch (error) {
return Promise.reject(coin_base_1.NewAddressError);
}
}
getMuxedAddress(param) {
try {
if (!param.address) {
throw new Error('Missing address');
}
let muxedAcc = (0, lib_1.encodeMuxedAccount)(param.address, param.id);
return Promise.resolve((0, lib_1.encodeMuxedAccountToAddress)(muxedAcc));
}
catch (error) {
return Promise.reject(coin_base_1.NewAddressError);
}
}
signMessage(param) {
return Promise.reject(coin_base_1.NotImplementedError);
}
calcTxHash(param) {
const tx = lib_1.TransactionBuilder.fromXDR(param.data.tx, param.data.networkPassphrase);
return Promise.resolve(coin_base_1.base.toHex(tx.hash()));
}
async signTransaction(param) {
try {
const txParam = param.data;
let timebounds = txParam.timebounds
? txParam.timebounds
: { minTime: 0, maxTime: 0 };
const transactionBuilder = new lib_1.TransactionBuilder(new lib_1.Account(txParam.source, txParam.sequence), {
fee: txParam.fee,
timebounds: timebounds,
ledgerbounds: txParam.ledgerbounds,
minAccountSequence: txParam.minAccountSequence,
minAccountSequenceAge: txParam.minAccountSequenceAge,
minAccountSequenceLedgerGap: txParam.minAccountSequenceLedgerGap,
extraSigners: txParam.extraSigners,
memo: txParam.memo ? lib_1.Memo.text(txParam.memo) : lib_1.Memo.none(),
networkPassphrase: txParam.networkPassphrase,
});
if (!txParam.decimals) {
return Promise.reject('missing decimals');
}
if (txParam.type === 'transfer') {
if (!txParam.toAddress) {
return Promise.reject(coin_base_1.ValidAddressError);
}
const validation = await this.validAddress({
address: txParam.toAddress,
});
if (!validation.isValid) {
return Promise.reject(coin_base_1.ValidAddressError);
}
let op;
if (txParam.asset) {
const asset = new lib_1.Asset(txParam.asset.assetName, txParam.asset.issuer);
op = lib_1.Operation.payment({
destination: txParam.toAddress,
asset: asset,
amount: (0, utils_1.convertWithDecimals)(txParam.asset.amount, txParam.decimals),
});
}
else {
if (!txParam.amount) {
return Promise.reject('missing amount');
}
op = lib_1.Operation.payment({
destination: txParam.toAddress,
asset: lib_1.Asset.native(),
amount: (0, utils_1.convertWithDecimals)(txParam.amount, txParam.decimals),
});
}
transactionBuilder.addOperation(op);
}
else if (txParam.type === 'changeTrust') {
if (!txParam.asset) {
return Promise.reject('missing asset');
}
const asset = new lib_1.Asset(txParam.asset.assetName, txParam.asset.issuer);
let op = lib_1.Operation.changeTrust({
asset: asset,
limit: (0, utils_1.convertWithDecimals)(txParam.asset.amount, txParam.decimals),
});
transactionBuilder.addOperation(op);
}
else {
return Promise.reject('invalid tx type');
}
let transaction = transactionBuilder.build();
if (param.privateKey) {
let kp = lib_1.Keypair.fromSecret(param.privateKey);
transaction.sign(kp);
}
return Promise.resolve(transaction.toXDR());
}
catch (e) {
return Promise.reject(coin_base_1.SignTxError);
}
}
async signCommonMsg(params) {
let k = lib_1.Keypair.fromSecret(params.privateKey);
return super.signCommonMsg({
privateKey: params.privateKey,
privateKeyHex: coin_base_1.base.toHex(k.rawSecretKey()),
message: params.message,
signType: coin_base_1.SignType.ED25519,
});
}
validAddress(param) {
let isValid;
try {
lib_1.StrKey.decodeEd25519PublicKey(param.address);
isValid = true;
}
catch (e) {
try {
(0, lib_1.decodeAddressToMuxedAccount)(param.address);
isValid = true;
}
catch (e) {
isValid = false;
}
}
return Promise.resolve({
isValid: isValid,
address: param.address,
});
}
}
exports.StellarWallet = StellarWallet;
//# sourceMappingURL=StellarWallet.js.map