@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/src/families/stacks/bridge/account.ts

@@ -1,304 +1,18 @@
-import BlockstackApp from "@zondax/ledger-stacks";
-import { c32address } from "c32check";
-import { StacksMainnet } from "@stacks/network";
-import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
-import invariant from "invariant";
-import {
-  AmountRequired,
-  FeeNotLoaded,
-  InvalidAddress,
-  InvalidNonce,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  NotEnoughBalance,
-  RecipientRequired,
-} from "@ledgerhq/errors";
-import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
-import { StacksMemoTooLong } from "../errors";
-import {
-  AddressVersion,
-  TransactionVersion,
-  AnchorMode,
-  UnsignedTokenTransferOptions,
-  estimateTransaction,
-  makeUnsignedSTXTokenTransfer,
-} from "@stacks/transactions";
-
-import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
 import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import {
-  Account,
-  AccountBridge,
-  AccountLike,
-  BroadcastFnSignature,
-  SignOperationEvent,
-  SignOperationFnSignature,
-} from "@ledgerhq/types-live";
-
-import { StacksNetwork } from "./utils/api.types";
-import { StacksOperation, Transaction, TransactionStatus } from "../types";
-import { findNextNonce, getAccountShape, getTxToBroadcast } from "./utils/misc";
-import { broadcastTx } from "./utils/api";
-import { getAddress } from "../../filecoin/bridge/utils/utils";
-import { withDevice } from "../../../hw/deviceAccess";
-import { getPath, throwIfError } from "../utils";
-import { getMainAccount } from "../../../account";
-import { encodeOperationId, patchOperationWithHash } from "../../../operation";
-import { validateAddress } from "./utils/addresses";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+import { getTransactionStatus } from "../getTransactionStatus";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { prepareTransaction } from "../prepareTransaction";
+import { Transaction, TransactionStatus } from "../types";
+import { createTransaction } from "../createTransaction";
+import { signOperation } from "../signOperation";
+import { sync } from "../synchronization";
+import { broadcast } from "../broadcast";
 
 const receive = makeAccountBridgeReceive();
 
-const createTransaction = (): Transaction => {
-  return {
-    family: "stacks",
-    recipient: "",
-    amount: new BigNumber(0),
-    network: "mainnet",
-    anchorMode: AnchorMode.Any,
-    useAllAmount: false,
-  };
-};
-
-const sync = makeSync({ getAccountShape });
-
-const broadcast: BroadcastFnSignature = async ({
-  signedOperation: { operation, signature, rawData },
-}) => {
-  invariant(operation as StacksOperation, "StacksOperation expected");
-  const tx = await getTxToBroadcast(operation as StacksOperation, signature, rawData ?? {});
-
-  const hash = await broadcastTx(tx);
-  const result = patchOperationWithHash(operation, hash);
-
-  return result;
-};
-
-const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
-  const errors: TransactionStatus["errors"] = {};
-  const warnings: TransactionStatus["warnings"] = {};
-
-  const { spendableBalance } = a;
-  const { address } = getAddress(a);
-  const { recipient, useAllAmount, fee } = t;
-  const { memo } = t;
-  let { amount } = t;
-
-  if (!recipient) {
-    errors.recipient = new RecipientRequired();
-  } else if (!validateAddress(recipient).isValid) {
-    errors.recipient = new InvalidAddress("", {
-      currencyName: a.currency.name,
-    });
-  } else if (address === recipient) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  } else if (!fee || fee.eq(0)) {
-    errors.gas = new FeeNotLoaded();
-  }
-
-  const estimatedFees = fee || new BigNumber(0);
-
-  const totalSpent = useAllAmount ? spendableBalance : amount.plus(estimatedFees);
-  amount = useAllAmount ? spendableBalance.minus(estimatedFees) : amount;
-
-  if (amount.lte(0)) errors.amount = new AmountRequired();
-  if (totalSpent.gt(spendableBalance)) errors.amount = new NotEnoughBalance();
-  if (memo && memo.length > 34) errors.transaction = new StacksMemoTooLong();
-
-  return {
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  };
-};
-
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount?: Account | null | undefined;
-  transaction?: Transaction | null | undefined;
-}): Promise<BigNumber> => {
-  const a = getMainAccount(account, parentAccount);
-  const { spendableBalance } = a;
-  const mainAccount = getMainAccount(account, parentAccount);
-  const { xpub } = mainAccount;
-  invariant(xpub, "xpub is required");
-
-  const dummyTx = {
-    ...createTransaction(),
-    ...transaction,
-    recipient: getAbandonSeedAddress(a.currency.id),
-    useAllAmount: true,
-  };
-  // Compute fees
-  const { recipient, anchorMode, memo, amount } = dummyTx;
-  const network = StacksNetwork[dummyTx.network] || new StacksMainnet();
-
-  const options: UnsignedTokenTransferOptions = {
-    recipient,
-    anchorMode,
-    memo,
-    network,
-    publicKey: xpub,
-    amount: amount.toFixed(),
-  };
-
-  const tx = await makeUnsignedSTXTokenTransfer(options);
-
-  const [feeEst] = await estimateTransaction(tx.payload);
-
-  const diff = spendableBalance.minus(new BigNumber(feeEst.fee));
-  return diff.gte(0) ? diff : new BigNumber(0);
-};
-
-const prepareTransaction = async (a: Account, t: Transaction): Promise<Transaction> => {
-  const { spendableBalance, pendingOperations } = a;
-  const { recipient, useAllAmount } = t;
-  const { xpub } = a;
-  invariant(xpub, "xpub is required");
-
-  const patch: Partial<Transaction> = {};
-  if (xpub && recipient && validateAddress(recipient).isValid) {
-    const { anchorMode, memo, amount } = t;
-
-    const network = StacksNetwork[t.network] || new StacksMainnet();
-
-    // Check if recipient is valid
-    const options: UnsignedTokenTransferOptions = {
-      recipient,
-      anchorMode,
-      memo,
-      network,
-      publicKey: xpub,
-      amount: amount.toFixed(),
-    };
-
-    const tx = await makeUnsignedSTXTokenTransfer(options);
-
-    const addressVersion =
-      network.version === TransactionVersion.Mainnet
-        ? AddressVersion.MainnetSingleSig
-        : AddressVersion.TestnetSingleSig;
-    const senderAddress = c32address(addressVersion, tx.auth.spendingCondition!.signer);
-
-    const [fee] = await estimateTransaction(tx.payload);
-
-    patch.fee = new BigNumber(fee.fee);
-    patch.nonce = await findNextNonce(senderAddress, pendingOperations);
-
-    if (useAllAmount) patch.amount = spendableBalance.minus(patch.fee);
-  }
-
-  return defaultUpdateTransaction(t, patch);
-};
-
-const signOperation: SignOperationFnSignature<Transaction> = ({
-  account,
-  deviceId,
-  transaction,
-}): Observable<SignOperationEvent> =>
-  withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        async function main() {
-          const { address, derivationPath } = getAddress(account);
-          const { xpub, id: accountId } = account;
-          invariant(xpub, "xpub is required");
-
-          const { recipient, fee, anchorMode, network, memo, amount, nonce } = transaction;
-
-          if (!xpub) {
-            throw new InvalidAddress("", {
-              currencyName: account.currency.name,
-            });
-          }
-
-          if (!fee) {
-            throw new FeeNotLoaded();
-          }
-
-          if (!nonce) {
-            throw new InvalidNonce();
-          }
-
-          const blockstack = new BlockstackApp(transport);
-
-          const options: UnsignedTokenTransferOptions = {
-            amount: amount.toFixed(),
-            recipient,
-            anchorMode,
-            network: StacksNetwork[network],
-            memo,
-            publicKey: xpub,
-            fee: fee.toFixed(),
-            nonce: nonce.toFixed(),
-          };
-
-          const tx = await makeUnsignedSTXTokenTransfer(options);
-
-          const serializedTx = tx.serialize();
-
-          o.next({
-            type: "device-signature-requested",
-          });
-
-          // Sign by device
-          const result = await blockstack.sign(getPath(derivationPath), Buffer.from(serializedTx));
-          throwIfError(result);
-
-          o.next({
-            type: "device-signature-granted",
-          });
-
-          const txHash = "";
-
-          // build signature on the correct format
-          const signature = `${result.signatureVRS.toString("hex")}`;
-
-          const operation: StacksOperation = {
-            id: encodeOperationId(accountId, txHash, "OUT"),
-            hash: txHash,
-            type: "OUT",
-            senders: [address],
-            recipients: [recipient],
-            accountId,
-            value: amount.plus(fee),
-            fee,
-            blockHash: null,
-            blockHeight: null,
-            date: new Date(),
-            transactionSequenceNumber: nonce.toNumber(),
-            extra: {
-              memo,
-            },
-          };
-
-          o.next({
-            type: "signed",
-            signedOperation: {
-              operation,
-              signature,
-              rawData: {
-                xpub,
-                network,
-                anchorMode,
-              },
-            },
-          });
-        }
-
-        main().then(
-          () => o.complete(),
-          e => o.error(e),
-        );
-      }),
-  );
-
-export const accountBridge: AccountBridge<Transaction> = {
+export const accountBridge: AccountBridge<Transaction, Account, TransactionStatus> = {
   createTransaction,
   updateTransaction: defaultUpdateTransaction,
   getTransactionStatus,

package/src/families/stacks/bridge/currency.ts

@@ -1,6 +1,6 @@
-import { makeScanAccounts } from "../../../bridge/jsHelpers";
-import { getAccountShape } from "./utils/misc";
 import { CurrencyBridge } from "@ledgerhq/types-live";
+import { makeScanAccounts } from "../../../bridge/jsHelpers";
+import { getAccountShape } from "../synchronization";
 
 const scanAccounts = makeScanAccounts({ getAccountShape });
 

package/src/families/stacks/bridge/utils/api.ts

@@ -88,15 +88,20 @@ export const fetchEstimatedFees = async (
 };
 
 export const fetchBlockHeight = async (): Promise<NetworkStatusResponse> => {
-  const data = await fetch<NetworkStatusResponse>("/extended/v1/status");
+  const data = await fetch<NetworkStatusResponse>("/extended");
   return data as NetworkStatusResponse; // TODO Validate if the response fits this interface
 };
 
 export const fetchTxs = async (addr: string, offset = 0): Promise<TransactionsResponse> => {
-  const response = await fetch<TransactionsResponse>(
-    `/extended/v1/address/${addr}/transactions_with_transfers?offset=${offset}&limit=50`,
-  );
-  return response; // TODO Validate if the response fits this interface
+  const limit = 50;
+  try {
+    const response = await fetch<TransactionsResponse>(
+      `/extended/v2/addresses/${addr}/transactions?offset=${offset}&limit=${limit}`,
+    );
+    return response; // TODO Validate if the response fits this interface
+  } catch (e) {
+    return { limit, offset, total: 0, results: [] };
+  }
 };
 
 export const fetchFullTxs = async (addr: string): Promise<TransactionResponse[]> => {

package/src/families/stacks/bridge/utils/api.types.ts

@@ -23,39 +23,110 @@ export interface TransactionResponse {
   tx: {
     tx_id: string;
     nonce: number;
-    tx_status: string;
-    tx_type: string;
     fee_rate: string;
     sender_address: string;
     sponsored: boolean;
+    post_condition_mode: string;
+    post_conditions: Array<{
+      type: string;
+      condition_code: string;
+      amount: string;
+      principal: {
+        type_id: string;
+        address: string;
+      };
+    }>;
+    anchor_mode: string;
+    is_unanchored: boolean;
     block_hash: string;
+    parent_block_hash: string;
     block_height: number;
-    tx_index: number;
+    block_time: number;
+    block_time_iso: string;
     burn_block_time: number;
+    burn_block_time_iso: string;
+    parent_burn_block_time: number;
+    parent_burn_block_time_iso: string;
+    canonical: boolean;
+    tx_index: number;
+    tx_status: string;
+    tx_result: {
+      hex: string;
+      repr: string;
+    };
+    microblock_hash: string;
+    microblock_sequence: number;
+    microblock_canonical: boolean;
+    event_count: number;
+    events: Array<any>;
+    execution_cost_read_count: number;
+    execution_cost_read_length: number;
+    execution_cost_runtime: number;
+    execution_cost_write_count: number;
+    execution_cost_write_length: number;
+    tx_type: "token_transfer" | "contract_call";
     token_transfer?: {
       recipient_address: string;
       amount: string;
       memo: string;
     };
+    smart_contract?: {
+      clarity_version: number;
+      contract_id: string;
+      source_code: string;
+    };
     contract_call?: {
       contract_id: string;
       function_name: string;
       function_signature: string;
-      function_args: {
+      function_args: Array<{
         hex: string;
         repr: string;
         name: string;
         type: string;
-      }[];
+      }>;
     };
   };
-  stx_transfers: {
-    amount: string;
-    sender: string;
-    recipient: string;
-  }[];
   stx_sent: string;
   stx_received: string;
+  events: {
+    stx: {
+      transfer: number;
+      mint: number;
+      burn: number;
+    };
+    ft: {
+      transfer: number;
+      mint: number;
+      burn: number;
+    };
+    nft: {
+      transfer: number;
+      mint: number;
+      burn: number;
+    };
+  };
+}
+
+export interface DecodedSendManyFunctionArgsCV {
+  type: string;
+  value: Array<{
+    type: string;
+    value: {
+      memo?: {
+        type: string;
+        value: string;
+      };
+      to: {
+        type: string;
+        value: string;
+      };
+      ustx: {
+        type: string;
+        value: string;
+      };
+    };
+  }>;
 }
 
 export interface MempoolTransaction {

package/src/families/stacks/bridge/utils/misc.ts

@@ -1,27 +1,19 @@
 import { BigNumber } from "bignumber.js";
-import flatMap from "lodash/flatMap";
 import { Account, Operation, OperationType } from "@ledgerhq/types-live";
 import {
   makeUnsignedSTXTokenTransfer,
   UnsignedTokenTransferOptions,
   createMessageSignature,
-  getAddressFromPublicKey,
+  deserializeCV,
+  cvToJSON,
 } from "@stacks/transactions";
 
-import { GetAccountShape } from "../../../../bridge/jsHelpers";
-import { decodeAccountId, encodeAccountId } from "../../../../account";
-import {
-  fetchBalances,
-  fetchBlockHeight,
-  fetchFullMempoolTxs,
-  fetchFullTxs,
-  fetchNonce,
-} from "../../bridge/utils/api";
-import { StacksNetwork, TransactionResponse } from "./api.types";
+import { decodeAccountId } from "../../../../account";
+import { fetchFullMempoolTxs, fetchNonce } from "../../bridge/utils/api";
+import { DecodedSendManyFunctionArgsCV, StacksNetwork, TransactionResponse } from "./api.types";
 import { getCryptoCurrencyById } from "../../../../currencies";
 import { encodeOperationId, encodeSubOperationId } from "../../../../operation";
 import { StacksOperation } from "../../types";
-import invariant from "invariant";
 import { log } from "@ledgerhq/logs";
 
 export const getTxToBroadcast = async (
@@ -61,14 +53,22 @@ export const getTxToBroadcast = async (
 export const getUnit = () => getCryptoCurrencyById("stacks").units[0];
 
 export const getAddress = (
-  a: Account,
+  account: Account,
 ): {
   address: string;
   derivationPath: string;
-} => ({ address: a.freshAddress, derivationPath: a.freshAddressPath });
+} => ({ address: account.freshAddress, derivationPath: account.freshAddressPath });
+
+const getMemo = (memoHex: string): string => {
+  if (memoHex?.substring(0, 2) === "0x") {
+    return Buffer.from(memoHex.substring(2), "hex").toString().replaceAll("\x00", "");
+  }
+
+  return "";
+};
 
 export const mapTxToOps =
-  (accountID: string) =>
+  (accountID: string, address: string) =>
   (tx: TransactionResponse): StacksOperation[] => {
     try {
       const {
@@ -80,16 +80,15 @@ export const mapTxToOps =
         sender_address,
         block_hash: blockHash,
       } = tx.tx;
-      const { stx_received: receivedValue, stx_sent: sentValue, stx_transfers } = tx;
+      const { stx_received: receivedValue, stx_sent: sentValue } = tx;
 
-      const allRecipients = stx_transfers.map(t => t.recipient);
-      const recipients = allRecipients.length === 1 ? [allRecipients[0]] : [];
+      let recipients: string[] = [];
+      if (tx.tx.tx_type === "token_transfer" && tx.tx.token_transfer) {
+        recipients = [tx.tx.token_transfer.recipient_address];
+      }
 
       const memoHex = tx.tx.token_transfer?.memo;
-      let memo: string = "";
-      if (memoHex?.substring(0, 2) === "0x") {
-        memo = Buffer.from(memoHex.substring(2), "hex").toString().replaceAll("\x00", "");
-      }
+      const memo: string = getMemo(memoHex ?? "");
 
       const ops: StacksOperation[] = [];
 
@@ -97,7 +96,7 @@ export const mapTxToOps =
       const feeToUse = new BigNumber(fee_rate || "0");
 
       const isSending = sentValue !== "0" && receivedValue === "0";
-      const isReceiving = receivedValue !== "0" && sentValue === "0";
+      const isReceiving = receivedValue !== "0";
 
       const operationCommons = {
         hash: tx_id,
@@ -115,26 +114,35 @@ export const mapTxToOps =
 
       if (isSending) {
         const type: OperationType = "OUT";
+        let internalOperations: StacksOperation[] | undefined = undefined;
+
+        if (tx.tx.tx_type === "contract_call" && tx.tx.contract_call) {
+          internalOperations = [];
+          const deserialized = deserializeCV(tx.tx.contract_call.function_args[0].hex);
+          const decodedArgs: DecodedSendManyFunctionArgsCV = cvToJSON(deserialized);
+          for (const [idx, t] of decodedArgs.value.entries()) {
+            internalOperations.push({
+              ...operationCommons,
+              id: encodeSubOperationId(accountID, tx_id, type, idx),
+              contract: "send-many",
+              type,
+              value: new BigNumber(t.value.ustx.value),
+              senders: [sender_address],
+              recipients: [t.value.to.value],
+              extra: {
+                memo: getMemo(t.value.memo?.value ?? ""),
+              },
+            });
+          }
+        }
+
         ops.push({
           ...operationCommons,
           id: encodeOperationId(accountID, tx_id, type),
           value: new BigNumber(sentValue),
           recipients,
           type,
-          internalOperations:
-            stx_transfers.length > 1
-              ? stx_transfers.map((t, idx) => {
-                  return {
-                    ...operationCommons,
-                    id: encodeSubOperationId(accountID, tx_id, type, idx),
-                    contract: "send-many",
-                    type,
-                    value: new BigNumber(t.amount),
-                    senders: [t.sender],
-                    recipients: [t.recipient],
-                  };
-                })
-              : undefined,
+          internalOperations,
         });
       }
 
@@ -144,21 +152,8 @@ export const mapTxToOps =
           ...operationCommons,
           id: encodeOperationId(accountID, tx_id, type),
           value: new BigNumber(receivedValue),
-          recipients,
+          recipients: recipients.length ? recipients : [address],
           type,
-          internalOperations:
-            stx_transfers.length > 1
-              ? stx_transfers.map((t, idx) => {
-                  return {
-                    ...operationCommons,
-                    id: encodeSubOperationId(accountID, tx_id, type, idx),
-                    type,
-                    value: new BigNumber(t.amount),
-                    senders: [t.sender],
-                    recipients: [t.recipient],
-                  };
-                })
-              : undefined,
         });
       }
 
@@ -169,50 +164,7 @@ export const mapTxToOps =
     }
   };
 
-export const getAccountShape: GetAccountShape = async info => {
-  const { initialAccount, currency, rest = {}, derivationMode } = info;
-  // for bridge tests specifically the `rest` object is empty and therefore the publicKey is undefined
-  // reconciliatePublicKey tries to get pubKey from rest object and then from accountId
-  const pubKey = reconciliatePublicKey(rest.publicKey, initialAccount);
-  invariant(pubKey, "publicKey is required");
-
-  const accountId: string = encodeAccountId({
-    type: "js",
-    version: "2",
-    currencyId: currency.id,
-    xpubOrAddress: pubKey,
-    derivationMode,
-  });
-
-  const address = getAddressFromPublicKey(pubKey);
-
-  const blockHeight = await fetchBlockHeight();
-  const balanceResp = await fetchBalances(address);
-  const rawTxs = await fetchFullTxs(address);
-  const mempoolTxs = await fetchFullMempoolTxs(address);
-
-  const balance = new BigNumber(balanceResp.balance);
-  let spendableBalance = new BigNumber(balanceResp.balance);
-  for (const tx of mempoolTxs) {
-    spendableBalance = spendableBalance
-      .minus(new BigNumber(tx.fee_rate))
-      .minus(new BigNumber(tx.token_transfer.amount));
-  }
-
-  const result: Partial<Account> = {
-    id: accountId,
-    xpub: pubKey,
-    freshAddress: address,
-    balance,
-    spendableBalance,
-    operations: flatMap(rawTxs, mapTxToOps(accountId)),
-    blockHeight: blockHeight.chain_tip.block_height,
-  };
-
-  return result;
-};
-
-function reconciliatePublicKey(
+export function reconciliatePublicKey(
   publicKey: string | undefined,
   initialAccount: Account | undefined,
 ): string {