@ledgerhq/coin-tron 0.0.1

package/src/test/cli.ts

@@ -0,0 +1,219 @@
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import type { Account, AccountLike, AccountLikeArray } from "@ledgerhq/types-live";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import zipWith from "lodash/zipWith";
+import { from, Observable } from "rxjs";
+import { map } from "rxjs/operators";
+import { getTronSuperRepresentativeData } from "../network";
+import type {
+  SuperRepresentativeData,
+  Transaction,
+  TronAccount,
+  Transaction as TronTransaction,
+  Vote,
+} from "../types";
+
+const options = [
+  {
+    name: "token",
+    alias: "t",
+    type: String,
+    desc: "use an token account children of the account",
+  },
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send, freeze, unfreeze, withdrawExpireUnfreeze, unDelegateResource, legacyUnfreeze",
+  },
+  {
+    name: "duration",
+    type: String,
+    desc: "duration in day",
+  },
+  {
+    name: "resource",
+    type: String,
+    desc: "reward ENERGY or BANDWIDTH",
+  },
+  {
+    name: "tronVoteAddress",
+    type: String,
+    multiple: true,
+    desc: "address of the super representative voting",
+  },
+  {
+    name: "tronVoteCount",
+    type: String,
+    multiple: true,
+    desc: "number of votes for the vote address",
+  },
+];
+
+function inferAccounts(account: Account, opts: Record<string, any>): AccountLikeArray {
+  invariant(account.currency.family === "tron", "tron family");
+
+  if (!opts.token) {
+    const accounts: Account[] = [account];
+    return accounts;
+  }
+
+  return opts.token.map((token: string) => {
+    const subAccounts = account.subAccounts || [];
+
+    if (token) {
+      const subAccount = subAccounts.find(t => {
+        const currency = getAccountCurrency(t);
+        return (
+          token.toLowerCase() === currency.ticker.toLowerCase() ||
+          token.toLowerCase() === currency.id
+        );
+      });
+
+      if (!subAccount) {
+        throw new Error(
+          "token account '" +
+            token +
+            "' not found. Available: " +
+            subAccounts.map(t => getAccountCurrency(t).ticker).join(", "),
+        );
+      }
+
+      return subAccount;
+    }
+  });
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, any>,
+): Transaction[] {
+  const mode = opts.mode || "send";
+  invariant(
+    [
+      "send",
+      "freeze",
+      "unfreeze",
+      "vote",
+      "claimReward",
+      "withdrawExpireUnfreeze",
+      "unDelegateResource",
+      "legacyUnfreeze",
+    ].includes(mode),
+    `Unexpected mode: ${mode}`,
+  );
+  const resource = opts.resource ? opts.resource.toUpperCase() : undefined;
+
+  if (resource) {
+    invariant(["BANDWIDTH", "ENERGY"].includes(resource), `Unexpected resource: ${resource}`);
+  }
+
+  const voteAddresses: string[] = opts["tronVoteAddress"] || [];
+  const voteCounts: number[] = (opts["tronVoteCount"] || []).map((value: string) => {
+    invariant(Number.isInteger(Number(value)), `Invalid integer: ${value}`);
+    return parseInt(value);
+  });
+  const votes: Vote[] = zipWith(voteAddresses, voteCounts, (a, c) => ({
+    address: a,
+    voteCount: c,
+  }));
+  return flatMap(transactions, ({ transaction, account }) => {
+    invariant(transaction.family === "tron", "tron family");
+
+    if (account.type === "Account") {
+      invariant((account as TronAccount).tronResources, "unactivated account");
+    }
+
+    if (account.type === "TokenAccount") {
+      const isDelisted = account.token.delisted === true;
+      invariant(!isDelisted, "token is delisted");
+    }
+
+    return {
+      ...transaction,
+      family: "tron",
+      subAccountId: account.type === "TokenAccount" ? account.id : null,
+      mode,
+      resource,
+      votes,
+    } as TronTransaction;
+  });
+}
+
+const formatOptStr = (str: string | null | undefined): string => str || "";
+
+const superRepresentativesFormatters = {
+  json: (srData: SuperRepresentativeData): string => JSON.stringify(srData),
+  default: (srData: SuperRepresentativeData): string => {
+    const headerList = 'address "name" url voteCount brokerage isJobs';
+    const strList = srData.list.map(
+      sr =>
+        `${sr.address} "${formatOptStr(sr.name)}" ${formatOptStr(sr.url)} ${sr.voteCount} ${
+          sr.brokerage
+        } ${sr.isJobs}`,
+    );
+    const metaData = [
+      `nextVotingDate: ${srData.nextVotingDate}`,
+      `totalVotes: ${srData.totalVotes}`,
+    ];
+    return [headerList].concat(strList).concat(metaData).join("\n");
+  },
+};
+
+const tronSuperRepresentative = {
+  args: [
+    {
+      name: "max",
+      desc: "max number of super representatives to return",
+      type: Number,
+    },
+    {
+      name: "format",
+      desc: Object.keys(superRepresentativesFormatters).join(" | "),
+      type: String,
+    },
+  ],
+  job: ({
+    max,
+    format,
+  }: Partial<{
+    max: number | null | undefined;
+    format: "json" | "default";
+  }>): Observable<string> =>
+    from(getTronSuperRepresentativeData(max)).pipe(
+      map((srData: SuperRepresentativeData) => {
+        const f = format
+          ? superRepresentativesFormatters[format]
+          : superRepresentativesFormatters.default;
+        return f(srData);
+      }),
+    ),
+};
+
+export type CliTools = {
+  options: typeof options;
+  inferAccounts: typeof inferAccounts;
+  inferTransactions: (
+    transactions: Array<{
+      account: AccountLike;
+      transaction: Transaction;
+    }>,
+    opts: Record<string, any>,
+    { inferAmount }: any,
+  ) => Transaction[];
+  commands: { tronSuperRepresentative: typeof tronSuperRepresentative };
+};
+
+export default function makeCliTools(): CliTools {
+  return {
+    options,
+    inferAccounts,
+    inferTransactions,
+    commands: {
+      tronSuperRepresentative,
+    },
+  };
+}

package/src/test/index.ts

@@ -0,0 +1,6 @@
+import makeCliTools from "./cli";
+
+export * from "./bridgeDatasetTest";
+export { makeCliTools };
+export * from "./bot-specs";
+export * from "./bot-deviceActions";

package/src/types/bridge.ts

@@ -0,0 +1,304 @@
+import {
+  Account,
+  AccountRaw,
+  Operation,
+  OperationExtra,
+  OperationExtraRaw,
+  OperationRaw,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+
+export type TronOperationMode =
+  | "send"
+  | "freeze"
+  | "unfreeze"
+  | "vote"
+  | "claimReward"
+  | "withdrawExpireUnfreeze"
+  | "unDelegateResource"
+  | "legacyUnfreeze";
+
+export type TronResource = "BANDWIDTH" | "ENERGY";
+export type NetworkInfo = {
+  family: "tron";
+  freeNetUsed: BigNumber;
+  freeNetLimit: BigNumber;
+  netUsed: BigNumber;
+  netLimit: BigNumber;
+  energyUsed: BigNumber;
+  energyLimit: BigNumber;
+};
+export type NetworkInfoRaw = {
+  family: "tron";
+  freeNetUsed: string;
+  freeNetLimit: string;
+  netUsed: string;
+  netLimit: string;
+  energyUsed: string;
+  energyLimit: string;
+};
+export type Transaction = TransactionCommon & {
+  family: "tron";
+  mode: TronOperationMode;
+  resource: TronResource | null | undefined;
+  networkInfo: NetworkInfo | null | undefined;
+  duration: number | null | undefined;
+  votes: Vote[];
+};
+export type TransactionRaw = TransactionCommonRaw & {
+  mode: TronOperationMode;
+  family: "tron";
+  resource: TronResource | null | undefined;
+  networkInfo: NetworkInfoRaw | null | undefined;
+  duration: number | null | undefined;
+  votes: Vote[];
+};
+export type TrongridTxType =
+  | "TransferContract"
+  | "TransferAssetContract"
+  | "FreezeBalanceContract"
+  | "UnfreezeBalanceContract"
+  | "VoteWitnessContract"
+  | "TriggerSmartContract"
+  | "WithdrawBalanceContract"
+  | "ExchangeTransactionContract"
+  | "FreezeBalanceV2Contract"
+  | "UnfreezeBalanceV2Contract"
+  | "WithdrawExpireUnfreezeContract"
+  | "UnDelegateResourceContract";
+
+export type TrongridTxInfo = {
+  txID: string;
+  date: Date;
+  type: TrongridTxType;
+  tokenId?: string;
+  from: string;
+  to?: string;
+  value?: BigNumber;
+  fee?: BigNumber;
+  resource?: TronResource;
+  blockHeight?: number;
+  extra?: TrongridExtraTxInfo;
+  hasFailed: boolean;
+};
+
+export type TronOperation = Operation<TrongridExtraTxInfo>;
+export type TronOperationRaw = OperationRaw<TrongridExtraTxInfoRaw>;
+
+export type TrongridExtraTxInfo = OperationExtra & {
+  frozenAmount?: BigNumber;
+  unfreezeAmount?: BigNumber;
+  votes?: Vote[];
+  unDelegatedAmount?: BigNumber;
+  receiverAddress?: string;
+};
+export function isTrongridExtraTxInfo(op: OperationExtra): op is TrongridExtraTxInfo {
+  return (
+    op !== null &&
+    typeof op === "object" &&
+    ("frozenAmount" in op || "unfreezeAmount" in op || "votes" in op)
+  );
+}
+export type TrongridExtraTxInfoRaw = OperationExtraRaw & {
+  frozenAmount?: string;
+  unfreezeAmount?: string;
+  votes?: Vote[];
+  unDelegatedAmount?: string;
+  receiverAddress?: string;
+};
+export function isTrongridExtraTxInfoRaw(op: OperationExtraRaw): op is TrongridExtraTxInfoRaw {
+  return (
+    op !== null &&
+    typeof op === "object" &&
+    ("frozenAmount" in op || "unfreezeAmount" in op || "votes" in op)
+  );
+}
+
+/** Payload types to send to trongrid */
+export type SendTransactionData = {
+  to_address: string;
+  owner_address: string;
+  amount: number;
+  asset_name: string | null | undefined;
+};
+export type SmartContractFunction = "transfer(address,uint256)";
+export type SmartContractTransactionData = {
+  function_selector: SmartContractFunction;
+  fee_limit: number;
+  call_value: number;
+  contract_address: string;
+  parameter: string;
+  owner_address: string;
+};
+
+export type FreezeTransactionData = {
+  owner_address: string;
+  frozen_balance: number;
+  resource: TronResource | null | undefined;
+};
+
+export type UnFreezeTransactionData = {
+  owner_address: string;
+  resource: TronResource | null | undefined;
+  unfreeze_balance: number;
+};
+
+export type LegacyUnfreezeTransactionData = {
+  receiver_address?: string;
+  owner_address: string;
+  resource: TronResource | null | undefined;
+};
+
+export type WithdrawExpireUnfreezeTransactionData = {
+  owner_address: string;
+};
+
+export type UnDelegateResourceTransactionData = {
+  owner_address: string;
+  resource: TronResource | null | undefined;
+  receiver_address: string;
+  balance: number;
+};
+
+export type SendTransactionDataSuccess = {
+  raw_data_hex?: string;
+  raw_data: Record<string, any> | undefined;
+  txID: string;
+};
+
+export type SuperRepresentativeData = {
+  list: SuperRepresentative[];
+  totalVotes: number;
+  nextVotingDate: Date;
+};
+export type SuperRepresentative = {
+  address: string;
+  name: string | null | undefined;
+  url: string | null | undefined;
+  isJobs: boolean;
+  brokerage: number;
+  voteCount: number;
+  totalProduced: number | null | undefined;
+  totalMissed: number | null | undefined;
+  latestBlockNum: number | null | undefined;
+  latestSlotNum: number | null | undefined;
+};
+export type TronResources = {
+  frozen: {
+    bandwidth: FrozenInfo | null | undefined;
+    energy: FrozenInfo | null | undefined;
+  };
+  unFrozen: {
+    bandwidth: UnFrozenInfo[] | null | undefined;
+    energy: UnFrozenInfo[] | null | undefined;
+  };
+  delegatedFrozen: {
+    bandwidth: DelegatedFrozenInfo | null | undefined;
+    energy: DelegatedFrozenInfo | null | undefined;
+  };
+  legacyFrozen: {
+    bandwidth: LegacyFrozenInfo | null | undefined;
+    energy: LegacyFrozenInfo | null | undefined;
+  };
+  votes: Vote[];
+  tronPower: number;
+  energy: BigNumber;
+  bandwidth: BandwidthInfo;
+  unwithdrawnReward: BigNumber;
+  lastWithdrawnRewardDate: Date | null | undefined;
+  lastVotedDate: Date | null | undefined;
+  cacheTransactionInfoById: Record<string, TronTransactionInfo> | undefined;
+};
+export type TronResourcesRaw = {
+  frozen: {
+    bandwidth: FrozenInfoRaw | null | undefined;
+    energy: FrozenInfoRaw | null | undefined;
+  };
+  unFrozen: {
+    bandwidth: UnFrozenInfoRaw[] | null | undefined;
+    energy: UnFrozenInfoRaw[] | null | undefined;
+  };
+  delegatedFrozen: {
+    bandwidth: DelegatedFrozenInfoRaw | null | undefined;
+    energy: DelegatedFrozenInfoRaw | null | undefined;
+  };
+  legacyFrozen: {
+    bandwidth: LegacyFrozenInfoRaw | null | undefined;
+    energy: LegacyFrozenInfoRaw | null | undefined;
+  };
+  votes: Vote[];
+  tronPower: number;
+  energy: string;
+  bandwidth: BandwidthInfoRaw;
+  unwithdrawnReward: string;
+  lastWithdrawnRewardDate: string | null | undefined;
+  lastVotedDate: string | null | undefined;
+  cacheTransactionInfoById: Record<string, TronTransactionInfoRaw> | undefined;
+};
+export type Vote = {
+  address: string;
+  voteCount: number;
+};
+
+export type DelegatedFrozenInfo = {
+  amount: BigNumber;
+};
+export type DelegatedFrozenInfoRaw = {
+  amount: string;
+};
+
+export type FrozenInfo = {
+  amount: BigNumber;
+};
+
+export type FrozenInfoRaw = {
+  amount: string;
+};
+
+export type LegacyFrozenInfo = {
+  amount: BigNumber;
+  expiredAt: Date;
+};
+
+export type LegacyFrozenInfoRaw = {
+  amount: string;
+  expiredAt: string;
+};
+
+export type UnFrozenInfo = {
+  amount: BigNumber;
+  expireTime: Date;
+};
+
+export type UnFrozenInfoRaw = {
+  amount: string;
+  expireTime: string;
+};
+
+export type BandwidthInfo = {
+  freeUsed: BigNumber;
+  freeLimit: BigNumber;
+  gainedUsed: BigNumber;
+  gainedLimit: BigNumber;
+};
+export type BandwidthInfoRaw = {
+  freeUsed: string;
+  freeLimit: string;
+  gainedUsed: string;
+  gainedLimit: string;
+};
+export type TronTransactionInfo = {
+  fee: number;
+  blockNumber: number;
+  withdraw_amount?: number;
+  unfreeze_amount?: number;
+};
+export type TronTransactionInfoRaw = [number, number, number?, number?];
+export type TronAccount = Account & { tronResources: TronResources };
+export type TronAccountRaw = AccountRaw & { tronResources: TronResourcesRaw };
+export type TransactionStatus = TransactionStatusCommon;
+export type TransactionStatusRaw = TransactionStatusCommonRaw;

package/src/types/errors.ts

@@ -0,0 +1,22 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const TronNoFrozenForBandwidth = createCustomErrorClass("TronNoFrozenForBandwidth");
+export const TronNoFrozenForEnergy = createCustomErrorClass("TronNoFrozenForEnergy");
+export const TronUnfreezeNotExpired = createCustomErrorClass("TronUnfreezeNotExpired");
+export const TronLegacyUnfreezeNotExpired = createCustomErrorClass("TronLegacyUnfreezeNotExpired");
+export const TronVoteRequired = createCustomErrorClass("TronVoteRequired");
+export const TronInvalidVoteCount = createCustomErrorClass("TronInvalidVoteCount");
+export const TronRewardNotAvailable = createCustomErrorClass("TronRewardNotAvailable");
+export const TronNoReward = createCustomErrorClass("TronNoReward");
+export const TronInvalidFreezeAmount = createCustomErrorClass("TronInvalidFreezeAmount");
+export const TronSendTrc20ToNewAccountForbidden = createCustomErrorClass(
+  "TronSendTrc20ToNewAccountForbidden",
+);
+export const TronUnexpectedFees = createCustomErrorClass("TronUnexpectedFees");
+export const TronNotEnoughTronPower = createCustomErrorClass("TronNotEnoughTronPower");
+export const TronTransactionExpired = createCustomErrorClass("TronTransactionExpired");
+export const TronNotEnoughEnergy = createCustomErrorClass("TronNotEnoughEnergy");
+export const TronNoUnfrozenResource = createCustomErrorClass("TronNoUnfrozenResource");
+export const TronInvalidUnDelegateResourceAmount = createCustomErrorClass(
+  "TronInvalidUnDelegateResourceAmount",
+);

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from "./bridge";
+export * from "./errors";
+// export * from "./model";
+export * from "./signer";

package/src/types/signer.ts

@@ -0,0 +1,9 @@
+export type TronAddress = {
+  publicKey: string;
+  address: string;
+};
+export type TronSignature = string;
+export interface TronSigner {
+  getAddress(path: string, boolDisplay?: boolean): Promise<TronAddress>;
+  sign(path: string, rawTxHex: string, tokenSignatures: string[]): Promise<TronSignature>;
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "module": "commonjs",
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "outDir": "lib",
+    "typeRoots": ["./types", "./node_modules/@types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/api/subscan.ts", "src/api/websocket.ts"]
+}

package/types/tronweb/index.d.ts

@@ -0,0 +1,5 @@
+declare module "tronweb" {
+  export * from "@agrozyme/types-tronweb";
+  import TronWeb from "@agrozyme/types-tronweb";
+  export default TronWeb;
+}