@ledgerhq/coin-tron 0.0.1

package/src/network/types.ts

@@ -0,0 +1,147 @@
+import { TrongridTxType } from "../types";
+
+export type TransactionResponseTronAPI<T> = {
+  data: T[];
+  success: boolean;
+  meta: {
+    at: number;
+    page_size: number;
+    links?: {
+      next: string;
+    };
+  };
+};
+
+//-- TRANSACTION
+export type TransactionTronAPI<T = TransactionContract> = {
+  ret: Ret[];
+  signature: string[];
+  txID: string;
+  tx_id?: string; // Not found in request to TronGrid...
+  net_usage: number;
+  raw_data_hex: string;
+  net_fee: number;
+  energy_usage: number;
+  blockNumber?: number;
+  block_timestamp: number;
+  energy_fee: number;
+  energy_usage_total: number;
+  unfreeze_amount?: number;
+  withdraw_amount?: number;
+  raw_data: TransactionRawData<T>;
+  internal_transactions: any[];
+};
+
+type Ret = {
+  contractRet: string; // Better to have an exhaustive list: "STRING" + ?
+  fee?: number;
+};
+
+type TransactionRawData<T> = {
+  contract: Contract<T>[];
+  ref_block_bytes: string;
+  ref_block_hash: string;
+  expiration: number;
+  timestamp?: number;
+  fee_limit?: number;
+  data?: string;
+};
+
+type Contract<T> = {
+  parameter: {
+    value: T;
+    type_url: string;
+  };
+  type: TrongridTxType;
+};
+
+type Vote = {
+  vote_address: string;
+  vote_count: number;
+};
+
+type TransactionContract = {
+  owner_address: string;
+  votes?: Vote[];
+  resource: any;
+  frozen_balance?: number;
+  amount?: number;
+  to_address?: string;
+  data?: string;
+  contract_address?: string;
+  asset_name?: string;
+  frozen_duration?: number;
+  resource_type?: "BANDWIDTH" | "ENERGY";
+  resource_value?: number;
+  quant?: number;
+  receiver_address?: string;
+  unfreeze_balance?: number;
+  balance?: number;
+};
+
+//-- Transaction details
+export type TransactionInfoTronAPI = {
+  id: string;
+  fee: number;
+  blockNumber: number;
+  blockTimeStamp: number;
+  contractResult: string[];
+  receipt: {
+    net_usage?: number;
+    net_fee?: number;
+  };
+};
+
+export function isTransactionTronAPI(tx: unknown): tx is TransactionTronAPI {
+  return (tx as TransactionTronAPI).txID !== undefined;
+}
+
+//-- TRC20
+export type Trc20API = {
+  transaction_id: string;
+  token_info: TokenInfo;
+  block_timestamp: number;
+  from: string;
+  to: string;
+  detail: TransactionTronAPI<Trc20Contract>;
+  type: string;
+  value?: string;
+};
+
+type TokenInfo = {
+  symbol: string;
+  address?: string;
+  decimals: number;
+  name: string;
+};
+
+type Trc20Contract = {
+  data: string;
+  owner_address: string;
+  contract_address: string;
+};
+
+//-- Malformed?
+export type MalformedTransactionTronAPI = {
+  internal_tx_id: string;
+  data: {
+    note: string;
+    rejected: boolean;
+    call_value: {
+      _: number;
+    };
+  };
+  block_timestamp: number;
+  to_address: string;
+  tx_id: string;
+  from_address: string;
+};
+
+export function isMalformedTransactionTronAPI(
+  tx: TransactionTronAPI | MalformedTransactionTronAPI,
+): tx is MalformedTransactionTronAPI {
+  return (
+    (tx as MalformedTransactionTronAPI).internal_tx_id !== undefined ||
+    (tx as MalformedTransactionTronAPI).tx_id !== undefined
+  );
+}

package/src/signer/getAddress.ts

@@ -0,0 +1,13 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { TronSigner } from "../types";
+
+const getAddress = (signerContext: SignerContext<TronSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const r = await signerContext(deviceId, signer => signer.getAddress(path, verify));
+    return { ...r, path };
+  };
+};
+
+export default getAddress;

package/src/signer/index.ts

@@ -0,0 +1,7 @@
+/**
+ * This directory is the home for all types and logic based on Ledgers signer.
+ */
+
+import getAddress from "./getAddress";
+
+export default getAddress;

package/src/test/bot-deviceActions.ts

@@ -0,0 +1,121 @@
+import type { DeviceAction, DeviceActionArg } from "@ledgerhq/coin-framework/bot/types";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+import type { Transaction, Vote } from "../types";
+import { Account } from "@ledgerhq/types-live";
+
+function subAccount(subAccountId: string, account: Account) {
+  const sub = (account.subAccounts || []).find(a => a.id === subAccountId);
+  if (!sub || sub.type !== "TokenAccount")
+    throw new Error("expected sub account id " + subAccountId);
+  return sub;
+}
+
+const resourceExpected = ({ transaction: { resource } }: DeviceActionArg<Transaction, any>) =>
+  resource ? resource.slice(0, 1).toUpperCase() + resource.slice(1).toLowerCase() : "";
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Review",
+      button: SpeculosButton.RIGHT, // TODO define expectedValue
+    },
+    {
+      title: "Claim",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Gain",
+      button: SpeculosButton.RIGHT,
+      expectedValue: arg => resourceExpected(arg),
+    },
+    {
+      title: "Resource",
+      button: SpeculosButton.RIGHT,
+      expectedValue: arg => resourceExpected(arg),
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status, transaction }) =>
+        formatDeviceAmount(
+          transaction.subAccountId
+            ? subAccount(transaction.subAccountId, account).token
+            : account.currency,
+          status.amount,
+          {
+            hideCode: true,
+          },
+        ),
+    },
+    {
+      title: "Token",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, transaction }) => {
+        const isTokenTransaction = Boolean(transaction.subAccountId);
+        if (isTokenTransaction) {
+          const token = subAccount(transaction.subAccountId!, account).token;
+          const [, tokenType, tokenId] = token.id.split("/");
+          if (tokenType === "trc10") {
+            return `${token.name.split(" ")[0]}[${tokenId}]`;
+          } else {
+            return token.ticker;
+          }
+        }
+        return "TRX";
+      },
+    },
+    {
+      title: "From Address",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Freeze To",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Delegated To",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "To",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Sign",
+      button: SpeculosButton.BOTH,
+      final: true,
+    },
+  ],
+  fallback: ({ event, transaction }) => {
+    if (transaction.mode === "vote") {
+      for (const vote of transaction.votes) {
+        const title = `${vote.address.slice(0, 5)}...${vote.address.slice(
+          vote.address.length - 5,
+        )}`;
+
+        if (event.text === title) {
+          return voteAction(vote, title);
+        }
+      }
+    }
+  },
+});
+
+function voteAction(
+  vote: Vote,
+  title: string,
+): { title: string; button: SpeculosButton; expectedValue: () => string } {
+  return {
+    title,
+    button: SpeculosButton.RIGHT,
+    expectedValue: () => String(vote.voteCount),
+  };
+}