@ledgerhq/live-common 34.51.0-nightly.1 → 34.51.0-nightly.10

package/src/bridge/generic-alpaca/accountBridge.ts

@@ -14,6 +14,7 @@ import { genericEstimateMaxSpendable } from "./estimateMaxSpendable";
 import { createTransaction } from "./createTransaction";
 import { genericBroadcast } from "./broadcast";
 import { genericSignOperation } from "./signOperation";
+import { genericSignRawOperation } from "./signRawOperation";
 import type { AlpacaSigner } from "./signer/types";
 
 export function getAlpacaAccountBridge(
@@ -32,6 +33,7 @@ export function getAlpacaAccountBridge(
     estimateMaxSpendable: genericEstimateMaxSpendable(network, kind),
     broadcast: genericBroadcast(network, kind),
     signOperation: genericSignOperation(network, kind)(signer.context),
+    signRawOperation: genericSignRawOperation(network, kind)(signer.context),
     getSerializedAddressParameters, // NOTE: check wether it should be exposed by coin-module's api instead?
   } satisfies Partial<AccountBridge<any>>;
 }

package/src/bridge/generic-alpaca/alpaca/network/network-alpaca.ts

@@ -186,6 +186,14 @@ export const getNetworkAlpacaApi = (networkFamily: string) =>
     listOperations: buildListOperations(networkFamily),
     lastBlock: buildLastBlock(networkFamily),
     craftTransaction: buildCraftTransaction(networkFamily),
+    craftRawTransaction: (
+      _transaction: string,
+      _sender: string,
+      _publicKey: string,
+      _sequence: number,
+    ): Promise<CraftedTransaction> => {
+      throw new Error("craftRawTransaction is not supported");
+    },
     getBlock(_height): Promise<Block> {
       throw new Error("getBlock is not supported");
     },

package/src/bridge/generic-alpaca/getTransactionStatus.ts

@@ -36,14 +36,16 @@ export function genericGetTransactionStatus(
       }
     }
 
-    const { errors, warnings, estimatedFees, amount, totalSpent } = await alpacaApi.validateIntent(
-      transactionToIntent(account, draftTransaction, alpacaApi.computeIntentType),
-      { value: transaction.fees ? BigInt(transaction.fees.toString()) : 0n },
-    );
+    const { errors, warnings, estimatedFees, amount, totalSpent, totalFees } =
+      await alpacaApi.validateIntent(
+        transactionToIntent(account, draftTransaction, alpacaApi.computeIntentType),
+        { value: transaction.fees ? BigInt(transaction.fees.toString()) : 0n },
+      );
 
     return {
       errors,
       warnings,
+      totalFees: typeof totalFees === "bigint" ? new BigNumber(totalFees.toString()) : undefined,
       estimatedFees:
         !transaction.fees || transaction.fees.isZero()
           ? new BigNumber(estimatedFees.toString())

package/src/bridge/generic-alpaca/signRawOperation.ts

@@ -0,0 +1,86 @@
+import { Observable } from "rxjs";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account, DeviceId, SignOperationEvent, AccountBridge } from "@ledgerhq/types-live";
+import { getAlpacaApi } from "./alpaca";
+import { buildOptimisticOperation } from "./utils";
+import { Result } from "@ledgerhq/coin-framework/derivation";
+import { log } from "@ledgerhq/logs";
+import BigNumber from "bignumber.js";
+import { GenericTransaction } from "./types";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const genericSignRawOperation =
+  (network, kind) =>
+  (signerContext: SignerContext<any>): AccountBridge<GenericTransaction>["signRawOperation"] =>
+  ({
+    account,
+    transaction,
+    deviceId,
+  }: {
+    account: Account;
+    transaction: string;
+    deviceId: DeviceId;
+  }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      async function main() {
+        const alpacaApi = getAlpacaApi(account.currency.id, kind);
+        const signedInfo = await signerContext(deviceId, async signer => {
+          const derivationPath = account.freshAddressPath;
+          const { publicKey } = (await signer.getAddress(derivationPath)) as Result;
+
+          const sender = account.freshAddress;
+
+          // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
+          const sequenceNumber = await alpacaApi.getSequence(sender);
+
+          /* Craft unsigned blob via Alpaca */
+          const { transaction: unsigned } = await alpacaApi.craftRawTransaction(
+            transaction,
+            sender,
+            publicKey,
+            sequenceNumber,
+          );
+
+          /* Notify UI that the device is now showing the tx */
+          o.next({ type: "device-signature-requested" });
+          /* Sign on Ledger device */
+          const txnSig = await signer.signTransaction(derivationPath, unsigned);
+          return { unsigned, txnSig, publicKey, sequence: sequenceNumber };
+        });
+
+        /* If the user cancelled inside signerContext */
+        if (!signedInfo) return;
+        o.next({ type: "device-signature-granted" });
+
+        /* Combine payload + signature for broadcast */
+        const combined = await alpacaApi.combine(
+          signedInfo.unsigned,
+          signedInfo.txnSig,
+          signedInfo.publicKey,
+        );
+        const operation = buildOptimisticOperation(
+          account,
+          { family: account.currency.family, amount: new BigNumber(0), recipient: "" },
+          signedInfo.sequence,
+        );
+        if (!operation.id) {
+          log("Generic alpaca", "buildOptimisticOperation", operation);
+        }
+        // NOTE: we set the transactionSequenceNumber before on the operation
+        // now that we create it in craftTransaction, we might need to return it back from craftTransaction also
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: combined,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/bridge/generic-alpaca/tests/getAccountShape.test.ts

@@ -48,6 +48,7 @@ jest.mock("../buildSubAccounts", () => ({
 const chains = [
   { currency: { id: "stellar", name: "Stellar" }, network: "testnet" },
   { currency: { id: "ripple", name: "XRP" }, network: "mainnet" },
+  { currency: { id: "tezos", name: "Tezos" }, network: "mainnet" },
 ];
 
 describe("genericGetAccountShape (stellar & xrp)", () => {

package/src/bridge/generic-alpaca/utils.ts

@@ -134,14 +134,14 @@ export function transactionToIntent(
   const res: TransactionIntent & { memo?: { type: string; value?: string } } & {
     data?: { type: string; value?: unknown };
   } = {
+    intentType: isStaking ? "staking" : "transaction",
     type: intentType,
     sender: account.freshAddress,
     recipient: transaction.recipient,
     amount,
     asset: { type: "native", name: account.currency.name, unit: account.currency.units[0] },
     useAllAmount,
-    feesStrategy:
-      transaction.feesStrategy === "custom" ? undefined : transaction.feesStrategy ?? undefined,
+    feesStrategy: transaction.feesStrategy ?? undefined,
     data: Buffer.isBuffer(transaction.data)
       ? { type: "buffer", value: transaction.data }
       : { type: "none" },

package/src/bridge/mockHelpers.ts

@@ -183,3 +183,60 @@ export const makeAccountBridgeReceive: () => (
     path: account.freshAddressPath,
     publicKey: "mockPublickKey", // We could probably keep the publicKey in `account.freshPublicKey`
   });
+
+export const signRawOperation: AccountBridge<any>["signRawOperation"] = ({ account }) =>
+  new Observable(o => {
+    let cancelled = false;
+
+    async function main() {
+      await delay(1000);
+      if (cancelled) return;
+
+      for (let i = 0; i <= 1; i += 0.1) {
+        o.next({
+          type: "device-streaming",
+          progress: i,
+          index: i,
+          total: 10,
+        });
+        await delay(300);
+      }
+
+      o.next({
+        type: "device-signature-requested",
+      });
+      await delay(2000);
+      if (cancelled) return;
+      o.next({
+        type: "device-signature-granted",
+      });
+      const rng = new Prando("");
+      const op = genOperation(account, account, account.operations, rng);
+      op.type = "OUT";
+      op.value = new BigNumber(0);
+      op.blockHash = null;
+      op.blockHeight = null;
+      op.senders = [account.freshAddress];
+      op.recipients = [];
+      op.blockHeight = account.blockHeight;
+      op.date = new Date();
+      await delay(1000);
+      if (cancelled) return;
+      broadcasted[account.id] = (broadcasted[account.id] || []).concat(op);
+      o.next({
+        type: "signed",
+        signedOperation: {
+          operation: { ...op },
+          signature: "",
+        },
+      });
+    }
+
+    main().then(
+      () => o.complete(),
+      e => o.error(e),
+    );
+    return () => {
+      cancelled = true;
+    };
+  });