Merge pull request #399 from ensdomains/feat/unnamed-evm-coins

feat: support unknown evm chains

Author: TateB

src/async.test.ts

@@ -27,13 +27,23 @@ test("evm coin name", async () => {
   expect(coder.coinType).toBe(2147483658);
   expect(coder.name).toBe("op");
   expect(coder.evmChainId).toBe(10);
+  expect("isUnknownChain" in coder).toBeFalse();
 });
 
 test("evm coin type", async () => {
   const coder = await getCoderByCoinTypeAsync(2147483658);
   expect(coder.coinType).toBe(2147483658);
   expect(coder.name).toBe("op");
   expect(coder.evmChainId).toBe(10);
+  expect(coder.isUnknownChain).toBeFalse();
+});
+
+test("unknown evm coin type", async () => {
+  const coder = await getCoderByCoinTypeAsync(2147483659);
+  expect(coder.coinType).toBe(2147483659);
+  expect(coder.name).toBe("Unknown Chain (11)");
+  expect(coder.evmChainId).toBe(11);
+  expect(coder.isUnknownChain).toBeTrue();
 });
 
 const nonEvmCoinNames = Object.keys(nonEvmCoinNameToTypeMap);

src/async.ts

@@ -46,24 +46,24 @@ export const getCoderByCoinTypeAsync = async <
   const names =
     coinTypeToNameMap[String(coinType) as keyof typeof coinTypeToNameMap];
 
-  if (!names) throw new Error(`Unsupported coin type: ${coinType}`);
-
-  const [name] = names;
-
   if (coinType >= SLIP44_MSB) {
     // EVM coin
     const evmChainId = coinTypeToEvmChainId(coinType);
+    const isUnknownChain = !names;
+    const name = isUnknownChain ? `Unknown Chain (${evmChainId})` : names[0];
     return {
       name,
       coinType: coinType as EvmCoinType,
       evmChainId,
+      isUnknownChain,
       encode: eth.encode,
       decode: eth.decode,
     } as GetCoderByCoinType<TCoinType>;
   }
-  const mod = await import(`./coin/${name}`);
 
+  if (!names) throw new Error(`Unsupported coin type: ${coinType}`);
+  const [name] = names;
+  const mod = await import(`./coin/${name}`);
   if (!mod) throw new Error(`Failed to load coin: ${name}`);
-
   return mod[name];
 };

src/index.test.ts

@@ -31,6 +31,7 @@ test("evm coin name", () => {
   expect(coder.coinType).toBe(2147483658);
   expect(coder.name).toBe("op");
   expect(coder.evmChainId).toBe(10);
+  expect("isUnknownChain" in coder).toBeFalse();
   expect(coder.encode).toBeFunction();
   expect(coder.decode).toBeFunction();
 });
@@ -40,6 +41,17 @@ test("evm coin type", () => {
   expect(coder.coinType).toBe(2147483658);
   expect(coder.name).toBe("op");
   expect(coder.evmChainId).toBe(10);
+  expect(coder.isUnknownChain).toBeFalse();
+  expect(coder.encode).toBeFunction();
+  expect(coder.decode).toBeFunction();
+});
+
+test("unknown evm coin type", () => {
+  const coder = getCoderByCoinType(2147483659);
+  expect(coder.coinType).toBe(2147483659);
+  expect(coder.name).toBe("Unknown Chain (11)");
+  expect(coder.evmChainId).toBe(11);
+  expect(coder.isUnknownChain).toBeTrue();
   expect(coder.encode).toBeFunction();
   expect(coder.decode).toBeFunction();
 });

src/index.ts

@@ -72,22 +72,28 @@ export const getCoderByCoinType = <
 ): GetCoderByCoinType<TCoinType> => {
   const names =
     coinTypeToNameMap[String(coinType) as keyof typeof coinTypeToNameMap];
-  if (!names) {
-    throw new Error(`Unsupported coin type: ${coinType}`);
-  }
-  const [name] = names;
+  // https://docs.ens.domains/ens-improvement-proposals/ensip-11-evmchain-address-resolution
+
   if (coinType >= SLIP44_MSB) {
     // EVM coin
     const evmChainId = coinTypeToEvmChainId(coinType);
+    const isUnknownChain = !names;
+    const name = isUnknownChain ? `Unknown Chain (${evmChainId})` : names[0]; // name is derivable
     const ethFormat = formats["eth"];
     return {
       name,
       coinType: coinType as EvmCoinType,
       evmChainId,
+      isUnknownChain,
       encode: ethFormat.encode,
       decode: ethFormat.decode,
     } as GetCoderByCoinType<TCoinType>;
   }
+
+  if (!names) {
+    throw new Error(`Unsupported coin type: ${coinType}`);
+  }
+  const [name] = names;
   const format = formats[name as keyof typeof formats];
   return format as GetCoderByCoinType<TCoinType>;
 };

src/types.ts

@@ -1,4 +1,4 @@
-import type { Subtract } from "ts-arithmetic";
+import type { GtOrEq, Subtract } from "ts-arithmetic";
 import type * as formats from "./coins.js";
 import type {
   coinNameToTypeMap,
@@ -20,13 +20,15 @@ type NonEvmCoinTypeToFormat = {
 };
 export type CoinTypeToFormatMap = {
   [key in CoinType]: key extends EvmCoinType
-    ? Prettify<GetEvmCoin<CoinTypeToNameMap[`${key}`][0]>>
+    ? Prettify<GetEvmCoin<key>>
     : key extends keyof NonEvmCoinTypeToFormat
     ? NonEvmCoinTypeToFormat[key]
     : never;
 };
 export type CoinNameToFormatMap = {
-  [key in CoinName]: CoinTypeToFormatMap[CoinNameToTypeMap[key]];
+  [key in CoinName]: Prettify<
+    Omit<CoinTypeToFormatMap[CoinNameToTypeMap[key]], "isUnknownChain">
+  >;
 };
 
 export type EvmCoinMap = typeof evmCoinNameToTypeMap;
@@ -35,12 +37,16 @@ export type EvmCoinType = EvmCoinMap[EvmCoinName];
 export type EvmChainId = Subtract<EvmCoinType, typeof SLIP44_MSB>;
 
 export type GetEvmCoin<
-  TEvmName extends EvmCoinName,
-  TCoinType extends CoinNameToTypeMap[TEvmName] = CoinNameToTypeMap[TEvmName]
+  TCoinType extends number,
+  TChainId extends number = Subtract<TCoinType, typeof SLIP44_MSB>,
+  TCoinName extends string = TCoinType extends EvmCoinType
+    ? CoinTypeToNameMap[`${TCoinType}`][0]
+    : `Unknown Chain (${TChainId})`
 > = {
-  name: TEvmName;
+  name: TCoinName;
   coinType: TCoinType;
-  evmChainId: Subtract<TCoinType, typeof SLIP44_MSB>;
+  evmChainId: TChainId;
+  isUnknownChain: TCoinType extends EvmCoinType ? false : true;
   encode: EncoderFunction;
   decode: DecoderFunction;
 };
@@ -52,6 +58,7 @@ export type CoinParameters = {
   name: string;
   coinType: number;
   evmChainId?: number;
+  isUnknownChain?: boolean;
 };
 
 export type CoinCoder = {
@@ -72,7 +79,11 @@ export type GetCoderByCoinName<TCoinName extends CoinName | string> =
   TCoinName extends CoinName ? CoinNameToFormatMap[TCoinName] : Coin;
 
 export type GetCoderByCoinType<TCoinType extends CoinType | number> =
-  TCoinType extends CoinType ? CoinTypeToFormatMap[TCoinType] : Coin;
+  TCoinType extends CoinType
+    ? CoinTypeToFormatMap[TCoinType]
+    : GtOrEq<TCoinType, typeof SLIP44_MSB> extends 1
+    ? Prettify<GetEvmCoin<TCoinType>>
+    : Coin;
 
 export type ParseInt<T> = T extends `${infer N extends number}` ? N : never;
 

src/utils/evm.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import {
+  coinTypeToEvmChainId,
+  evmChainIdToCoinType,
+  isEvmCoinType,
+} from "./evm.js";
+
+describe("isEvmCoinType()", () => {
+  test("non evm coin type", () => {
+    expect(isEvmCoinType(1000)).toBeFalse();
+  });
+  test("evm coin type", () => {
+    expect(isEvmCoinType(2147483658)).toBeTrue();
+  });
+});
+
+describe("evmChainIdToCoinType()", () => {
+  test("normal chainId", () => {
+    expect(evmChainIdToCoinType(10)).toBe(2147483658);
+  });
+  test("chainId too large", () => {
+    expect(() => evmChainIdToCoinType(2147483648)).toThrow("Invalid chainId");
+  });
+});
+
+describe("coinTypeToEvmChainId()", () => {
+  test("non evm coin type", () => {
+    expect(() => coinTypeToEvmChainId(1000)).toThrow(
+      "Coin type is not an EVM chain"
+    );
+  });
+  test("evm coin type", () => {
+    expect(coinTypeToEvmChainId(2147483658)).toBe(10);
+  });
+});

src/utils/evm.ts

@@ -1,8 +1,20 @@
-import type { Add, Lt, Subtract } from "ts-arithmetic";
+import type { Add, GtOrEq, Lt, Subtract } from "ts-arithmetic";
 import type { EvmChainId, EvmCoinType } from "../types.js";
 
 export const SLIP44_MSB = 0x80000000;
 
+export const isEvmCoinType = <
+  TCoinType extends EvmCoinType | number = EvmCoinType | number
+>(
+  coinType: TCoinType
+) =>
+  ((coinType & SLIP44_MSB) !== 0) as GtOrEq<
+    TCoinType,
+    typeof SLIP44_MSB
+  > extends 1
+    ? true
+    : false;
+
 type EvmChainIdToCoinType<
   TChainId extends EvmChainId | number = EvmChainId | number
 > = Lt<TChainId, typeof SLIP44_MSB> extends 1

src/utils/index.ts

@@ -41,6 +41,7 @@ export {
   SLIP44_MSB,
   coinTypeToEvmChainId,
   evmChainIdToCoinType,
+  isEvmCoinType,
 } from "./evm.js";
 export { validateFlowAddress } from "./flow.js";
 export { decodeLeb128, encodeLeb128 } from "./leb128.js";