chore: order families alphabetically

packages/core/src/families/common.ts

@@ -6,24 +6,22 @@ export const schemaTransactionCommon = z.object({
 });
 
 export const FAMILIES = [
-  "bitcoin",
-  "ethereum",
   "algorand",
-  "crypto_org",
-  "ripple",
-  "cosmos",
-  "ripple",
+  "bitcoin",
   "celo",
   "cosmos",
-  "hedera",
+  "crypto_org",
+  "elrond",
+  "ethereum",
   "filecoin",
-  "tezos",
+  "hedera",
+  "near",
+  "neo",
   "polkadot",
+  "ripple",
   "stellar",
+  "tezos",
   "tron",
-  "near",
-  "neo",
-  "elrond",
 ] as const;
 
 export const schemaFamilies = z.enum(FAMILIES);

packages/core/src/families/elrond/types.ts

@@ -14,8 +14,8 @@ export type ElrondTransactionMode =
 export interface ElrondTransaction extends TransactionCommon {
   readonly family: RawElrondTransaction["family"];
   mode: ElrondTransactionMode;
-  data?: Buffer;
   fees: BigNumber | null | undefined;
+  data?: Buffer;
   gasLimit: BigNumber;
 }
 

packages/core/src/families/index.ts

@@ -3,17 +3,17 @@ export * from "./bitcoin/types";
 export * from "./celo/types";
 export * from "./cosmos/types";
 export * from "./crypto_org/types";
+export * from "./elrond/types";
 export * from "./ethereum/types";
-export * from "./hedera/types";
 export * from "./filecoin/types";
+export * from "./hedera/types";
 export * from "./near/types";
 export * from "./neo/types";
 export * from "./polkadot/types";
 export * from "./ripple/types";
 export * from "./stellar/types";
 export * from "./tezos/types";
 export * from "./tron/types";
-export * from "./elrond/types";
 export * from "./common";
 export * from "./serializer";
 export * from "./types";

packages/core/src/families/serializer.ts

@@ -18,19 +18,23 @@ import {
   deserializeCryptoOrgTransaction,
   serializeCryptoOrgTransaction,
 } from "./crypto_org/serializer";
+import {
+  deserializeElrondTransaction,
+  serializeElrondTransaction,
+} from "./elrond/serializer";
 import {
   deserializeEthereumTransaction,
   serializeEthereumTransaction,
 } from "./ethereum/serializer";
-import * as near from "./near/serializer";
-import {
-  deserializeHederaTransaction,
-  serializeHederaTransaction,
-} from "./hedera/serializer";
 import {
   deserializeFilecoinTransaction,
   serializeFilecoinTransaction,
 } from "./filecoin/serializer";
+import {
+  deserializeHederaTransaction,
+  serializeHederaTransaction,
+} from "./hedera/serializer";
+import * as near from "./near/serializer";
 import * as neo from "./neo/serializer";
 import {
   deserializePolkadotTransaction,
@@ -52,10 +56,6 @@ import {
   deserializeTronTransaction,
   serializeTronTransaction,
 } from "./tron/serializer";
-import {
-  deserializeElrondTransaction,
-  serializeElrondTransaction,
-} from "./elrond/serializer";
 
 import type { RawTransaction, Transaction } from "./types";
 
@@ -68,38 +68,38 @@ import type { RawTransaction, Transaction } from "./types";
  */
 export function serializeTransaction(transaction: Transaction): RawTransaction {
   switch (transaction.family) {
-    case "ethereum":
-      return serializeEthereumTransaction(transaction);
-    case "bitcoin":
-      return serializeBitcoinTransaction(transaction);
     case "algorand":
       return serializeAlgorandTransaction(transaction);
-    case "crypto_org":
-      return serializeCryptoOrgTransaction(transaction);
-    case "ripple":
-      return serializeRippleTransaction(transaction);
+    case "bitcoin":
+      return serializeBitcoinTransaction(transaction);
     case "celo":
       return serializeCeloTransaction(transaction);
     case "cosmos":
       return serializeCosmosTransaction(transaction);
-    case "hedera":
-      return serializeHederaTransaction(transaction);
+    case "crypto_org":
+      return serializeCryptoOrgTransaction(transaction);
+    case "elrond":
+      return serializeElrondTransaction(transaction);
+    case "ethereum":
+      return serializeEthereumTransaction(transaction);
     case "filecoin":
       return serializeFilecoinTransaction(transaction);
-    case "tezos":
-      return serializeTezosTransaction(transaction);
+    case "hedera":
+      return serializeHederaTransaction(transaction);
+    case "near":
+      return near.serialize(transaction);
+    case "neo":
+      return neo.serialize(transaction);
     case "polkadot":
       return serializePolkadotTransaction(transaction);
+    case "ripple":
+      return serializeRippleTransaction(transaction);
     case "stellar":
       return serializeStellarTransaction(transaction);
+    case "tezos":
+      return serializeTezosTransaction(transaction);
     case "tron":
       return serializeTronTransaction(transaction);
-    case "near":
-      return near.serialize(transaction);
-    case "neo":
-      return neo.serialize(transaction);
-    case "elrond":
-      return serializeElrondTransaction(transaction);
     default: {
       const exhaustiveCheck: never = transaction; // https://www.typescriptlang.org/docs/handbook/2/narrowing.html#exhaustiveness-checking
       return exhaustiveCheck;
@@ -119,38 +119,38 @@ export function deserializeTransaction(
   rawTransaction: RawTransaction
 ): Transaction {
   switch (rawTransaction.family) {
-    case "ethereum":
-      return deserializeEthereumTransaction(rawTransaction);
-    case "bitcoin":
-      return deserializeBitcoinTransaction(rawTransaction);
     case "algorand":
       return deserializeAlgorandTransaction(rawTransaction);
-    case "crypto_org":
-      return deserializeCryptoOrgTransaction(rawTransaction);
-    case "ripple":
-      return deserializeRippleTransaction(rawTransaction);
+    case "bitcoin":
+      return deserializeBitcoinTransaction(rawTransaction);
     case "celo":
       return deserializeCeloTransaction(rawTransaction);
     case "cosmos":
       return deserializeCosmosTransaction(rawTransaction);
-    case "hedera":
-      return deserializeHederaTransaction(rawTransaction);
+    case "crypto_org":
+      return deserializeCryptoOrgTransaction(rawTransaction);
+    case "elrond":
+      return deserializeElrondTransaction(rawTransaction);
+    case "ethereum":
+      return deserializeEthereumTransaction(rawTransaction);
     case "filecoin":
       return deserializeFilecoinTransaction(rawTransaction);
-    case "tezos":
-      return deserializeTezosTransaction(rawTransaction);
+    case "hedera":
+      return deserializeHederaTransaction(rawTransaction);
+    case "near":
+      return near.deserialize(rawTransaction);
+    case "neo":
+      return neo.deserialize(rawTransaction);
     case "polkadot":
       return deserializePolkadotTransaction(rawTransaction);
+    case "ripple":
+      return deserializeRippleTransaction(rawTransaction);
     case "stellar":
       return deserializeStellarTransaction(rawTransaction);
+    case "tezos":
+      return deserializeTezosTransaction(rawTransaction);
     case "tron":
       return deserializeTronTransaction(rawTransaction);
-    case "near":
-      return near.deserialize(rawTransaction);
-    case "neo":
-      return neo.deserialize(rawTransaction);
-    case "elrond":
-      return deserializeElrondTransaction(rawTransaction);
     default: {
       const exhaustiveCheck: never = rawTransaction; // https://www.typescriptlang.org/docs/handbook/2/narrowing.html#exhaustiveness-checking
       return exhaustiveCheck;

packages/core/src/families/types.ts

@@ -1,23 +1,23 @@
 import type BigNumber from "bignumber.js";
 import type { z } from "zod";
+import type { schemaFamilies } from "./common";
+import type { schemaRawTransaction } from "./validation";
 import type { AlgorandTransaction } from "./algorand/types";
 import type { BitcoinTransaction } from "./bitcoin/types";
-import type { schemaFamilies } from "./common";
 import type { CeloTransaction } from "./celo/types";
 import type { CosmosTransaction } from "./cosmos/types";
 import type { CryptoOrgTransaction } from "./crypto_org/types";
+import type { ElrondTransaction } from "./elrond/types";
 import type { EthereumTransaction } from "./ethereum/types";
-import type { HederaTransaction } from "./hedera/types";
 import type { FilecoinTransaction } from "./filecoin/types";
+import type { HederaTransaction } from "./hedera/types";
 import type { NearTransaction } from "./near/types";
 import type { NeoTransaction } from "./neo/types";
 import type { PolkadotTransaction } from "./polkadot/types";
 import type { RippleTransaction } from "./ripple/types";
 import type { StellarTransaction } from "./stellar/types";
 import type { TezosTransaction } from "./tezos/types";
 import type { TronTransaction } from "./tron/types";
-import type { ElrondTransaction } from "./elrond/types";
-import type { schemaRawTransaction } from "./validation";
 
 /**
  * Supported coin families
@@ -60,19 +60,19 @@ export type RawTransaction = z.infer<typeof schemaRawTransaction>;
  * them to the network upon user validation.
  */
 export type Transaction =
-  | EthereumTransaction
-  | BitcoinTransaction
   | AlgorandTransaction
-  | CryptoOrgTransaction
-  | HederaTransaction
-  | FilecoinTransaction
-  | RippleTransaction
+  | BitcoinTransaction
   | CeloTransaction
   | CosmosTransaction
-  | TezosTransaction
-  | PolkadotTransaction
-  | StellarTransaction
-  | TronTransaction
+  | CryptoOrgTransaction
+  | ElrondTransaction
+  | EthereumTransaction
+  | FilecoinTransaction
+  | HederaTransaction
   | NearTransaction
   | NeoTransaction
-  | ElrondTransaction;
+  | PolkadotTransaction
+  | RippleTransaction
+  | StellarTransaction
+  | TezosTransaction
+  | TronTransaction;

packages/core/src/families/validation.ts

@@ -4,33 +4,33 @@ import { schemaRawBitcoinTransaction } from "./bitcoin/validation";
 import { schemaRawCeloTransaction } from "./celo/validation";
 import { schemaRawCosmosTransaction } from "./cosmos/validation";
 import { schemaRawCryptoOrgTransaction } from "./crypto_org/validation";
+import { schemaRawElrondTransaction } from "./elrond/validation";
 import { schemaRawEthereumTransaction } from "./ethereum/validation";
+import { schemaRawFilecoinTransaction } from "./filecoin/validation";
+import { schemaRawHederaTransaction } from "./hedera/validation";
 import { schemaRawNearTransaction } from "./near/validation";
 import { schemaRawNeoTransaction } from "./neo/validation";
 import { schemaRawPolkadotTransaction } from "./polkadot/validation";
 import { schemaRawRippleTransaction } from "./ripple/validation";
 import { schemaRawStellarTransaction } from "./stellar/validation";
 import { schemaRawTezosTransaction } from "./tezos/validation";
 import { schemaRawTronTransaction } from "./tron/validation";
-import { schemaRawHederaTransaction } from "./hedera/validation";
-import { schemaRawFilecoinTransaction } from "./filecoin/validation";
-import { schemaRawElrondTransaction } from "./elrond/validation";
 
 export const schemaRawTransaction = z.discriminatedUnion("family", [
   schemaRawAlgorandTransaction,
   schemaRawBitcoinTransaction,
   schemaRawCeloTransaction,
   schemaRawCosmosTransaction,
   schemaRawCryptoOrgTransaction,
+  schemaRawElrondTransaction,
   schemaRawEthereumTransaction,
-  schemaRawHederaTransaction,
   schemaRawFilecoinTransaction,
+  schemaRawHederaTransaction,
   schemaRawNearTransaction,
   schemaRawNeoTransaction,
   schemaRawPolkadotTransaction,
   schemaRawRippleTransaction,
   schemaRawStellarTransaction,
   schemaRawTezosTransaction,
   schemaRawTronTransaction,
-  schemaRawElrondTransaction,
 ]);