@ledgerhq/coin-solana 0.29.0 → 0.29.1-nightly.0

package/src/prepareTransaction.ts

@@ -79,15 +79,7 @@ import { estimateFeeAndSpendable, estimateTokenMaxSpendable } from "./estimateMa
 import { MemoTransferExt, TransferFeeConfigExt } from "./network/chain/account/tokenExtensions";
 import { calculateToken2022TransferFees } from "./helpers/token";
 import { TokenAccountInfo } from "./network/chain/account/token";
-import {
-  DecodedTransferInstruction,
-  MessageCompiledInstruction,
-  PublicKey,
-  SystemInstruction,
-  SystemProgram,
-  VersionedMessage,
-  VersionedTransaction,
-} from "@solana/web3.js";
+import { deriveRawCommandDescriptor, toLiveTransaction } from "./rawTransaction";
 import BigNumber from "bignumber.js";
 import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
 
@@ -118,102 +110,13 @@ async function deriveCommandDescriptor(
       return deriveStakeWithdrawCommandDescriptor(mainAccount, tx, model, api);
     case "stake.split":
       return deriveStakeSplitCommandDescriptor(mainAccount, tx, model, api);
+    case "raw":
+      return deriveRawCommandDescriptor(tx, api);
     default:
       return assertUnreachable(model);
   }
 }
 
-function fromBigIntToBigNumber(bigInt: bigint): BigNumber {
-  return BigNumber(bigInt.toString());
-}
-
-function toSolanaTransaction(serializedTransaction: string): VersionedTransaction {
-  return VersionedTransaction.deserialize(Buffer.from(serializedTransaction, "base64"));
-}
-
-function findInstruction(
-  compiledInstructions: MessageCompiledInstruction[],
-  staticAccountKeys: PublicKey[],
-): MessageCompiledInstruction | undefined {
-  return compiledInstructions.find(instruction => {
-    return (
-      staticAccountKeys[instruction.programIdIndex].toString() ===
-      SystemProgram.programId.toString()
-    );
-  });
-}
-
-function decodeInstruction(
-  message: VersionedMessage,
-  instruction: MessageCompiledInstruction,
-): DecodedTransferInstruction {
-  return SystemInstruction.decodeTransfer({
-    data: Buffer.from(instruction.data),
-    programId: SystemProgram.programId,
-    keys: instruction.accountKeyIndexes.map(index => {
-      return {
-        pubkey: message.staticAccountKeys[index],
-        isSigner: message.isAccountSigner(index),
-        isWritable: message.isAccountWritable(index),
-      };
-    }),
-  });
-}
-
-function buildTransferTransaction(
-  raw: string,
-  lamports: bigint,
-  fromPubkey: PublicKey,
-  toPubkey: PublicKey,
-  estimatedFees: number | null,
-): Transaction {
-  return {
-    raw,
-    family: "solana",
-    amount: fromBigIntToBigNumber(lamports),
-    recipient: String(toPubkey),
-    model: {
-      kind: "transfer",
-      uiState: {},
-      commandDescriptor: {
-        command: {
-          kind: "transfer",
-          amount: fromBigIntToBigNumber(lamports).toNumber(),
-          sender: String(fromPubkey),
-          recipient: String(toPubkey),
-        },
-        fee: estimatedFees ?? 0,
-        warnings: {},
-        errors: {},
-      },
-    },
-  };
-}
-
-async function toLiveTransaction(
-  api: ChainAPI,
-  serializedTransaction: string,
-): Promise<Transaction> {
-  const solanaTransaction = toSolanaTransaction(serializedTransaction);
-  const message = solanaTransaction.message;
-  const instruction = findInstruction(message.compiledInstructions, message.staticAccountKeys);
-
-  if (!instruction) {
-    throw new Error("No supported instructions found on Solana transaction");
-  }
-
-  const decodedInstruction = decodeInstruction(message, instruction);
-  const estimatedFees = await api.getFeeForMessage(message);
-
-  return buildTransferTransaction(
-    serializedTransaction,
-    decodedInstruction.lamports,
-    decodedInstruction.fromPubkey,
-    decodedInstruction.toPubkey,
-    estimatedFees,
-  );
-}
-
 const prepareTransaction = async (
   mainAccount: SolanaAccount,
   tx: Transaction,

package/src/rawTransaction.ts

@@ -0,0 +1,59 @@
+import { ChainAPI } from "./network";
+import { Transaction } from "./types";
+import { VersionedTransaction } from "@solana/web3.js";
+import BigNumber from "bignumber.js";
+
+function buildRawTransaction(raw: string, estimatedFees: number | null): Transaction {
+  return {
+    raw,
+    family: "solana",
+    amount: BigNumber(0),
+    recipient: "",
+    model: {
+      kind: "raw",
+      uiState: {},
+      commandDescriptor: {
+        command: {
+          kind: "raw",
+          raw,
+        },
+        fee: estimatedFees ?? 0,
+        warnings: {},
+        errors: {},
+      },
+    },
+  };
+}
+
+export async function toLiveTransaction(
+  api: ChainAPI,
+  serializedTransaction: string,
+): Promise<Transaction> {
+  const solanaTransaction = VersionedTransaction.deserialize(
+    Buffer.from(serializedTransaction, "base64"),
+  );
+
+  const estimatedFees = await api.getFeeForMessage(solanaTransaction.message);
+
+  return buildRawTransaction(serializedTransaction, estimatedFees);
+}
+
+export async function deriveRawCommandDescriptor(tx: Transaction, api: ChainAPI) {
+  if (!tx.raw) {
+    throw new Error("Raw transaction is required to derive command descriptor");
+  }
+
+  const liveTx = await toLiveTransaction(api, tx.raw);
+
+  return (
+    liveTx.model.commandDescriptor || {
+      command: {
+        kind: "raw",
+        raw: tx.raw,
+      },
+      fee: tx.model.commandDescriptor?.fee ?? 0,
+      warnings: {},
+      errors: {},
+    }
+  );
+}

package/src/signOperation.ts

@@ -3,6 +3,7 @@ import type { Account, AccountBridge, OperationType } from "@ledgerhq/types-live
 import type {
   Command,
   CommandDescriptor,
+  RawCommand,
   SolanaOperation,
   SolanaOperationExtra,
   StakeCreateAccountCommand,
@@ -168,10 +169,32 @@ function buildOptimisticOperationForCommand(
       return optimisticOpForStakeWithdraw(account, command, commandDescriptor);
     case "stake.split":
       return optimisticOpForStakeSplit(account, command, commandDescriptor);
+    case "raw":
+      return optimisticOpForRaw(account, transaction, command, commandDescriptor);
     default:
       return assertUnreachable(command);
   }
 }
+
+function optimisticOpForRaw(
+  account: Account,
+  transaction: Transaction,
+  command: RawCommand,
+  commandDescriptor: CommandDescriptor,
+): SolanaOperation {
+  const commons = optimisticOpcommons(commandDescriptor);
+  return {
+    ...commons,
+    id: encodeOperationId(account.id, "", "OUT"),
+    type: "OUT",
+    accountId: account.id,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient],
+    value: new BigNumber(commons.fee ?? 0),
+    extra: getOpExtras(command),
+  };
+}
+
 function optimisticOpForTransfer(
   account: Account,
   transaction: Transaction,
@@ -307,6 +330,7 @@ function getOpExtras(command: Command): SolanaOperationExtra {
     case "stake.undelegate":
     case "stake.withdraw":
     case "stake.split":
+    case "raw":
       break;
     default:
       return assertUnreachable(command);

package/src/specs.ts

@@ -730,6 +730,7 @@ function expectCorrectMemo(input: TransactionTestInput<Transaction>) {
     case "stake.undelegate":
     case "stake.withdraw":
     case "stake.split":
+    case "raw":
       break;
     default:
       return assertUnreachable(transaction.model);

package/src/transaction.ts

@@ -88,6 +88,8 @@ function formatCommand(mainAccount: Account, tx: Transaction, command: Command)
       return formatStakeWithdraw(mainAccount, tx, command);
     case "stake.split":
       return formatStakeSplit(mainAccount, tx, command);
+    case "raw":
+      return formatRaw(tx);
     default:
       return assertUnreachable(command);
   }
@@ -105,9 +107,7 @@ function formatStakeCreateAccount(
     `  AMOUNT: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
     `  SEED: ${command.seed}`,
     `  VALIDATOR: ${command.delegate.voteAccAddress}`,
-  ]
-    .filter(Boolean)
-    .join("\n");
+  ].join("\n");
 
   return "\n" + str;
 }
@@ -157,7 +157,7 @@ function formatCreateATA(mainAccount: Account, command: TokenCreateATACommand) {
   if (!token) {
     throw new Error(`token for mint "${command.mint}" not found`);
   }
-  const str = [`  OPT IN TOKEN: ${token.ticker}`].filter(Boolean).join("\n");
+  const str = [`  OPT IN TOKEN: ${token.ticker}`].join("\n");
   return "\n" + str;
 }
 
@@ -186,9 +186,7 @@ function formatCreateApprove(
     `  APPROVE: ${command.account}`,
     `  DELEGATE: ${command.recipientDescriptor.walletAddress}`,
     `  AMOUNT: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
-  ]
-    .filter(Boolean)
-    .join("\n");
+  ].join("\n");
   return "\n" + str;
 }
 
@@ -205,21 +203,17 @@ function formatCreateRevoke(
     throw new Error("token subaccount expected");
   }
 
-  const str = [`  OWNER: ${command.owner}`, `  REVOKE: ${command.account}`]
-    .filter(Boolean)
-    .join("\n");
+  const str = [`  OWNER: ${command.owner}`, `  REVOKE: ${command.account}`].join("\n");
   return "\n" + str;
 }
 
 function formatStakeDelegate(command: StakeDelegateCommand) {
-  const str = [`  DELEGATE: ${command.stakeAccAddr}`, `  TO: ${command.voteAccAddr}`]
-    .filter(Boolean)
-    .join("\n");
+  const str = [`  DELEGATE: ${command.stakeAccAddr}`, `  TO: ${command.voteAccAddr}`].join("\n");
   return "\n" + str;
 }
 
 function formatStakeUndelegate(command: StakeUndelegateCommand) {
-  const str = [`  UNDELEGATE: ${command.stakeAccAddr}`].filter(Boolean).join("\n");
+  const str = [`  UNDELEGATE: ${command.stakeAccAddr}`].join("\n");
   return "\n" + str;
 }
 
@@ -229,9 +223,7 @@ function formatStakeWithdraw(mainAccount: Account, tx: Transaction, command: Sta
     `  WITHDRAW FROM: ${command.stakeAccAddr}`,
     `  AMOUNT: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
     `  TO: ${command.toAccAddr}`,
-  ]
-    .filter(Boolean)
-    .join("\n");
+  ].join("\n");
   return "\n" + str;
 }
 
@@ -241,9 +233,14 @@ function formatStakeSplit(mainAccount: Account, tx: Transaction, command: StakeS
     `  SPLIT: ${command.stakeAccAddr}`,
     `  AMOUNT: ${amount}${tx.useAllAmount ? " (ALL)" : ""}`,
     `  TO: ${command.splitStakeAccAddr}`,
-  ]
-    .filter(Boolean)
-    .join("\n");
+  ].join("\n");
+  return "\n" + str;
+}
+
+function formatRaw(tx: Transaction) {
+  const str = [`  SEND RAW: ${tx.useAllAmount ? " (ALL)" : ""}`, `  TO: ${tx.recipient}`].join(
+    "\n",
+  );
   return "\n" + str;
 }
 

package/src/tx-fees.ts

@@ -58,6 +58,7 @@ const createDummyTx = (address: string, kind: TransactionModel["kind"]) => {
       return createDummyTokenRevokeTx(address);
     case "stake.split":
     case "token.createATA":
+    case "raw":
       throw new Error(`not implemented for <${kind}>`);
     default:
       return assertUnreachable(kind);

package/src/types.ts

@@ -121,6 +121,11 @@ export type TokenTransferCommand = {
   };
 };
 
+export type RawCommand = {
+  kind: "raw";
+  raw: string;
+};
+
 export type Command =
   | TransferCommand
   | TokenTransferCommand
@@ -131,7 +136,8 @@ export type Command =
   | StakeDelegateCommand
   | StakeUndelegateCommand
   | StakeWithdrawCommand
-  | StakeSplitCommand;
+  | StakeSplitCommand
+  | RawCommand;
 
 export type CommandDescriptor = {
   command: Command;
@@ -214,6 +220,11 @@ export type StakeSplitTransaction = {
   };
 };
 
+export type RawTransaction = {
+  kind: "raw";
+  uiState: object;
+};
+
 export type TransactionModel = { commandDescriptor?: CommandDescriptor } & (
   | TransferTransaction
   | TokenTransferTransaction
@@ -225,6 +236,7 @@ export type TransactionModel = { commandDescriptor?: CommandDescriptor } & (
   | StakeUndelegateTransaction
   | StakeWithdrawTransaction
   | StakeSplitTransaction
+  | RawTransaction
 );
 
 export type Transaction = TransactionCommon & {