Sign ledger transaction (#229)

Author: dgca

main/api/ironfish/Ironfish.ts

@@ -19,7 +19,7 @@ import { logger } from "./logger";
 import packageJson from "../../../package.json";
 import { userSettingsStore } from "../../stores/userSettingsStore";
 import { SnapshotManager } from "../snapshot/snapshotManager";
-import { SplitPromise, splitPromise } from "../utils";
+import { SplitPromise, splitPromise } from "../utils/splitPromise";
 
 export class Ironfish {
   public snapshotManager: SnapshotManager = new SnapshotManager();

main/api/ledger/index.ts

@@ -1,6 +1,7 @@
 import { observable } from "@trpc/server/observable";
 
 import { ledgerManager, ConnectionStatus } from "./utils/ledger";
+import { handleSendTransactionInput } from "../transactions/handleSendTransaction";
 import { t } from "../trpc";
 
 export const ledgerRouter = t.router({
@@ -19,4 +20,9 @@ export const ledgerRouter = t.router({
     const result = await ledgerManager.importAccount();
     return result;
   }),
+  submitLedgerTransaction: t.procedure
+    .input(handleSendTransactionInput)
+    .mutation(async (opts) => {
+      return ledgerManager.submitTransaction(opts.input);
+    }),
 });

main/api/ledger/utils/ledger.ts

@@ -9,11 +9,14 @@ import IronfishApp, {
   ResponseViewKey,
   ResponseProofGenKey,
 } from "@zondax/ledger-ironfish";
+import { z } from "zod";
 
 import { ledgerStore } from "../../../stores/ledgerStore";
-import { PromiseQueue } from "../../../utils/promiseQueue";
 import { handleImportAccount } from "../../accounts/handleImportAccount";
 import { logger } from "../../ironfish/logger";
+import { handleSendTransactionInput } from "../../transactions/handleSendTransaction";
+import { PromiseQueue } from "../../utils/promiseQueue";
+import { createUnsignedTransaction } from "../../utils/transactions";
 
 export const DERIVATION_PATH = "m/44'/1338'/0";
 const IRONFISH_APP_NAME = "Ironfish";
@@ -354,6 +357,76 @@ class LedgerManager {
 
     return returnValue;
   };
+
+  submitTransaction = async ({
+    fromAccount,
+    toAccount,
+    assetId,
+    amount,
+    fee,
+    memo,
+  }: z.infer<typeof handleSendTransactionInput>) => {
+    const returnValue = await this.taskQueue.enqueue(async () => {
+      try {
+        const unsignedTransaction = await createUnsignedTransaction({
+          fromAccount,
+          toAccount,
+          assetId,
+          amount,
+          fee,
+          memo,
+        });
+        const unsignedTransactionBuffer = Buffer.from(
+          unsignedTransaction,
+          "hex",
+        );
+
+        if (unsignedTransactionBuffer.length > 16 * 1024) {
+          throw new Error(
+            "Transaction size is too large, must be less than 16kb.",
+          );
+        }
+
+        const connectResponse = await this.connect();
+
+        if (connectResponse.status !== "SUCCESS") {
+          throw new Error(connectResponse.error.message);
+        }
+
+        const transport = connectResponse.data;
+        const ironfishAppReponse = await this.getIronfishApp(transport);
+
+        if (ironfishAppReponse.status !== "SUCCESS") {
+          throw new Error(ironfishAppReponse.error.message);
+        }
+
+        const signResponse = await ironfishAppReponse.data.sign(
+          DERIVATION_PATH,
+          unsignedTransactionBuffer,
+        );
+
+        if (!signResponse.signature) {
+          throw new Error(signResponse.errorMessage || "No signature returned");
+        }
+
+        const splitSignParams = {
+          unsignedTransaction: unsignedTransactionBuffer,
+          signature: signResponse.signature.toString("hex"),
+        };
+
+        // @todo: Sign and submit the transaction once addSignature is available from the RPC client
+        return splitSignParams;
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to import account";
+        logger.error(message);
+        await this.disconnect();
+        throw new Error(message);
+      }
+    });
+
+    return returnValue;
+  };
 }
 
 export const ledgerManager = new LedgerManager();

main/api/snapshot/snapshotManager.ts

@@ -9,7 +9,7 @@ import {
   getDefaultManifestUrl,
 } from "./utils";
 import { SnapshotUpdate } from "../../../shared/types";
-import { SplitPromise, splitPromise } from "../utils";
+import { SplitPromise, splitPromise } from "../utils/splitPromise";
 
 export class SnapshotManager {
   onProgress: Event<[SnapshotUpdate]> = new Event();

main/api/transactions/handleSendTransaction.ts

@@ -1,11 +1,8 @@
-import {
-  CreateTransactionRequest,
-  CurrencyUtils,
-  RawTransactionSerde,
-} from "@ironfish/sdk";
+import { RawTransactionSerde } from "@ironfish/sdk";
 import { z } from "zod";
 
 import { manager } from "../manager";
+import { createRawTransaction } from "../utils/transactions";
 
 export const handleSendTransactionInput = z.object({
   fromAccount: z.string(),
@@ -27,25 +24,14 @@ export async function handleSendTransaction({
   const ironfish = await manager.getIronfish();
   const rpcClient = await ironfish.rpcClient();
 
-  const params: CreateTransactionRequest = {
-    account: fromAccount,
-    outputs: [
-      {
-        publicAddress: toAccount,
-        amount: CurrencyUtils.encode(BigInt(amount)),
-        memo: memo ?? "",
-        assetId: assetId,
-      },
-    ],
-    fee: CurrencyUtils.encode(BigInt(fee)),
-    feeRate: null,
-    expiration: undefined,
-    confirmations: undefined,
-  };
-
-  const createResponse = await rpcClient.wallet.createTransaction(params);
-  const bytes = Buffer.from(createResponse.content.transaction, "hex");
-  const rawTx = RawTransactionSerde.deserialize(bytes);
+  const rawTx = await createRawTransaction({
+    fromAccount,
+    toAccount,
+    assetId,
+    amount,
+    fee,
+    memo,
+  });
 
   const postResponse = await rpcClient.wallet.postTransaction({
     transaction: RawTransactionSerde.serialize(rawTx).toString("hex"),

main/utils/promiseQueue.ts renamed to main/api/utils/promiseQueue.ts

@@ -5,6 +5,7 @@ export type SplitPromise<T> = {
   resolve: PromiseResolve<T>;
   reject: PromiseReject;
 };
+
 export function splitPromise<T>(): SplitPromise<T> {
   const [promise, resolve, reject] = PromiseUtils.split<T>();
   return { promise, resolve, reject };

main/api/utils/index.ts renamed to main/api/utils/splitPromise.ts

@@ -0,0 +1,79 @@
+import {
+  CreateTransactionRequest,
+  CurrencyUtils,
+  RawTransactionSerde,
+} from "@ironfish/sdk";
+import { z } from "zod";
+
+import { manager } from "../manager";
+
+export const createTransactionInput = z.object({
+  fromAccount: z.string(),
+  toAccount: z.string(),
+  assetId: z.string(),
+  amount: z.string(),
+  fee: z.number(),
+  memo: z.string().optional(),
+});
+
+export type CreateTransactionInput = z.infer<typeof createTransactionInput>;
+
+export async function createUnsignedTransaction({
+  fromAccount,
+  toAccount,
+  assetId,
+  amount,
+  fee,
+  memo,
+}: CreateTransactionInput) {
+  const ironfish = await manager.getIronfish();
+  const rpcClient = await ironfish.rpcClient();
+
+  const rawTx = await createRawTransaction({
+    fromAccount,
+    toAccount,
+    assetId,
+    amount,
+    fee,
+    memo,
+  });
+
+  const serializedRawTx = RawTransactionSerde.serialize(rawTx);
+  const builtTransactionResponse = await rpcClient.wallet.buildTransaction({
+    rawTransaction: serializedRawTx.toString("hex"),
+    account: fromAccount,
+  });
+  return builtTransactionResponse.content.unsignedTransaction;
+}
+
+export async function createRawTransaction({
+  fromAccount,
+  toAccount,
+  assetId,
+  amount,
+  fee,
+  memo,
+}: CreateTransactionInput) {
+  const ironfish = await manager.getIronfish();
+  const rpcClient = await ironfish.rpcClient();
+
+  const params: CreateTransactionRequest = {
+    account: fromAccount,
+    outputs: [
+      {
+        publicAddress: toAccount,
+        amount: CurrencyUtils.encode(BigInt(amount)),
+        memo: memo ?? "",
+        assetId: assetId,
+      },
+    ],
+    fee: CurrencyUtils.encode(BigInt(fee)),
+    feeRate: null,
+    expiration: undefined,
+    confirmations: undefined,
+  };
+
+  const createResponse = await rpcClient.wallet.createTransaction(params);
+  const bytes = Buffer.from(createResponse.content.transaction, "hex");
+  return RawTransactionSerde.deserialize(bytes);
+}