Merge pull request #4395 from BitGo/WIN-2643-fix-op-transfers

fix(abstract-eth): fix opeth:op transfers

modules/abstract-eth/src/abstractEthLikeNewCoins.ts

@@ -1730,7 +1730,11 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
     const transferBuilder = txBuilder.transfer() as TransferBuilder;
 
     const network = this.getNetwork();
-    const token = getToken(params.tokenContractAddress as string, network as EthLikeNetwork)?.name as string;
+    const token = getToken(
+      params.tokenContractAddress as string,
+      network as EthLikeNetwork,
+      this.staticsCoin?.family as string
+    )?.name as string;
 
     transferBuilder
       .coin(token)

modules/abstract-eth/src/lib/transaction.ts

@@ -101,7 +101,7 @@ export class Transaction extends BaseTransaction {
       const { to, amount, tokenContractAddress, signature } = decodeTransferData(txData.data);
       let coinName: string;
       if (tokenContractAddress) {
-        const token = getToken(tokenContractAddress, this._coinConfig.network);
+        const token = getToken(tokenContractAddress, this._coinConfig.network, this._coinConfig.family);
         coinName = token ? token.name : UNSUPPORTED_COIN_NAME;
       } else {
         coinName = this._coinConfig.name;

modules/abstract-eth/src/lib/utils.ts

@@ -638,13 +638,23 @@ export function getBufferedByteCode(methodId: string, rawData: string): Buffer {
  * Get the statics coin object matching a given contract address if it exists
  *
  * @param tokenContractAddress The contract address to match against
+ * @param network - the coin network
+ * @param family - the coin family
  * @returns statics BaseCoin object for the matching token
  */
-export function getToken(tokenContractAddress: string, network: BaseNetwork): Readonly<BaseCoin> | undefined {
+export function getToken(
+  tokenContractAddress: string,
+  network: BaseNetwork,
+  family: string
+): Readonly<BaseCoin> | undefined {
+  // filter the coins array to find the token with the matching contract address, network and coin family
+  // coin family is needed to avoid causing issues when a token has same contract address on two different chains
   const tokens = coins.filter((coin) => {
     if (coin instanceof ContractAddressDefinedToken) {
       return (
-        coin.network.type === network.type && coin.contractAddress.toLowerCase() === tokenContractAddress.toLowerCase()
+        coin.network.type === network.type &&
+        coin.family === family &&
+        coin.contractAddress.toLowerCase() === tokenContractAddress.toLowerCase()
       );
     }
     return false;

modules/sdk-coin-opeth/test/unit/opethToken.ts

@@ -1,19 +1,24 @@
 import 'should';
-
+import assert from 'assert';
 import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';
-import { register } from '../../src';
 import { BitGoAPI } from '@bitgo/sdk-api';
+import { getToken } from '@bitgo/abstract-eth';
+
+import { register } from '../../src';
 
 describe('Opeth Token:', function () {
   let bitgo: TestBitGoAPI;
   let opethTokenCoin;
+  let opTokenCoin;
   const tokenName = 'topeth:terc18dp';
+  const opToken = 'opeth:op';
 
   before(function () {
     bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });
     register(bitgo);
     bitgo.initializeTestVars();
     opethTokenCoin = bitgo.coin(tokenName);
+    opTokenCoin = bitgo.coin(opToken);
   });
 
   it('should return constants', function () {
@@ -32,4 +37,14 @@ describe('Opeth Token:', function () {
     const tokencoinBycontractAddress = bitgo.coin(opethTokenCoin.tokenContractAddress);
     opethTokenCoin.should.deepEqual(tokencoinBycontractAddress);
   });
+
+  it('should return only one token for optimism token contract address', function () {
+    const token = getToken(
+      '0x4200000000000000000000000000000000000042',
+      opTokenCoin.getNetwork(),
+      opTokenCoin.getFamily()
+    );
+    assert(token);
+    token.name.should.equal('opeth:op');
+  });
 });