@xchainjs/xchain-solana 1.0.9 → 1.1.0

package/lib/client.d.ts

@@ -1,9 +1,15 @@
+import { Umi } from '@metaplex-foundation/umi';
+import { Connection } from '@solana/web3.js';
 import { AssetInfo, BaseXChainClient, Fees, Network, PreparedTx, TxHash, TxHistoryParams } from '@xchainjs/xchain-client';
 import { Address, TokenAsset } from '@xchainjs/xchain-util';
 import { Balance, SOLClientParams, Tx, TxParams, TxsPage } from './types';
+type Providers = {
+    solanaProvider: Connection;
+    umiProvider: Umi;
+};
 export declare class Client extends BaseXChainClient {
     private explorerProviders;
-    private providers;
+    protected providers: Providers[];
     private clientUrls?;
     constructor(params?: SOLClientParams);
     /**
@@ -174,3 +180,4 @@ export declare class Client extends BaseXChainClient {
      */
     private roundRobinPrepareTx;
 }
+export {};

package/lib/clientLedger.d.ts

@@ -0,0 +1,28 @@
+import SolanaLedgerApp from '@ledgerhq/hw-app-solana';
+import Transport from '@ledgerhq/hw-transport';
+import { Address } from '@xchainjs/xchain-util';
+import { Client } from './client';
+import { SOLClientParams, TxParams } from './types';
+export type SOLClientLedgerParams = SOLClientParams & {
+    transport: Transport;
+};
+/**
+ * Custom Tron Ledger client extending the base Tron client
+ */
+declare class ClientLedger extends Client {
+    private transport;
+    private ledgerApp;
+    constructor(params: SOLClientLedgerParams);
+    getApp(): SolanaLedgerApp;
+    getAddress(): string;
+    getDerivationPath(index?: number): string;
+    getAddressAsync(index?: number, verify?: boolean): Promise<Address>;
+    /**
+     * Transfers SOL or Solana token using ledger
+     *
+     * @param {TxParams} params The transfer options.
+     * @returns {TxHash} The transaction hash.
+     */
+    transfer({ walletIndex, recipient, asset, amount, memo, limit, priorityFee, allowOwnerOffCurve, }: TxParams): Promise<string>;
+}
+export { ClientLedger };

package/lib/index.d.ts

@@ -1,3 +1,4 @@
 export { Client } from './client';
+export { ClientLedger } from './clientLedger';
 export * from './types';
 export * from './const';

package/lib/index.esm.js

@@ -9,6 +9,7 @@ import { getSeed } from '@xchainjs/xchain-crypto';
 import { AssetType, baseAmount, assetToBase, assetAmount, assetFromStringEx, eqAsset, getContractAddressFromAsset } from '@xchainjs/xchain-util';
 import bs58 from 'bs58';
 import slip10 from 'micro-key-producer/slip10.js';
+import SolanaLedgerApp from '@ledgerhq/hw-app-solana';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -708,10 +709,140 @@ class Client extends BaseXChainClient {
                     return { rawUnsignedTx: bs58.encode(transaction.serialize({ verifySignatures: false })) };
                 }
             }
-            catch (_b) { }
+            catch (error) {
+                console.log('prepareTx error', error);
+            }
             throw Error('No provider able to prepare transaction');
         });
     }
 }
 
-export { Client, SOLAsset, SOLChain, SOL_DECIMALS, defaultSolanaParams };
+/**
+ * Custom Tron Ledger client extending the base Tron client
+ */
+class ClientLedger extends Client {
+    constructor(params) {
+        const clientParams = Object.assign(Object.assign({}, defaultSolanaParams), params);
+        super(clientParams);
+        this.transport = params.transport;
+        this.ledgerApp = new SolanaLedgerApp(this.transport);
+    }
+    getApp() {
+        if (this.ledgerApp)
+            return this.ledgerApp;
+        this.ledgerApp = new SolanaLedgerApp(this.transport);
+        return this.ledgerApp;
+    }
+    // Get the current address synchronously - not supported for Ledger Client
+    getAddress() {
+        throw Error('Sync method not supported for Ledger');
+    }
+    // get derivation path for ledger
+    getDerivationPath(index = 0) {
+        const derivationPath = this.getFullDerivationPath(index);
+        return derivationPath.replace(/^m\//, '');
+    }
+    // Get the current address asynchronously
+    getAddressAsync() {
+        return __awaiter(this, arguments, void 0, function* (index = 0, verify = false) {
+            const derivationPath = this.getDerivationPath(index);
+            const result = yield this.getApp().getAddress(derivationPath, verify);
+            const publicKey = new PublicKey(Buffer.from(result.address));
+            return publicKey.toBase58(); // return base58 solana address format
+        });
+    }
+    /**
+     * Transfers SOL or Solana token using ledger
+     *
+     * @param {TxParams} params The transfer options.
+     * @returns {TxHash} The transaction hash.
+     */
+    transfer(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ walletIndex = 0, recipient, asset, amount, memo, limit, priorityFee, allowOwnerOffCurve, }) {
+            const sender = yield this.getAddressAsync(walletIndex);
+            try {
+                for (const provider of this.providers) {
+                    const transaction = new Transaction();
+                    const fromPubkey = new PublicKey(sender);
+                    const toPubkey = new PublicKey(recipient);
+                    transaction.recentBlockhash = yield provider.solanaProvider
+                        .getLatestBlockhash()
+                        .then((block) => block.blockhash);
+                    transaction.feePayer = new PublicKey(sender);
+                    if (!asset || eqAsset(asset, this.getAssetInfo().asset)) {
+                        // Native transfer
+                        transaction.add(SystemProgram.transfer({
+                            fromPubkey,
+                            toPubkey,
+                            lamports: amount.amount().toNumber(),
+                        }));
+                    }
+                    else {
+                        // Token transfer
+                        const mintAddress = new PublicKey(getContractAddressFromAsset(asset));
+                        const fromAssociatedAccount = getAssociatedTokenAddressSync(mintAddress, fromPubkey);
+                        let fromTokenAccount;
+                        try {
+                            fromTokenAccount = yield getAccount(provider.solanaProvider, fromAssociatedAccount);
+                        }
+                        catch (error) {
+                            if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+                                throw Error('Can not find sender Token account');
+                            }
+                            throw error;
+                        }
+                        const toAssociatedAccount = getAssociatedTokenAddressSync(mintAddress, toPubkey, allowOwnerOffCurve);
+                        let toTokenAccount;
+                        try {
+                            toTokenAccount = yield getAccount(provider.solanaProvider, toAssociatedAccount);
+                        }
+                        catch (error) {
+                            if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+                                throw Error('Can not find recipient Token account. Create it first');
+                            }
+                            throw error;
+                        }
+                        transaction.add(createTransferInstruction(fromTokenAccount.address, toTokenAccount.address, fromPubkey, amount.amount().toNumber()));
+                    }
+                    if (memo) {
+                        transaction.add(new TransactionInstruction({
+                            keys: [{ pubkey: fromPubkey, isSigner: true, isWritable: true }],
+                            data: Buffer.from(memo, 'utf-8'),
+                            programId: new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
+                        }));
+                    }
+                    if (priorityFee) {
+                        transaction.add(ComputeBudgetProgram.setComputeUnitPrice({
+                            microLamports: priorityFee.amount().toNumber() / Math.pow(10, 3),
+                        }));
+                    }
+                    if (limit) {
+                        transaction.add(ComputeBudgetProgram.setComputeUnitLimit({
+                            units: limit,
+                        }));
+                    }
+                    const derivationPath = this.getDerivationPath(walletIndex);
+                    const { signature } = yield this.getApp().signTransaction(derivationPath, transaction.serializeMessage());
+                    if (!signature) {
+                        throw new Error('failed signing tx by ledger');
+                    }
+                    // Attach Ledger signature
+                    transaction.addSignature(new PublicKey(sender), Buffer.from(signature));
+                    // Verify it's valid (optional, sanity check)
+                    if (!transaction.verifySignatures()) {
+                        throw new Error('Signature verification failed');
+                    }
+                    // Serialize the signed transaction
+                    const signedTx = transaction.serialize();
+                    return this.broadcastTx(bs58.encode(signedTx));
+                }
+            }
+            catch (error) {
+                console.log('Transfer error', error);
+            }
+            throw Error('No provider able to transfer.');
+        });
+    }
+}
+
+export { Client, ClientLedger, SOLAsset, SOLChain, SOL_DECIMALS, defaultSolanaParams };

package/lib/index.js

@@ -11,11 +11,13 @@ var xchainCrypto = require('@xchainjs/xchain-crypto');
 var xchainUtil = require('@xchainjs/xchain-util');
 var bs58 = require('bs58');
 var slip10 = require('micro-key-producer/slip10.js');
+var SolanaLedgerApp = require('@ledgerhq/hw-app-solana');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var bs58__default = /*#__PURE__*/_interopDefault(bs58);
 var slip10__default = /*#__PURE__*/_interopDefault(slip10);
+var SolanaLedgerApp__default = /*#__PURE__*/_interopDefault(SolanaLedgerApp);
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -715,13 +717,144 @@ class Client extends xchainClient.BaseXChainClient {
                     return { rawUnsignedTx: bs58__default.default.encode(transaction.serialize({ verifySignatures: false })) };
                 }
             }
-            catch (_b) { }
+            catch (error) {
+                console.log('prepareTx error', error);
+            }
             throw Error('No provider able to prepare transaction');
         });
     }
 }
 
+/**
+ * Custom Tron Ledger client extending the base Tron client
+ */
+class ClientLedger extends Client {
+    constructor(params) {
+        const clientParams = Object.assign(Object.assign({}, defaultSolanaParams), params);
+        super(clientParams);
+        this.transport = params.transport;
+        this.ledgerApp = new SolanaLedgerApp__default.default(this.transport);
+    }
+    getApp() {
+        if (this.ledgerApp)
+            return this.ledgerApp;
+        this.ledgerApp = new SolanaLedgerApp__default.default(this.transport);
+        return this.ledgerApp;
+    }
+    // Get the current address synchronously - not supported for Ledger Client
+    getAddress() {
+        throw Error('Sync method not supported for Ledger');
+    }
+    // get derivation path for ledger
+    getDerivationPath(index = 0) {
+        const derivationPath = this.getFullDerivationPath(index);
+        return derivationPath.replace(/^m\//, '');
+    }
+    // Get the current address asynchronously
+    getAddressAsync() {
+        return __awaiter(this, arguments, void 0, function* (index = 0, verify = false) {
+            const derivationPath = this.getDerivationPath(index);
+            const result = yield this.getApp().getAddress(derivationPath, verify);
+            const publicKey = new web3_js.PublicKey(Buffer.from(result.address));
+            return publicKey.toBase58(); // return base58 solana address format
+        });
+    }
+    /**
+     * Transfers SOL or Solana token using ledger
+     *
+     * @param {TxParams} params The transfer options.
+     * @returns {TxHash} The transaction hash.
+     */
+    transfer(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ walletIndex = 0, recipient, asset, amount, memo, limit, priorityFee, allowOwnerOffCurve, }) {
+            const sender = yield this.getAddressAsync(walletIndex);
+            try {
+                for (const provider of this.providers) {
+                    const transaction = new web3_js.Transaction();
+                    const fromPubkey = new web3_js.PublicKey(sender);
+                    const toPubkey = new web3_js.PublicKey(recipient);
+                    transaction.recentBlockhash = yield provider.solanaProvider
+                        .getLatestBlockhash()
+                        .then((block) => block.blockhash);
+                    transaction.feePayer = new web3_js.PublicKey(sender);
+                    if (!asset || xchainUtil.eqAsset(asset, this.getAssetInfo().asset)) {
+                        // Native transfer
+                        transaction.add(web3_js.SystemProgram.transfer({
+                            fromPubkey,
+                            toPubkey,
+                            lamports: amount.amount().toNumber(),
+                        }));
+                    }
+                    else {
+                        // Token transfer
+                        const mintAddress = new web3_js.PublicKey(xchainUtil.getContractAddressFromAsset(asset));
+                        const fromAssociatedAccount = splToken.getAssociatedTokenAddressSync(mintAddress, fromPubkey);
+                        let fromTokenAccount;
+                        try {
+                            fromTokenAccount = yield splToken.getAccount(provider.solanaProvider, fromAssociatedAccount);
+                        }
+                        catch (error) {
+                            if (error instanceof splToken.TokenAccountNotFoundError || error instanceof splToken.TokenInvalidAccountOwnerError) {
+                                throw Error('Can not find sender Token account');
+                            }
+                            throw error;
+                        }
+                        const toAssociatedAccount = splToken.getAssociatedTokenAddressSync(mintAddress, toPubkey, allowOwnerOffCurve);
+                        let toTokenAccount;
+                        try {
+                            toTokenAccount = yield splToken.getAccount(provider.solanaProvider, toAssociatedAccount);
+                        }
+                        catch (error) {
+                            if (error instanceof splToken.TokenAccountNotFoundError || error instanceof splToken.TokenInvalidAccountOwnerError) {
+                                throw Error('Can not find recipient Token account. Create it first');
+                            }
+                            throw error;
+                        }
+                        transaction.add(splToken.createTransferInstruction(fromTokenAccount.address, toTokenAccount.address, fromPubkey, amount.amount().toNumber()));
+                    }
+                    if (memo) {
+                        transaction.add(new web3_js.TransactionInstruction({
+                            keys: [{ pubkey: fromPubkey, isSigner: true, isWritable: true }],
+                            data: Buffer.from(memo, 'utf-8'),
+                            programId: new web3_js.PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
+                        }));
+                    }
+                    if (priorityFee) {
+                        transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitPrice({
+                            microLamports: priorityFee.amount().toNumber() / Math.pow(10, 3),
+                        }));
+                    }
+                    if (limit) {
+                        transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+                            units: limit,
+                        }));
+                    }
+                    const derivationPath = this.getDerivationPath(walletIndex);
+                    const { signature } = yield this.getApp().signTransaction(derivationPath, transaction.serializeMessage());
+                    if (!signature) {
+                        throw new Error('failed signing tx by ledger');
+                    }
+                    // Attach Ledger signature
+                    transaction.addSignature(new web3_js.PublicKey(sender), Buffer.from(signature));
+                    // Verify it's valid (optional, sanity check)
+                    if (!transaction.verifySignatures()) {
+                        throw new Error('Signature verification failed');
+                    }
+                    // Serialize the signed transaction
+                    const signedTx = transaction.serialize();
+                    return this.broadcastTx(bs58__default.default.encode(signedTx));
+                }
+            }
+            catch (error) {
+                console.log('Transfer error', error);
+            }
+            throw Error('No provider able to transfer.');
+        });
+    }
+}
+
 exports.Client = Client;
+exports.ClientLedger = ClientLedger;
 exports.SOLAsset = SOLAsset;
 exports.SOLChain = SOLChain;
 exports.SOL_DECIMALS = SOL_DECIMALS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-solana",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "Solana client for XChainJS",
   "keywords": [
     "Solana",
@@ -32,6 +32,7 @@
     "lint": "eslint --config ../../eslint.config.mjs \"{src,__tests__}/**/*.ts\" --fix --max-warnings 0"
   },
   "dependencies": {
+    "@ledgerhq/hw-app-solana": "^7.5.5",
     "@metaplex-foundation/mpl-token-metadata": "^3.2.1",
     "@metaplex-foundation/umi": "0.9.2",
     "@metaplex-foundation/umi-bundle-defaults": "0.9.2",