feat: erc721 token support for evm coins

ticket: win-8154

Author: rohitsaw115

modules/bitgo/src/v2/coinFactory.ts

@@ -9,7 +9,8 @@ import { Near, TNear, Nep141Token } from '@bitgo/sdk-coin-near';
 import { SolToken } from '@bitgo/sdk-coin-sol';
 import { TrxToken } from '@bitgo/sdk-coin-trx';
 import { CoinFactory, CoinConstructor } from '@bitgo/sdk-core';
-import { EthLikeErc20Token } from '@bitgo/sdk-coin-evm';
+import { EthLikeErc20Token, EthLikeErc721Token } from '@bitgo/sdk-coin-evm';
+
 import {
   CoinMap,
   coins,
@@ -565,6 +566,20 @@ export function registerCoinConstructors(coinFactory: CoinFactory, coinMap: Coin
         coinFactory.register(name, coinConstructor);
       });
     });
+
+  // Generic ERC721 token registration for coins with SUPPORTS_ERC721 feature
+  coins
+    .filter((coin) => coin.features.includes(CoinFeature.SUPPORTS_ERC721) && !coin.isToken)
+    .forEach((coin) => {
+      const coinNames = {
+        Mainnet: `${coin.name}`,
+        Testnet: `t${coin.name}`,
+      };
+
+      EthLikeErc721Token.createTokenConstructors(coinNames).forEach(({ name, coinConstructor }) => {
+        coinFactory.register(name, coinConstructor);
+      });
+    });
 }
 
 export function getCoinConstructor(coinName: string): CoinConstructor | undefined {
@@ -926,8 +941,30 @@ export const buildEthLikeChainToTestnetMap = (): {
   return { mainnetToTestnetMap, testnetToMainnetMap };
 };
 
+const buildEthLikeErc721ChainToTestnetMap = (): {
+  mainnetToTestnetMapForErc721Tokens: Record<string, string>;
+  testnetToMainnetMapForErc721Tokens: Record<string, string>;
+} => {
+  const testnetToMainnetMapForErc721Tokens: Record<string, string> = {};
+  const mainnetToTestnetMapForErc721Tokens: Record<string, string> = {};
+
+  coins.forEach((coin) => {
+    if (coin.network.type === NetworkType.TESTNET && !coin.isToken) {
+      if (coins.get(coin.family)?.features.includes(CoinFeature.SUPPORTS_ERC721)) {
+        mainnetToTestnetMapForErc721Tokens[coin.family] = `${coin.name}`;
+        testnetToMainnetMapForErc721Tokens[coin.name] = `${coin.family}`;
+      }
+    }
+  });
+
+  return { mainnetToTestnetMapForErc721Tokens, testnetToMainnetMapForErc721Tokens };
+};
+
 const { mainnetToTestnetMap, testnetToMainnetMap } = buildEthLikeChainToTestnetMap();
 
+const { mainnetToTestnetMapForErc721Tokens, testnetToMainnetMapForErc721Tokens } =
+  buildEthLikeErc721ChainToTestnetMap();
+
 export function getTokenConstructor(tokenConfig: TokenConfig): CoinConstructor | undefined {
   const testnetCoin = mainnetToTestnetMap[tokenConfig.coin];
   if (testnetCoin) {
@@ -943,6 +980,21 @@ export function getTokenConstructor(tokenConfig: TokenConfig): CoinConstructor |
       Testnet: tokenConfig.coin,
     });
   }
+
+  if (mainnetToTestnetMapForErc721Tokens[tokenConfig.coin]) {
+    return EthLikeErc721Token.createTokenConstructor(tokenConfig as EthLikeTokenConfig, {
+      Mainnet: tokenConfig.coin,
+      Testnet: mainnetToTestnetMapForErc721Tokens[tokenConfig.coin],
+    });
+  }
+
+  if (testnetToMainnetMapForErc721Tokens[tokenConfig.coin]) {
+    return EthLikeErc721Token.createTokenConstructor(tokenConfig as EthLikeTokenConfig, {
+      Mainnet: testnetToMainnetMapForErc721Tokens[tokenConfig.coin],
+      Testnet: tokenConfig.coin,
+    });
+  }
+
   switch (tokenConfig.coin) {
     case 'eth':
     case 'hteth':

modules/bitgo/src/v2/coins/index.ts

@@ -31,7 +31,7 @@ import { Dot, Tdot } from '@bitgo/sdk-coin-dot';
 import { Eos, EosToken, Teos } from '@bitgo/sdk-coin-eos';
 import { Etc, Tetc } from '@bitgo/sdk-coin-etc';
 import { Erc20Token, Erc721Token, Eth, Gteth, Hteth, Teth } from '@bitgo/sdk-coin-eth';
-import { EvmCoin, EthLikeErc20Token } from '@bitgo/sdk-coin-evm';
+import { EvmCoin, EthLikeErc20Token, EthLikeErc721Token } from '@bitgo/sdk-coin-evm';
 import { Flr, Tflr, FlrToken } from '@bitgo/sdk-coin-flr';
 import { Flrp } from '@bitgo/sdk-coin-flrp';
 import { Ethw } from '@bitgo/sdk-coin-ethw';
@@ -109,7 +109,7 @@ export { Erc20Token, Erc721Token, Eth, Gteth, Hteth, Teth };
 export { Ethw };
 export { EthLikeCoin, TethLikeCoin };
 export { Etc, Tetc };
-export { EvmCoin, EthLikeErc20Token };
+export { EvmCoin, EthLikeErc20Token, EthLikeErc721Token };
 export { Flr, Tflr, FlrToken };
 export { Flrp };
 export { Hash, Thash, HashToken };

modules/bitgo/test/browser/browser.spec.ts

@@ -55,6 +55,7 @@ describe('Coins', () => {
       CosmosSharedCoin: 1,
       VetToken: 1,
       EthLikeErc20Token: 1,
+      EthLikeErc721Token: 1,
       HashToken: 1,
       FlrToken: 1,
       JettonToken: 1,

modules/sdk-coin-evm/src/ethLikeErc721Token.ts

@@ -0,0 +1,54 @@
+/**
+ * @prettier
+ */
+import { coins, EthLikeTokenConfig } from '@bitgo/statics';
+import { BitGoBase, CoinConstructor, common, MPCAlgorithm, NamedCoinConstructor } from '@bitgo/sdk-core';
+import { CoinNames, EthLikeToken, recoveryBlockchainExplorerQuery } from '@bitgo/abstract-eth';
+import { TransactionBuilder } from './lib';
+import assert from 'assert';
+
+export class EthLikeErc721Token extends EthLikeToken {
+  public readonly tokenConfig: EthLikeTokenConfig;
+  private readonly coinNames: CoinNames;
+
+  constructor(bitgo: BitGoBase, tokenConfig: EthLikeTokenConfig, coinNames: CoinNames) {
+    super(bitgo, tokenConfig, coinNames);
+    this.coinNames = coinNames;
+  }
+
+  static createTokenConstructor(config: EthLikeTokenConfig, coinNames: CoinNames): CoinConstructor {
+    return (bitgo: BitGoBase) => new this(bitgo, config, coinNames);
+  }
+
+  static createTokenConstructors(coinNames: CoinNames): NamedCoinConstructor[] {
+    return super.createTokenConstructors(coinNames);
+  }
+
+  protected getTransactionBuilder(): TransactionBuilder {
+    return new TransactionBuilder(coins.get(this.getBaseChain()));
+  }
+
+  getMPCAlgorithm(): MPCAlgorithm {
+    return 'ecdsa';
+  }
+
+  supportsTss(): boolean {
+    return true;
+  }
+
+  async recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>> {
+    const family = this.getFamily();
+    const evmConfig = common.Environments[this.bitgo.getEnv()].evm;
+    assert(
+      evmConfig && this.getFamily() in evmConfig,
+      `env config is missing for ${this.getFamily()} in ${this.bitgo.getEnv()}`
+    );
+    const explorerUrl = evmConfig[family].baseUrl;
+    const apiToken = evmConfig[family].apiToken;
+    return await recoveryBlockchainExplorerQuery(query, explorerUrl as string, apiToken);
+  }
+
+  getFullName(): string {
+    return 'ERC721 Token';
+  }
+}

modules/sdk-coin-evm/src/index.ts

@@ -2,3 +2,4 @@ export * from './evmCoin';
 export * from './lib';
 export * from './register';
 export * from './ethLikeErc20Token';
+export * from './ethLikeErc721Token';

modules/sdk-coin-evm/src/register.ts

@@ -2,6 +2,7 @@ import { BitGoBase } from '@bitgo/sdk-core';
 import { CoinFeature, coins, NetworkType } from '@bitgo/statics';
 import { EvmCoin } from './evmCoin';
 import { EthLikeErc20Token } from './ethLikeErc20Token';
+import { EthLikeErc721Token } from './ethLikeErc721Token';
 
 export const registerAll = (sdk: BitGoBase): void => {
   coins
@@ -35,5 +36,17 @@ export const register = (coinFamily: string, sdk: BitGoBase): void => {
           sdk.register(name, coinConstructor);
         });
       }
+
+      // Handle SUPPORTS_ERC721 registration
+      if (coinFeatures.includes(CoinFeature.SUPPORTS_ERC721)) {
+        const coinNames = {
+          Mainnet: `${coin.name}`,
+          Testnet: `${coin.name}`,
+        };
+
+        EthLikeErc721Token.createTokenConstructors(coinNames).forEach(({ name, coinConstructor }) => {
+          sdk.register(name, coinConstructor);
+        });
+      }
     });
 };

modules/statics/src/account.ts

@@ -90,6 +90,10 @@ export interface Erc20ConstructorOptions extends AccountConstructorOptions {
   contractAddress: string;
 }
 
+export interface Erc721ConstructorOptions extends AccountConstructorOptions {
+  contractAddress: string;
+}
+
 export interface NFTCollectionIdConstructorOptions extends AccountConstructorOptions {
   nftCollectionId: string;
 }
@@ -430,6 +434,12 @@ export class EthLikeERC20Token extends ContractAddressDefinedToken {
   }
 }
 
+export class EthLikeERC721Token extends ContractAddressDefinedToken {
+  constructor(options: Erc721ConstructorOptions) {
+    super(options);
+  }
+}
+
 /**
  * The AVAX C Chain network support tokens
  * AVAX C Chain Tokens are ERC20 coins
@@ -895,6 +905,51 @@ export function erc20Token(
   );
 }
 
+/**
+ * Factory function for erc721 token instances.
+ *
+ * @param id uuid v4
+ * @param name unique identifier of the token
+ * @param fullName Complete human-readable name of the token
+ * @param contractAddress Contract address of this token
+ * @param asset Asset which this token represents. This is the same for both mainnet and testnet variants of a coin.
+ * @param network network
+ * @param features Features of this coin. Defaults to the DEFAULT_FEATURES defined in `AccountCoin`
+ * @param prefix Optional token prefix
+ * @param suffix Optional token suffix
+ * @param primaryKeyCurve The elliptic curve for this chain/token
+ */
+export function erc721Token(
+  id: string,
+  name: string,
+  fullName: string,
+  contractAddress: string,
+  asset: UnderlyingAsset,
+  network: AccountNetwork,
+  features: CoinFeature[] = [...AccountCoin.DEFAULT_FEATURES, CoinFeature.EIP1559],
+  prefix = '',
+  suffix: string = name.toUpperCase(),
+  primaryKeyCurve: KeyCurve = KeyCurve.Secp256k1
+): Readonly<EthLikeERC721Token> {
+  return Object.freeze(
+    new EthLikeERC721Token({
+      id,
+      name,
+      fullName,
+      network,
+      contractAddress,
+      decimalPlaces: 0, // ERC721 tokens are non-divisible
+      asset,
+      features,
+      prefix,
+      suffix,
+      primaryKeyCurve,
+      isToken: true,
+      baseUnit: BaseUnit.ETH,
+    })
+  );
+}
+
 /**
  * Factory function for erc20 token instances.
  *

modules/statics/src/allCoinsAndTokens.ts

@@ -2136,7 +2136,7 @@ export const allCoinsAndTokens = [
     Networks.main.hederaEVM,
     8,
     UnderlyingAsset.HBAREVM,
-    BaseUnit.HBAR,
+    BaseUnit.ETH,
     [
       ...EVM_FEATURES,
       CoinFeature.SHARED_EVM_SIGNING,
@@ -2147,6 +2147,7 @@ export const allCoinsAndTokens = [
       CoinFeature.EVM_NON_BITGO_RECOVERY,
       CoinFeature.EVM_UNSIGNED_SWEEP_RECOVERY,
       CoinFeature.SUPPORTS_ERC20,
+      CoinFeature.SUPPORTS_ERC721,
     ]
   ),
   account(
@@ -2156,7 +2157,7 @@ export const allCoinsAndTokens = [
     Networks.test.hederaEVM,
     8,
     UnderlyingAsset.HBAREVM,
-    BaseUnit.HBAR,
+    BaseUnit.ETH,
     [
       ...EVM_FEATURES,
       CoinFeature.SHARED_EVM_SIGNING,
@@ -2166,6 +2167,7 @@ export const allCoinsAndTokens = [
       CoinFeature.EVM_COMPATIBLE_WP,
       CoinFeature.EVM_NON_BITGO_RECOVERY,
       CoinFeature.EVM_UNSIGNED_SWEEP_RECOVERY,
+      CoinFeature.SUPPORTS_ERC721,
     ]
   ),
   account(

modules/statics/src/base.ts

@@ -421,6 +421,11 @@ export enum CoinFeature {
    */
   SUPPORTS_ERC20 = 'supports-erc20-token',
 
+  /**
+   * This coin supports erc721 tokens
+   */
+  SUPPORTS_ERC721 = 'supports-erc721-token',
+
   /**
    * This coin is a Cosmos coin and should use shared Cosmos SDK module
    */

modules/statics/src/tokenConfig.ts

@@ -14,6 +14,7 @@ import {
   Erc20Coin,
   Erc721Coin,
   EthLikeERC20Token,
+  EthLikeERC721Token,
   FlrERC20Token,
   HederaToken,
   Nep141Token,
@@ -1088,6 +1089,43 @@ export const getFormattedEthLikeTokenConfig = (customCoinMap = coins): EthLikeTo
     return acc;
   }, []);
 
+function getEthLikeERC721TokenConfig(coin: EthLikeERC721Token): EthLikeTokenConfig {
+  return {
+    type: coin.name,
+    coin: coin.name.split(':')[0].toLowerCase(),
+    network: coin.network.type === NetworkType.MAINNET ? 'Mainnet' : 'Testnet',
+    name: coin.fullName,
+    tokenContractAddress: coin.contractAddress.toString().toLowerCase(),
+    decimalPlaces: coin.decimalPlaces,
+  };
+}
+
+const getFormattedEthLikeERC721Tokens = (customCoinMap = coins) =>
+  customCoinMap.reduce((acc: EthLikeTokenConfig[], coin) => {
+    if (coin instanceof EthLikeERC721Token) {
+      acc.push(getEthLikeERC721TokenConfig(coin));
+    }
+    return acc;
+  }, []);
+
+export const getEthLikeErc721Tokens = (network: 'Mainnet' | 'Testnet'): EthLikeTokenMap => {
+  const networkTokens = getFormattedEthLikeERC721Tokens().filter((token) => token.network === network);
+  const ethLikeTokenMap = {} as EthLikeTokenMap;
+
+  coins.forEach((coin) => {
+    if (coin instanceof AccountCoin && coin.features.includes(CoinFeature.SUPPORTS_ERC721)) {
+      const coinName = coin.family;
+      const coinNameForNetwork = network === 'Testnet' ? `t${coinName}` : coinName;
+
+      ethLikeTokenMap[coin.family] = {
+        tokens: networkTokens.filter((token) => token.coin === coinNameForNetwork),
+      };
+    }
+  });
+
+  return ethLikeTokenMap;
+};
+
 type EthLikeTokenMap = {
   [K in CoinFamily]: { tokens: EthLikeTokenConfig[] };
 };
@@ -1121,8 +1159,10 @@ export const getEthLikeTokens = (network: 'Mainnet' | 'Testnet'): EthLikeTokenMa
 const getFormattedTokensByNetwork = (network: 'Mainnet' | 'Testnet', coinMap: typeof coins) => {
   const networkType = network === 'Mainnet' ? NetworkType.MAINNET : NetworkType.TESTNET;
   const ethLikeTokenMap = getEthLikeTokens(network);
+  const ethLikeErc721TokenMap = getEthLikeErc721Tokens(network);
   return {
     ...ethLikeTokenMap,
+    ...ethLikeErc721TokenMap,
     eth: {
       tokens: getFormattedErc20Tokens(coinMap).filter((token) => token.network === network),
       nfts: getFormattedErc721Tokens(coinMap).filter((token) => token.network === network),
@@ -1387,6 +1427,8 @@ export function getFormattedTokenConfigForCoin(coin: Readonly<BaseCoin>): TokenC
     return getFlrTokenConfig(coin);
   } else if (coin instanceof EthLikeERC20Token) {
     return getEthLikeTokenConfig(coin);
+  } else if (coin instanceof EthLikeERC721Token) {
+    return getEthLikeERC721TokenConfig(coin);
   }
   return undefined;
 }