@ledgerhq/live-common 31.2.0 → 31.3.0-next.0

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

@@ -0,0 +1,305 @@
+import BlockstackApp from "@zondax/ledger-stacks";
+import { c32address } from "c32check";
+import { StacksMainnet } from "@stacks/network";
+import { BigNumber } from "bignumber.js";
+import BN from "bn.js";
+import { Observable } from "rxjs";
+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,
+  estimateTransfer,
+  makeUnsignedSTXTokenTransfer,
+} from "@stacks/transactions";
+
+import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import {
+  Account,
+  AccountBridge,
+  AccountLike,
+  BroadcastFnSignature,
+  Operation,
+  SignOperationEvent,
+  SignOperationFnSignature,
+} from "@ledgerhq/types-live";
+
+import { StacksNetwork } from "./utils/api.types";
+import { 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 { decodeAccountId, getMainAccount } from "../../../account";
+import { encodeOperationId, patchOperationWithHash } from "../../../operation";
+import { validateAddress } from "./utils/addresses";
+
+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, signatureRaw },
+}) => {
+  const tx = await getTxToBroadcast(operation, signature, signatureRaw ?? {});
+
+  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();
+  } 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 { id: accountId, spendableBalance } = a;
+  const { xpubOrAddress: xpub } = decodeAccountId(accountId);
+
+  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: new BN(amount.toFixed()),
+  };
+
+  const tx = await makeUnsignedSTXTokenTransfer(options);
+
+  const fee = await estimateTransfer(tx);
+
+  const diff = spendableBalance.minus(new BigNumber(fee.toString()));
+  return diff.gte(0) ? diff : new BigNumber(0);
+};
+
+const prepareTransaction = async (a: Account, t: Transaction): Promise<Transaction> => {
+  const { id: accountID, spendableBalance, pendingOperations } = a;
+  const { recipient, useAllAmount } = t;
+  const { xpubOrAddress: xpub } = decodeAccountId(accountID);
+
+  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: new BN(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 estimateTransfer(tx);
+
+    patch.fee = new BigNumber(fee.toString());
+    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 { id: accountId } = account;
+          const { address, derivationPath } = getAddress(account);
+          const { xpubOrAddress: xpub } = decodeAccountId(accountId);
+
+          const { recipient, fee, anchorMode, network, memo, amount, nonce } = transaction;
+
+          if (!xpub) {
+            throw new InvalidAddress();
+          }
+
+          if (!fee) {
+            throw new FeeNotLoaded();
+          }
+
+          if (!nonce) {
+            throw new InvalidNonce();
+          }
+
+          const blockstack = new BlockstackApp(transport);
+
+          const options: UnsignedTokenTransferOptions = {
+            amount: new BN(amount.toFixed()),
+            recipient,
+            anchorMode,
+            network: StacksNetwork[network],
+            memo,
+            publicKey: xpub,
+            fee: new BN(fee.toFixed()),
+            nonce: new BN(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), 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: Operation = {
+            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,
+              signatureRaw: {
+                xpub,
+                network,
+                anchorMode,
+              },
+              expirationDate: null,
+            },
+          });
+        }
+
+        main().then(
+          () => o.complete(),
+          e => o.error(e),
+        );
+      }),
+  );
+
+export const accountBridge: AccountBridge<Transaction> = {
+  createTransaction,
+  updateTransaction: defaultUpdateTransaction,
+  getTransactionStatus,
+  prepareTransaction,
+  estimateMaxSpendable,
+  signOperation,
+  sync,
+  receive,
+  broadcast,
+};

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

@@ -0,0 +1,11 @@
+import { makeScanAccounts } from "../../../bridge/jsHelpers";
+import { getAccountShape } from "./utils/misc";
+import { CurrencyBridge } from "@ledgerhq/types-live";
+
+const scanAccounts = makeScanAccounts({ getAccountShape });
+
+export const currencyBridge: CurrencyBridge = {
+  preload: () => Promise.resolve({}),
+  hydrate: () => {},
+  scanAccounts,
+};

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

@@ -0,0 +1,7 @@
+import { currencyBridge } from "./currency";
+import { accountBridge } from "./account";
+
+export default {
+  currencyBridge,
+  accountBridge,
+};

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

@@ -0,0 +1,23 @@
+import { c32addressDecode } from "c32check";
+
+type ValidateAddressResult =
+  | {
+      isValid: true;
+      data: {
+        version: number;
+        data: string;
+      };
+    }
+  | {
+      isValid: false;
+      error: any;
+    };
+
+export const validateAddress = (input: string): ValidateAddressResult => {
+  try {
+    const [version, data] = c32addressDecode(input);
+    return { isValid: true, data: { version, data } };
+  } catch (e) {
+    return { isValid: false, error: e };
+  }
+};

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

@@ -0,0 +1,153 @@
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+
+import {
+  BalanceResponse,
+  BroadcastTransactionRequest,
+  BroadcastTransactionResponse,
+  EstimatedFeesRequest,
+  EstimatedFeesResponse,
+  GetNonceResponse,
+  MempoolResponse,
+  MempoolTransaction,
+  NetworkStatusResponse,
+  TransactionResponse,
+  TransactionsResponse,
+} from "./api.types";
+import network from "@ledgerhq/live-network/network";
+import { getEnv } from "../../../../env";
+
+const getStacksURL = (path?: string): string => {
+  const baseUrl = getEnv("API_STACKS_ENDPOINT");
+  if (!baseUrl) throw new Error("API base URL not available");
+
+  return `${baseUrl}${path ? path : ""}`;
+};
+
+const fetch = async <T>(path: string) => {
+  const url = getStacksURL(path);
+
+  // We force data to this way as network func is not using the correct param type. Changing that func will generate errors in other implementations
+  const opts: AxiosRequestConfig = {
+    method: "GET",
+    url,
+  };
+  const rawResponse = await network(opts);
+
+  // We force data to this way as network func is not using the correct param type. Changing that func will generate errors in other implementations
+  const { data } = rawResponse as AxiosResponse<T>;
+
+  return data;
+};
+
+const send = async <T>(path: string, data: Record<string, any>) => {
+  const url = getStacksURL(path);
+
+  const opts: AxiosRequestConfig = {
+    method: "POST",
+    url,
+    data: JSON.stringify(data),
+    headers: { "Content-Type": "application/json" },
+  };
+
+  const rawResponse = await network(opts);
+
+  // We force data to this way as network func is not using generics. Changing that func will generate errors in other implementations
+  const { data: responseData } = rawResponse as AxiosResponse<T>;
+
+  return responseData;
+};
+
+const sendRaw = async <T>(path: string, data: Buffer) => {
+  const url = getStacksURL(path);
+
+  const opts: AxiosRequestConfig = {
+    method: "POST",
+    url,
+    data,
+    headers: { "Content-Type": "application/octet-stream" },
+  };
+
+  const rawResponse = await network(opts);
+
+  // We force data to this way as network func is not using generics. Changing that func will generate errors in other implementations
+  const { data: responseData } = rawResponse as AxiosResponse<T>;
+
+  return responseData;
+};
+
+export const fetchBalances = async (addr: string): Promise<BalanceResponse> => {
+  const data = await fetch<BalanceResponse>(`/extended/v1/address/${addr}/stx`);
+  return data; // TODO Validate if the response fits this interface
+};
+
+export const fetchEstimatedFees = async (
+  request: EstimatedFeesRequest,
+): Promise<EstimatedFeesResponse> => {
+  const feeRate = await send<EstimatedFeesResponse>(`/v2/fees/transfer`, request);
+  return feeRate; // TODO Validate if the response fits this interface
+};
+
+export const fetchBlockHeight = async (): Promise<NetworkStatusResponse> => {
+  const data = await fetch<NetworkStatusResponse>("/extended/v1/status");
+  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}`,
+  );
+  return response; // TODO Validate if the response fits this interface
+};
+
+export const fetchFullTxs = async (addr: string): Promise<TransactionResponse[]> => {
+  let qty,
+    offset = 0;
+  let txs: TransactionResponse[] = [];
+
+  do {
+    const { results, total, limit } = await fetchTxs(addr, offset);
+    txs = txs.concat(results);
+
+    offset += limit;
+    qty = total;
+  } while (offset < qty);
+
+  return txs; // TODO Validate if the response fits this interface
+};
+
+export const broadcastTx = async (
+  message: BroadcastTransactionRequest,
+): Promise<BroadcastTransactionResponse> => {
+  let response = await sendRaw<BroadcastTransactionResponse>(`/v2/transactions`, message);
+
+  if (response != "") response = `0x${response}`;
+  return response; // TODO Validate if the response fits this interface
+};
+
+export const fetchMempoolTxs = async (addr: string, offset = 0): Promise<MempoolResponse> => {
+  const response = await fetch<MempoolResponse>(
+    `/extended/v1/tx/mempool?sender_address=${addr}&offset=${offset}`,
+  );
+  return response; // TODO Validate if the response fits this interface
+};
+
+export const fetchFullMempoolTxs = async (addr: string): Promise<MempoolTransaction[]> => {
+  let qty,
+    offset = 0;
+  let txs: MempoolTransaction[] = [];
+
+  do {
+    const { results, total, limit } = await fetchMempoolTxs(addr, offset);
+    txs = txs.concat(results);
+
+    offset += limit;
+    qty = total;
+  } while (offset < qty);
+
+  return txs; // TODO Validate if the response fits this interface
+};
+
+export const fetchNonce = async (addr: string): Promise<GetNonceResponse> => {
+  const response = await fetch<GetNonceResponse>(`/extended/v1/address/${addr}/nonces`);
+  return response; // TODO Validate if the response fits this interface
+};

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

@@ -0,0 +1,96 @@
+import { StacksMainnet, StacksTestnet } from "@stacks/network";
+
+export const StacksNetwork = {
+  mainnet: new StacksMainnet(),
+  testnet: new StacksTestnet(),
+};
+
+export interface EstimatedFeesRequest {
+  to: string;
+  from: string;
+}
+
+export type EstimatedFeesResponse = number;
+
+export interface TransactionsResponse {
+  limit: number;
+  offset: number;
+  total: number;
+  results: TransactionResponse[];
+}
+
+export interface TransactionResponse {
+  tx: {
+    tx_id: string;
+    nonce: number;
+    tx_status: string;
+    tx_type: string;
+    fee_rate: string;
+    sender_address: string;
+    sponsored: boolean;
+    block_hash: string;
+    block_height: number;
+    tx_index: number;
+    burn_block_time: number;
+    token_transfer: {
+      recipient_address: string;
+      amount: string;
+      memo: string;
+    };
+  };
+  stx_transfers: {
+    amount: string;
+    sender: string;
+    recipient: string;
+  }[];
+}
+
+export interface MempoolTransaction {
+  tx_id: string;
+  nonce: number;
+  tx_status: string;
+  tx_type: string;
+  receipt_time: number;
+  receipt_time_iso: string;
+  fee_rate: string;
+  sender_address: string;
+  sponsored: boolean;
+  token_transfer: {
+    recipient_address: string;
+    amount: string;
+    memo: string;
+  };
+}
+
+export interface MempoolResponse {
+  limit: number;
+  offset: number;
+  total: number;
+  results: MempoolTransaction[];
+}
+
+export interface GetNonceResponse {
+  last_mempool_tx_nonce: number;
+  last_executed_tx_nonce: number;
+  possible_next_nonce: number;
+  detected_missing_nonces: number[];
+}
+
+export interface BalanceResponse {
+  balance: string;
+}
+
+export interface NetworkStatusResponse {
+  server_version: string;
+  status: string;
+  chain_tip: BlockIdentifier;
+}
+
+export type BroadcastTransactionRequest = Buffer;
+
+export type BroadcastTransactionResponse = string;
+
+interface BlockIdentifier {
+  block_height: number;
+  block_hash: string;
+}