@ledgerhq/coin-tron 5.18.0 → 5.19.0

package/src/network/format.test.ts

@@ -1,6 +1,43 @@
 import BigNumber from "bignumber.js";
-import { decode58Check, encode58Check, formatTrongridTrc20TxResponse } from "./format";
-import { Trc20API } from "./types";
+import {
+  decode58Check,
+  encode58Check,
+  formatTrongridTrc20TxResponse,
+  formatTrongridTxResponse,
+} from "./format";
+import { Trc20API, TransactionTronAPI } from "./types";
+import type { TronTransactionInfo } from "../types";
+
+const ownerHex = "41fd49eda0f23ff7ec1d03b52c3a45991c24cd440e";
+const toHex = "4198927ffb9f554dc4a453c64b2e553a02d6df514b";
+const trc20ContractHex = "4142a1e39aefa49290f2b3f9ed688d7cecf86cd6e0";
+
+function baseTransactionTronApi(
+  contract: TransactionTronAPI["raw_data"]["contract"][0],
+  overrides: Partial<TransactionTronAPI & { detail?: TronTransactionInfo }> = {},
+): TransactionTronAPI & { detail?: TronTransactionInfo } {
+  return {
+    ret: [{ contractRet: "SUCCESS", fee: 1000 }],
+    signature: [],
+    txID: "txId",
+    net_usage: 0,
+    raw_data_hex: "",
+    net_fee: 0,
+    energy_usage: 0,
+    block_timestamp: 1,
+    blockNumber: 42,
+    energy_fee: 0,
+    energy_usage_total: 0,
+    raw_data: {
+      contract: [contract],
+      ref_block_bytes: "",
+      ref_block_hash: "",
+      expiration: 0,
+    },
+    internal_transactions: [],
+    ...overrides,
+  };
+}
 
 describe("formatTrongridTrc20TxResponse", () => {
   it("should return correct TrongridTxInfo for Approval tx type", () => {
@@ -30,6 +67,7 @@ describe("formatTrongridTrc20TxResponse", () => {
       hasFailed: false,
       tokenType: "trc20",
       tokenAddress: "addr",
+      feesPayer: "from",
     });
   });
 
@@ -60,8 +98,269 @@ describe("formatTrongridTrc20TxResponse", () => {
       hasFailed: false,
       tokenType: "trc20",
       tokenAddress: "tokenId",
+      feesPayer: "from",
     });
   });
+
+  it("should fall back to contract_address when token_info.address is missing (unindexed LP contract)", () => {
+    const tx = {
+      from: "from",
+      to: "to",
+      block_timestamp: 1,
+      detail: {
+        ret: [{ fee: 0 }],
+        raw_data: {
+          contract: [
+            {
+              parameter: {
+                value: {
+                  owner_address: "41f1fe9d73ffb3b6ab532858b266c02f63410fbd70",
+                  // hex for TU1wcXoAq5EXhZp7ga6E1Vb1Sqw1ciQP4s (unindexed LP contract)
+                  contract_address: "41c5f6aa996edd0696a0295b07fd7b20b0dd84c557",
+                },
+              },
+            },
+          ],
+        },
+      },
+      value: "20000000000",
+      transaction_id: "txId",
+      token_info: {},
+      type: "Transfer",
+    };
+    const result = formatTrongridTrc20TxResponse(tx as unknown as Trc20API);
+    expect(result).toMatchObject({
+      type: "TriggerSmartContract",
+      tokenId: "TU1wcXoAq5EXhZp7ga6E1Vb1Sqw1ciQP4s",
+      tokenAddress: "TU1wcXoAq5EXhZp7ga6E1Vb1Sqw1ciQP4s",
+    });
+  });
+
+  it("should set feesPayer from owner_address when it differs from from (transferFrom case)", () => {
+    // owner_address is the Tron tx initiator (hex); `from` is the TRC20 token source (base58)
+    const tx = {
+      from: "TTokenSourceAddress",
+      to: "to",
+      block_timestamp: 1,
+      detail: {
+        ret: [{ fee: 1 }],
+        raw_data: {
+          contract: [
+            {
+              parameter: {
+                value: {
+                  // hex for TY2ksFgpvb82TgGPwUSa7iseqPW5weYQyh
+                  owner_address: "41f1fe9d73ffb3b6ab532858b266c02f63410fbd70",
+                },
+              },
+            },
+          ],
+        },
+      },
+      value: 100,
+      transaction_id: "txId",
+      token_info: { address: "tokenAddr" },
+      type: "Transfer",
+    };
+    const result = formatTrongridTrc20TxResponse(tx as unknown as Trc20API);
+    expect(result).toEqual({
+      txID: "txId",
+      date: new Date(1),
+      type: "TriggerSmartContract",
+      tokenId: "tokenAddr",
+      from: "TTokenSourceAddress",
+      to: "to",
+      blockHeight: undefined,
+      value: new BigNumber(100),
+      fee: new BigNumber(1),
+      hasFailed: false,
+      tokenType: "trc20",
+      tokenAddress: "tokenAddr",
+      feesPayer: "TY2ksFgpvb82TgGPwUSa7iseqPW5weYQyh",
+    });
+  });
+});
+
+describe("formatTrongridTxResponse", () => {
+  it("should return correct TrongridTxInfo for TransferContract", async () => {
+    const tx = baseTransactionTronApi({
+      type: "TransferContract",
+      parameter: {
+        type_url: "",
+        value: {
+          owner_address: ownerHex,
+          to_address: toHex,
+          amount: 1_000_000,
+        },
+      },
+    });
+    const result = await formatTrongridTxResponse(tx, () => Promise.resolve(null));
+    expect(result).toEqual({
+      txID: "txId",
+      date: new Date(1),
+      type: "TransferContract",
+      tokenId: undefined,
+      tokenType: undefined,
+      tokenAddress: undefined,
+      from: encode58Check(ownerHex),
+      to: encode58Check(toHex),
+      value: new BigNumber(1_000_000),
+      fee: new BigNumber(1000),
+      blockHeight: 42,
+      hasFailed: false,
+      feesPayer: encode58Check(ownerHex),
+    });
+  });
+
+  it("should set hasFailed when contract execution did not succeed", async () => {
+    const tx = baseTransactionTronApi(
+      {
+        type: "TransferContract",
+        parameter: {
+          type_url: "",
+          value: {
+            owner_address: ownerHex,
+            to_address: toHex,
+            amount: 100,
+          },
+        },
+      },
+      { ret: [{ contractRet: "REVERT", fee: 0 }] },
+    );
+    const result = await formatTrongridTxResponse(tx, () => Promise.resolve(null));
+    expect(result?.hasFailed).toBe(true);
+  });
+
+  it("should return correct TrongridTxInfo for TransferAssetContract", async () => {
+    const assetName = "10013004";
+    const tx = baseTransactionTronApi({
+      type: "TransferAssetContract",
+      parameter: {
+        type_url: "",
+        value: {
+          owner_address: ownerHex,
+          to_address: toHex,
+          amount: 100,
+          asset_name: assetName,
+        },
+      },
+    });
+    const result = await formatTrongridTxResponse(tx, () => Promise.resolve(null));
+    expect(result).toEqual({
+      txID: "txId",
+      date: new Date(1),
+      type: "TransferAssetContract",
+      tokenId: assetName,
+      tokenType: "trc10",
+      tokenAddress: undefined,
+      from: encode58Check(ownerHex),
+      to: encode58Check(toHex),
+      value: new BigNumber(100),
+      fee: new BigNumber(1000),
+      blockHeight: 42,
+      hasFailed: false,
+      feesPayer: encode58Check(ownerHex),
+    });
+  });
+
+  it("should return correct TrongridTxInfo for TriggerSmartContract", async () => {
+    const tx = baseTransactionTronApi({
+      type: "TriggerSmartContract",
+      parameter: {
+        type_url: "",
+        value: {
+          owner_address: ownerHex,
+          to_address: toHex,
+          contract_address: trc20ContractHex,
+          amount: 0,
+        },
+      },
+    });
+    const result = await formatTrongridTxResponse(tx, () => Promise.resolve(null));
+    expect(result).toEqual({
+      txID: "txId",
+      date: new Date(1),
+      type: "TriggerSmartContract",
+      tokenId: encode58Check(trc20ContractHex),
+      tokenType: "trc20",
+      tokenAddress: encode58Check(trc20ContractHex),
+      from: encode58Check(ownerHex),
+      to: encode58Check(toHex),
+      value: new BigNumber(0),
+      fee: new BigNumber(1000),
+      blockHeight: 42,
+      hasFailed: false,
+      feesPayer: encode58Check(ownerHex),
+    });
+  });
+
+  it("should map withdraw amount for WithdrawBalanceContract", async () => {
+    const tx = baseTransactionTronApi(
+      {
+        type: "WithdrawBalanceContract",
+        parameter: {
+          type_url: "",
+          value: {
+            owner_address: ownerHex,
+          },
+        },
+      },
+      { withdraw_amount: 5_000_000 },
+    );
+    const result = await formatTrongridTxResponse(tx, () => Promise.resolve(null));
+    expect(result?.value).toEqual(new BigNumber(5_000_000));
+  });
+
+  it("should map quant for ExchangeTransactionContract", async () => {
+    const tx = baseTransactionTronApi({
+      type: "ExchangeTransactionContract",
+      parameter: {
+        type_url: "",
+        value: {
+          owner_address: ownerHex,
+          quant: 777,
+        },
+      },
+    });
+    const result = await formatTrongridTxResponse(tx, () => Promise.resolve(null));
+    expect(result?.value).toEqual(new BigNumber(777));
+  });
+
+  it("should attach vote extra info using getValidatorName", async () => {
+    const voteAddressHex = "41b183301d6301fae224c6ab9b28b19b6d1625bf23";
+    const getValidatorName = jest
+      .fn()
+      .mockImplementation(async (address: string) =>
+        address === encode58Check(voteAddressHex) ? "SR-Name" : null,
+      );
+    const tx = baseTransactionTronApi({
+      type: "VoteWitnessContract",
+      parameter: {
+        type_url: "",
+        value: {
+          owner_address: ownerHex,
+          votes: [{ vote_address: voteAddressHex, vote_count: 3 }],
+        },
+      },
+    });
+    const result = await formatTrongridTxResponse(tx, getValidatorName);
+    expect(getValidatorName).toHaveBeenCalledWith(encode58Check(voteAddressHex));
+    expect(result?.extra).toEqual({
+      votes: [
+        {
+          name: "SR-Name",
+          address: encode58Check(voteAddressHex),
+          voteCount: 3,
+        },
+      ],
+    });
+  });
+
+  it("should return undefined when the transaction payload cannot be parsed", async () => {
+    const tx = { txID: "broken", block_timestamp: 1 } as TransactionTronAPI;
+    const result = await formatTrongridTxResponse(tx, () => Promise.resolve(null));
+    expect(result).toBeUndefined();
+  });
 });
 
 describe("decode58Check", () => {

package/src/network/format.ts

@@ -20,6 +20,11 @@ export const formatTrongridTrc20TxResponse = (tx: Trc20API): TrongridTxInfo | nu
     const bnFee = new BigNumber(fee || 0);
     let formattedValue;
 
+    // token_info.address is missing for unindexed contracts (e.g. LP/DEX pool tokens not in TronGrid registry)
+    // fall back to the contract_address from the raw transaction, which is always present
+    const contractAddressHex = detail.raw_data?.contract?.[0]?.parameter?.value?.contract_address;
+    const tokenAddress = token_info.address ?? (contractAddressHex ? encode58Check(contractAddressHex) : undefined);
+
     switch (type) {
       case "Approval":
         txType = "ContractApproval";
@@ -27,7 +32,7 @@ export const formatTrongridTrc20TxResponse = (tx: Trc20API): TrongridTxInfo | nu
         break;
       default:
         txType = "TriggerSmartContract";
-        tokenId = token_info.address ?? undefined;
+        tokenId = tokenAddress;
         formattedValue = value ? new BigNumber(value) : new BigNumber(0);
         break;
     }
@@ -35,12 +40,14 @@ export const formatTrongridTrc20TxResponse = (tx: Trc20API): TrongridTxInfo | nu
     const date = new Date(block_timestamp);
 
     const blockHeight = detail ? detail.blockNumber : undefined;
+    const ownerAddressHex = detail.raw_data?.contract?.[0]?.parameter?.value?.owner_address;
+    const feesPayer = ownerAddressHex ? encode58Check(ownerAddressHex) : from;
     return {
       txID,
       date,
       type: txType,
       tokenId: tokenId,
-      tokenAddress: token_info.address,
+      tokenAddress,
       tokenType: "trc20",
       from,
       to,
@@ -48,6 +55,7 @@ export const formatTrongridTrc20TxResponse = (tx: Trc20API): TrongridTxInfo | nu
       value: formattedValue,
       fee: bnFee,
       hasFailed: false, // trc20 txs are succeeded if returned by trongrid,
+      feesPayer,
     };
   } catch (e) {
     log("tron-error", `could not parse transaction ${tx}`);
@@ -55,9 +63,10 @@ export const formatTrongridTrc20TxResponse = (tx: Trc20API): TrongridTxInfo | nu
   }
 };
 
-export const formatTrongridTxResponse = (
+export const formatTrongridTxResponse = async (
   tx: TransactionTronAPI & { detail?: TronTransactionInfo },
-): TrongridTxInfo | null | undefined => {
+  getValidatorName: (address: string) => Promise<string | null | undefined>,
+): Promise<TrongridTxInfo | null | undefined> => {
   try {
     const { txID, block_timestamp, detail, blockNumber, unfreeze_amount, withdraw_amount } = tx;
     const date = new Date(block_timestamp);
@@ -118,16 +127,22 @@ export const formatTrongridTxResponse = (
       fee: new BigNumber(fee || 0),
       blockHeight,
       hasFailed,
+      feesPayer: from,
     };
 
-    const getExtra = (): TrongridExtraTxInfo | null | undefined => {
+    const getExtra = async (): Promise<TrongridExtraTxInfo | null | undefined> => {
       switch (type) {
         case "VoteWitnessContract":
           return {
-            votes: votes?.map(v => ({
-              address: encode58Check(v.vote_address as string),
-              voteCount: v.vote_count,
-            })),
+            votes:
+              votes &&
+              (await Promise.all(
+                votes.map(async v => ({
+                  name: await getValidatorName(encode58Check(v.vote_address)),
+                  address: encode58Check(v.vote_address),
+                  voteCount: v.vote_count,
+                })),
+              )),
           };
 
         case "FreezeBalanceContract":
@@ -157,7 +172,7 @@ export const formatTrongridTxResponse = (
       }
     };
 
-    const extra = getExtra();
+    const extra = await getExtra();
 
     if (extra) {
       txInfo.extra = extra;

package/src/network/index.ts

@@ -589,10 +589,12 @@ export async function fetchTronAccountTxsPage(
     ),
   ]);
 
-  const nativeTxsFormatted = nativeResult.results
-    .filter(isTransactionTronAPI)
-    .filter(isValidNativeTx)
-    .map(tx => formatTrongridTxResponse(tx));
+  const nativeTxsFormatted = await Promise.all(
+    nativeResult.results
+      .filter(isTransactionTronAPI)
+      .filter(isValidNativeTx)
+      .map(tx => formatTrongridTxResponse(tx, accountNamesCache)),
+  );
 
   const trc20TxsFormatted = compact(trc20Result.results.map(formatTrongridTrc20TxResponse));
   const trc20TxIds = new Set(trc20TxsFormatted.map(t => t.txID));
@@ -616,18 +618,20 @@ export async function fetchTronAccountTxs(
     ? Math.min(params.limitPerCall, params.hintGlobalLimit)
     : params.limitPerCall;
   const queryParams = `limit=${adjustedLimitPerCall}&min_timestamp=${params.minTimestamp}&order_by=block_timestamp,${params.order}`;
-  const nativeTxs = (
-    await getAllTransactions<
-      (TransactionTronAPI & { detail?: TronTransactionInfo }) | MalformedTransactionTronAPI
-    >(
-      `${getBaseApiUrl()}/v1/accounts/${addr}/transactions?${queryParams}`,
-      shouldFetchMoreTxs,
-      getTransactions(cacheTransactionInfoById),
+  const nativeTxs = await Promise.all(
+    (
+      await getAllTransactions<
+        (TransactionTronAPI & { detail?: TronTransactionInfo }) | MalformedTransactionTronAPI
+      >(
+        `${getBaseApiUrl()}/v1/accounts/${addr}/transactions?${queryParams}`,
+        shouldFetchMoreTxs,
+        getTransactions(cacheTransactionInfoById),
+      )
     )
-  )
-    .filter(isTransactionTronAPI)
-    .filter(isValidNativeTx)
-    .map(tx => formatTrongridTxResponse(tx));
+      .filter(isTransactionTronAPI)
+      .filter(isValidNativeTx)
+      .map(tx => formatTrongridTxResponse(tx, accountNamesCache)),
+  );
 
   // we need to fetch and filter trc20 transactions from another endpoint
   // doc https://developers.tron.network/reference/get-trc20-transaction-info-by-account-address
@@ -774,19 +778,12 @@ export const validateAddress = async (address: string): Promise<boolean> => {
 };
 
 // cache for account names (name is unchanged over time)
-const accountNamesCache = makeLRUCache(
+export const accountNamesCache = makeLRUCache(
   async (addr: string): Promise<string | null | undefined> => getAccountName(addr),
   (addr: string) => addr,
   hours(3, 300),
 );
 
-// cache for super representative brokerages (brokerage is unchanged over time)
-const srBrokeragesCache = makeLRUCache(
-  async (addr: string): Promise<number> => getBrokerage(addr),
-  (addr: string) => addr,
-  hours(3, 300),
-);
-
 export const getAccountName = async (addr: string): Promise<string | null | undefined> => {
   const tronAcc = await fetchTronAccount(addr);
   const acc = tronAcc[0];
@@ -797,13 +794,6 @@ export const getAccountName = async (addr: string): Promise<string | null | unde
   return accountName;
 };
 
-export const getBrokerage = async (addr: string): Promise<number> => {
-  const { brokerage } = await fetch(`/wallet/getBrokerage?address=${encodeURIComponent(addr)}`);
-  srBrokeragesCache.hydrate(addr, brokerage); // put it in cache
-
-  return brokerage;
-};
-
 const superRepresentativesCache = makeLRUCache(
   async (): Promise<SuperRepresentative[]> => {
     const superRepresentatives = await fetchSuperRepresentatives();
@@ -827,21 +817,14 @@ export const hydrateSuperRepresentatives = (list: SuperRepresentative[]) => {
 };
 
 const fetchSuperRepresentatives = async (): Promise<SuperRepresentative[]> => {
-  const result = await fetch(`/wallet/listwitnesses`);
-  const sorted = result.witnesses.sort((a: any, b: any) => b.voteCount - a.voteCount);
-  const superRepresentatives = await promiseAllBatched(3, sorted, async (w: any) => {
-    const encodedAddress = encode58Check(w.address);
-    const accountName = await accountNamesCache(encodedAddress);
-    const brokerage = await srBrokeragesCache(encodedAddress);
-    return {
-      ...w,
-      address: encodedAddress,
-      name: accountName,
-      brokerage,
-      voteCount: w.voteCount || 0,
-      isJobs: w.isJobs || false,
-    };
-  });
+  const result = await fetch<{ witnesses: SuperRepresentative[] }>(`/wallet/listwitnesses`);
+  const sorted = result.witnesses.sort((a, b) => b.voteCount - a.voteCount);
+  const superRepresentatives = sorted.map(w => ({
+    ...w,
+    address: encode58Check(w.address),
+    voteCount: w.voteCount || 0,
+    isJobs: w.isJobs || false,
+  }));
   hydrateSuperRepresentatives(superRepresentatives); // put it in cache
 
   return superRepresentatives;

package/src/network/trongrid/trongrid-adapters.test.ts

@@ -119,6 +119,19 @@ describe("fromTrongridTxInfoToOperation", () => {
     expect(result.type).toBe("UNKNOWN");
   });
 
+  it("should use feesPayer over from when set (transferFrom case)", () => {
+    const txInfo = {
+      ...mockTrongridTxInfo,
+      from: mockUserAddress, // TRC20 "from" — our address
+      feesPayer: "actualInitiator", // Tron owner_address — someone else called transferFrom
+    };
+
+    const result = fromTrongridTxInfoToOperation(txInfo, mockBlock, mockUserAddress);
+
+    expect(result.tx.feesPayer).toBe("actualInitiator");
+    expect(result.type).toBe("OUT"); // direction still uses `from`
+  });
+
   it("should handle missing fee or value gracefully", () => {
     const txInfo = {
       ...mockTrongridTxInfo,

package/src/network/trongrid/trongrid-adapters.ts

@@ -18,7 +18,7 @@ export function fromTrongridTxInfoToOperation(
         time: block.time || new Date(0),
       },
       fees: fromBigNumberToBigInt<bigint>(trongridTxInfo.fee, BigInt(0)),
-      feesPayer: trongridTxInfo.from,
+      feesPayer: trongridTxInfo.feesPayer ?? trongridTxInfo.from,
       date: trongridTxInfo.date,
       failed: trongridTxInfo.hasFailed,
     },

package/src/test/bridgeDatasetTest.ts

@@ -148,10 +148,12 @@ const tron: CurrenciesData<Transaction> = {
             resource: undefined,
             votes: [
               {
+                name: "Node 1",
                 address: "TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH",
                 voteCount: 1,
               },
               {
+                name: "Node 2",
                 address: "TGj1Ej1qRzL9feLTLhjwgxXF4Ct6GTWg2U",
                 voteCount: 1,
               },
@@ -643,6 +645,7 @@ const tron: CurrenciesData<Transaction> = {
             resource: undefined,
             votes: [
               {
+                name: "Node 1",
                 address: "abcde",
                 voteCount: 1,
               },
@@ -670,6 +673,7 @@ const tron: CurrenciesData<Transaction> = {
             resource: undefined,
             votes: [
               {
+                name: "Node 1",
                 address: "TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH",
                 voteCount: 0,
               },
@@ -697,10 +701,12 @@ const tron: CurrenciesData<Transaction> = {
             resource: undefined,
             votes: [
               {
+                name: "Node 1",
                 address: "TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH",
                 voteCount: 5,
               },
               {
+                name: "Node 2",
                 address: "TGj1Ej1qRzL9feLTLhjwgxXF4Ct6GTWg2U",
                 voteCount: 5,
               },
@@ -864,9 +870,21 @@ const tron: CurrenciesData<Transaction> = {
             energy: { amount: "26000000", expiredAt: "2020-02-01T16:04:51.000Z" },
           },
           votes: [
-            { address: "TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH", voteCount: 15 },
-            { address: "TGj1Ej1qRzL9feLTLhjwgxXF4Ct6GTWg2U", voteCount: 1 },
-            { address: "TCZvvbn4SCVyNhCAt1L8Kp1qk5rtMiKdBB", voteCount: 2 },
+            {
+              name: "Node 1",
+              address: "TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH",
+              voteCount: 15,
+            },
+            {
+              name: "Node 2",
+              address: "TGj1Ej1qRzL9feLTLhjwgxXF4Ct6GTWg2U",
+              voteCount: 1,
+            },
+            {
+              name: "Node 3",
+              address: "TCZvvbn4SCVyNhCAt1L8Kp1qk5rtMiKdBB",
+              voteCount: 2,
+            },
           ],
           tronPower: 26,
           energy: "326",

package/src/test/cli.ts

@@ -36,6 +36,12 @@ const options = [
     type: String,
     desc: "reward ENERGY or BANDWIDTH",
   },
+  {
+    name: "tronVoteName",
+    type: String,
+    multiple: true,
+    desc: "name of the super representative voting",
+  },
   {
     name: "tronVoteAddress",
     type: String,
@@ -111,12 +117,14 @@ function inferTransactions(
     invariant(["BANDWIDTH", "ENERGY"].includes(resource), `Unexpected resource: ${resource}`);
   }
 
+  const voteNames: string[] = opts["tronVoteName"] || [];
   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) => ({
+  const votes: Vote[] = zipWith(voteNames, voteAddresses, voteCounts, (n, a, c) => ({
+    name: n,
     address: a,
     voteCount: c,
   }));
@@ -148,12 +156,9 @@ 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 headerList = "address url voteCount isJobs";
     const strList = srData.list.map(
-      sr =>
-        `${sr.address} "${formatOptStr(sr.name)}" ${formatOptStr(sr.url)} ${sr.voteCount} ${
-          sr.brokerage
-        } ${sr.isJobs}`,
+      sr => `${sr.address} ${formatOptStr(sr.url)} ${sr.voteCount} ${sr.isJobs}`,
     );
     const metaData = [
       `nextVotingDate: ${srData.nextVotingDate}`,