@ledgerhq/coin-stacks 0.1.1-next.0

package/src/bridge/utils/misc.unit.test.ts

@@ -0,0 +1,237 @@
+import { mapPendingTxToOps, mapTxToOps } from "./misc";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { TransactionResponse, fetchFullTxs } from "../../network/index";
+import { Operation } from "@ledgerhq/types-live";
+
+const Address = "SP26AZ1JSFZQ82VH5W2NJSB2QW15EW5YKT6WMD69J";
+
+const mempoolTransfer = {
+  tx_id: "0x628369d2c9b49f0ec95531fe1e6a39141573117f3dd047fca65ff5e4058fbc55",
+  nonce: 32,
+  fee_rate: "487",
+  sender_address: "SPNX9YY3T4GR4XDSNRVWB2MDQVCTJMP3BGT7VCZA",
+  sponsored: false,
+  post_condition_mode: "deny",
+  post_conditions: [],
+  anchor_mode: "any",
+  tx_status: "pending",
+  receipt_time: 1714554733,
+  receipt_time_iso: "2024-05-01T09:12:13.000Z",
+  tx_type: "token_transfer",
+  token_transfer: {
+    recipient_address: "SP26AZ1JSFZQ82VH5W2NJSB2QW15EW5YKT6WMD69J",
+    amount: "9523",
+    memo: "0x00000000000000000000000000000000000000000000000000000000000000000000",
+  },
+};
+
+const sendManyTransfer = {
+  tx: {
+    tx_id: "0x68bdba90cdbd4e2e112fd008c8c396bd4ca365e482dc68fe25c7aeb5d8eb4c3f",
+    nonce: 18,
+    fee_rate: "500000",
+    sender_address: "SP26AZ1JSFZQ82VH5W2NJSB2QW15EW5YKT6WMD69J",
+    sponsored: false,
+    post_condition_mode: "deny",
+    post_conditions: [
+      {
+        type: "stx",
+        condition_code: "sent_equal_to",
+        amount: "345000",
+        principal: {
+          type_id: "principal_standard",
+          address: "SP26AZ1JSFZQ82VH5W2NJSB2QW15EW5YKT6WMD69J",
+        },
+      },
+    ],
+    anchor_mode: "any",
+    is_unanchored: false,
+    block_hash: "0xc8dd294972d86b09d4226fe99f8bfcdf2c55a7280ca87b7dc8b0fd119a7059f1",
+    parent_block_hash: "0xc8f2c105e37544ce27a3a470651d950c6e8fe5f6c072aef653e7ea1fbd97a429",
+    block_height: 137791,
+    block_time: 1706802438,
+    block_time_iso: "2024-02-01T15:47:18.000Z",
+    burn_block_time: 1706802438,
+    burn_block_time_iso: "2024-02-01T15:47:18.000Z",
+    parent_burn_block_time: 1706801557,
+    parent_burn_block_time_iso: "2024-02-01T15:32:37.000Z",
+    canonical: true,
+    tx_index: 121,
+    tx_status: "success",
+    tx_result: {
+      hex: "0x0703",
+      repr: "(ok true)",
+    },
+    microblock_hash: "0x",
+    microblock_sequence: 2147483647,
+    microblock_canonical: true,
+    event_count: 6,
+    events: [],
+    execution_cost_read_count: 6,
+    execution_cost_read_length: 737,
+    execution_cost_runtime: 151010,
+    execution_cost_write_count: 3,
+    execution_cost_write_length: 3,
+    tx_type: "contract_call",
+    contract_call: {
+      contract_id: "SP3FBR2AGK5H9QBDH3EEN6DF8EK8JY7RX8QJ5SVTE.send-many-memo",
+      function_name: "send-many",
+      function_signature: "",
+      function_args: [
+        {
+          hex: "0x0b000000030c00000003046d656d6f020000000333333302746f05162bd4fbc3d1218275b9ae37c58a8dbed9a952c35c047573747801000000000000000000000000000027100c00000003046d656d6f020000000334343402746f051601a0369ffa2faa8fe74faada53e2e3d215b4d42a047573747801000000000000000000000000000088b80c00000003046d656d6f020000000335353502746f051660cc6b74d6d317918d0a7717069da56d775d817e047573747801000000000000000000000000000493e0",
+          repr: "(list (tuple (memo 0x333333) (to 'SPNX9YY3T4GR4XDSNRVWB2MDQVCTJMP3BGT7VCZA) (ustx u10000)) (tuple (memo 0x343434) (to 'SPT0DMZZ8QTN3Z79YNDMMZ2WF91BD6M59S9Z10Y) (ustx u35000)) (tuple (memo 0x353535) (to 'SP1GCRTVMTV9HF4CD19VHE1MXMNPQEQC1FT6YWF5Y) (ustx u300000)))",
+          name: "",
+          type: "(list 3 (tuple (memo (buff 3)) (to principal) (ustx uint)))",
+        },
+      ],
+    },
+  },
+  stx_sent: "845000",
+  stx_received: "0",
+  events: {
+    stx: {
+      transfer: 3,
+      mint: 0,
+      burn: 0,
+    },
+    ft: {
+      transfer: 0,
+      mint: 0,
+      burn: 0,
+    },
+    nft: {
+      transfer: 0,
+      mint: 0,
+      burn: 0,
+    },
+  },
+};
+
+const basicTransfer = {
+  tx: {
+    tx_id: "0x84254bb1e50b9e4f1dd48161ba5e87dff4ba8718117e8c364769067614dfb99a",
+    nonce: 22,
+    fee_rate: "125250",
+    sender_address: "SP26AZ1JSFZQ82VH5W2NJSB2QW15EW5YKT6WMD69J",
+    sponsored: false,
+    post_condition_mode: "deny",
+    post_conditions: [],
+    anchor_mode: "any",
+    is_unanchored: false,
+    block_hash: "0xd3272fbbc264eec8f8b7857541d7a5e6c043b54dd799274544a72d185dc34f1d",
+    parent_block_hash: "0x7bc3a3adae166f4a876697ad4c4f924d29dcea2c84607fc7765c0ed0855c3e90",
+    block_height: 151738,
+    block_time: 1716831904,
+    block_time_iso: "2024-05-27T17:45:04.000Z",
+    burn_block_time: 1716831849,
+    burn_block_time_iso: "2024-05-27T17:44:09.000Z",
+    parent_burn_block_time: 1716831377,
+    parent_burn_block_time_iso: "2024-05-27T17:36:17.000Z",
+    canonical: true,
+    tx_index: 29,
+    tx_status: "success",
+    tx_result: {
+      hex: "0x0703",
+      repr: "(ok true)",
+    },
+    microblock_hash: "0x",
+    microblock_sequence: 2147483647,
+    microblock_canonical: true,
+    event_count: 1,
+    events: [],
+    execution_cost_read_count: 0,
+    execution_cost_read_length: 0,
+    execution_cost_runtime: 0,
+    execution_cost_write_count: 0,
+    execution_cost_write_length: 0,
+    tx_type: "token_transfer",
+    token_transfer: {
+      recipient_address: "SPNX9YY3T4GR4XDSNRVWB2MDQVCTJMP3BGT7VCZA",
+      amount: "827695",
+      memo: "0x31323333333334000000000000000000000000000000000000000000000000000000",
+    },
+  },
+  stx_sent: "952945",
+  stx_received: "0",
+  events: {
+    stx: {
+      transfer: 1,
+      mint: 0,
+      burn: 0,
+    },
+    ft: {
+      transfer: 0,
+      mint: 0,
+      burn: 0,
+    },
+    nft: {
+      transfer: 0,
+      mint: 0,
+      burn: 0,
+    },
+  },
+};
+
+describe("operation building from raw", () => {
+  test("map raw transaction to op", async () => {
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: "stacks",
+      xpubOrAddress: "",
+      derivationMode: "stacks_wallet",
+    });
+
+    // Contains operations for txn of type token_transfer
+    const operations = ([sendManyTransfer, basicTransfer] as any).flatMap(
+      mapTxToOps(accountId, Address),
+    );
+
+    expect(operations.length).toBe(2);
+
+    const opSenMany = operations[0];
+    const opBasic = operations[1];
+
+    expect(opSenMany.type).toBe("OUT");
+    expect(opSenMany.internalOperations).toHaveLength(3);
+    expect(opSenMany.senders).toHaveLength(1);
+    expect(opSenMany.recipients).toHaveLength(0);
+
+    expect(opBasic.type).toBe("OUT");
+    expect(opBasic.internalOperations).toBeUndefined();
+    expect(opBasic.senders).toHaveLength(1);
+    expect(opBasic.recipients).toHaveLength(1);
+  });
+});
+
+test("convert raw transactions to live operations", async () => {
+  const rawTxs: TransactionResponse[] = await fetchFullTxs(Address);
+  const operations: Operation[] = rawTxs.flatMap(mapTxToOps("dummyAccountID", Address));
+
+  expect(operations).toBeDefined();
+  expect(operations.length).toBeGreaterThan(0);
+});
+
+describe("operation building from mempool raw", () => {
+  test("map raw mempool transaction to op", async () => {
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: "stacks",
+      xpubOrAddress: "",
+      derivationMode: "stacks_wallet",
+    });
+
+    const address = "SPNX9YY3T4GR4XDSNRVWB2MDQVCTJMP3BGT7VCZA";
+
+    // Contains operations for txn of type token_transfer
+    const operations = [mempoolTransfer].map(mapPendingTxToOps(accountId, address)).flat();
+
+    expect(operations.length).toBe(1);
+    expect(operations[0].type).toBe("OUT");
+    expect(operations[0].internalOperations).toBeUndefined();
+    expect(operations[0].senders).toHaveLength(1);
+    expect(operations[0].recipients).toHaveLength(1);
+  });
+});

package/src/config.ts

@@ -0,0 +1,26 @@
+import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type StacksCoinConfig = () => CurrencyConfig & {
+  config_currency_stacks: {
+    type: "object";
+    default: {
+      status: {
+        type: "active";
+      };
+    };
+  };
+};
+
+let coinConfig: StacksCoinConfig | undefined;
+
+export const setCoinConfig = (config: StacksCoinConfig): void => {
+  coinConfig = config;
+};
+
+export const getCoinConfig = (): ReturnType<StacksCoinConfig> => {
+  if (!coinConfig?.()) {
+    throw new Error("Stacks module config not set");
+  }
+
+  return coinConfig();
+};

package/src/errors.ts

@@ -0,0 +1,3 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const StacksMemoTooLong = createCustomErrorClass("StacksMemoTooLong");

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+
+export { createBridges } from "./bridge/index";
+export type { StacksCoinConfig } from "./config";

package/src/network/api.ts

@@ -0,0 +1,173 @@
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+
+import { getEnv } from "@ledgerhq/live-env";
+import network from "@ledgerhq/live-network/network";
+import {
+  BalanceResponse,
+  BroadcastTransactionRequest,
+  BroadcastTransactionResponse,
+  EstimatedFeesRequest,
+  EstimatedFeesResponse,
+  GetNonceResponse,
+  MempoolResponse,
+  MempoolTransaction,
+  NetworkStatusResponse,
+  TransactionResponse,
+  TransactionsResponse,
+} from "./api.types";
+
+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");
+  return data as NetworkStatusResponse; // TODO Validate if the response fits this interface
+};
+
+export const fetchTxs = async (addr: string, offset = 0): Promise<TransactionsResponse> => {
+  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[]> => {
+  let qty,
+    offset = 0;
+  let txs: TransactionResponse[] = [];
+
+  do {
+    const { results, total, limit } = await fetchTxs(addr, offset);
+    txs = txs.concat(
+      results.filter(t => {
+        if (t.tx?.tx_type === "token_transfer") {
+          return true;
+        }
+
+        if (
+          t.tx?.tx_type === "contract_call" &&
+          t.tx?.contract_call?.function_name === "send-many"
+        ) {
+          return true;
+        }
+
+        return false;
+      }),
+    );
+
+    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/network/api.types.ts

@@ -0,0 +1,180 @@
+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;
+    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;
+    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: Array<{
+        hex: string;
+        repr: string;
+        name: string;
+        type: 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 {
+  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;
+}

package/src/network/index.ts

@@ -0,0 +1,2 @@
+export * from "./api";
+export * from "./api.types";

package/src/signer/getAddress.ts

@@ -0,0 +1,27 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { AddressVersion } from "@stacks/transactions/dist";
+import { StacksSigner } from "../types";
+import { getPath, throwIfError } from "../utils";
+
+const resolver = (signerContext: SignerContext<StacksSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const r = await signerContext(deviceId, async signer => {
+      const r = verify
+        ? await signer.showAddressAndPubKey(getPath(path), AddressVersion.MainnetSingleSig)
+        : await signer.getAddressAndPubKey(getPath(path), AddressVersion.MainnetSingleSig);
+      return r;
+    });
+
+    throwIfError(r);
+
+    return {
+      path,
+      address: r.address,
+      publicKey: r.publicKey.toString("hex"),
+    };
+  };
+};
+
+export default resolver;

package/src/signer/index.ts

@@ -0,0 +1,4 @@
+import resolver from "./getAddress";
+
+export * from "./signMessage";
+export default resolver;

package/src/signer/signMessage.ts

@@ -0,0 +1,26 @@
+import { getBufferFromString, getPath, throwIfError } from "../utils";
+
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { Account, AnyMessage } from "@ledgerhq/types-live";
+import { StacksSigner } from "../types";
+
+export const signMessage =
+  (signerContext: SignerContext<StacksSigner>) =>
+  async (deviceId: string, account: Account, { message }: AnyMessage) => {
+    if (!message) throw new Error(`Message cannot be empty`);
+    if (typeof message !== "string") throw new Error(`Message must be string`);
+
+    const r = await signerContext(deviceId, signer =>
+      signer.sign(getPath(account.freshAddressPath), getBufferFromString(message)),
+    );
+    throwIfError(r);
+
+    return {
+      rsv: {
+        r: r.signatureCompact.slice(0, 32).toString("hex"),
+        s: r.signatureCompact.slice(32, 64).toString("hex"),
+        v: parseInt(r.signatureCompact.slice(64, 65).toString("hex"), 16),
+      },
+      signature: `0x${r.signatureVRS.toString("hex")}`,
+    };
+  };