@bitpay-labs/bitcore-wallet-service 11.11.3 → 11.11.4

package/src/lib/chain/arc/index.ts

@@ -0,0 +1,95 @@
+import util from 'util';
+import { Constants, ethers } from '@bitpay-labs/crypto-wallet-core';
+import { ClientError } from '../../errors/clienterror';
+import { Errors } from '../../errors/errordefinitions';
+import { EthChain } from '../eth';
+import { ERC20Abi } from '../eth/abi-erc20';
+import type { TxProposal } from '../../model/txproposal';
+
+const usdcInterface = new ethers.Interface(ERC20Abi);
+
+export class ArcChain extends EthChain {
+  constructor() {
+    super();
+    this.chain = 'ARC';
+  }
+
+  private isUsdcTokenView(opts) {
+    return opts.tokenAddress?.toLowerCase() === Constants.ARC.USDC_CONTRACT_ADDRESS;
+  }
+
+  protected getAdditionalNativeAmount(txp: TxProposal): bigint {
+    if (txp.tokenAddress || txp.multisigContractAddress || txp.multiSendContractAddress) return 0n;
+
+    try {
+      return (txp.outputs || []).reduce((total, output, index) => {
+        if (output.toAddress?.toLowerCase() !== Constants.ARC.USDC_CONTRACT_ADDRESS) return total;
+        const data = index === 0 && txp.data ? txp.data : output.data;
+        if (!data || data === '0x') return total;
+        const call = usdcInterface.parseTransaction({ data });
+        let amount = 0n;
+        if (call?.name === 'transfer') {
+          amount = call.args[1];
+        } else if (call?.name === 'transferFrom' && call.args[0].toLowerCase() === txp.from?.toLowerCase()) {
+          amount = call.args[2];
+        }
+        // The ERC20 interface uses 6 decimals; the same native balance uses 18.
+        return total + amount * 10n ** 12n;
+      }, 0n);
+    } catch {
+      throw new ClientError('Invalid Arc USDC contract call data');
+    }
+  }
+
+  getWalletBalance(server, wallet, opts, cb) {
+    // Native USDC and its ERC-20 view share funds. A separate token balance would
+    // use different units and omit the native spend locked by pending proposals.
+    if (this.isUsdcTokenView(opts)) {
+      return cb(new ClientError('USDC is the native Arc balance; omit tokenAddress'));
+    }
+    return super.getWalletBalance(server, wallet, opts, cb);
+  }
+
+  getWalletSendMaxInfo(server, wallet, opts, cb) {
+    const onFee = (err, feePerKb?) => {
+      if (err) return cb(err);
+      feePerKb = Number(feePerKb);
+      if (!Number.isFinite(feePerKb) || feePerKb < Constants.ARC.MIN_GAS_PRICE) {
+        return cb(new ClientError('Arc gas price must be at least 20 gwei'));
+      }
+      return super.getWalletSendMaxInfo(server, wallet, { ...opts, feePerKb }, cb);
+    };
+    // Match the type-2 cap reserved when creating the proposal.
+    if (Number(opts.txType) === 2) {
+      return server.estimateFee({ network: wallet.network, chain: wallet.chain, txType: 2 })
+        .then(feePerKb => onFee(null, feePerKb), onFee);
+    }
+    return server._getFeePerKb(wallet, opts, onFee);
+  }
+
+  async getFee(server, wallet, opts) {
+    if (this.isUsdcTokenView(opts)) {
+      throw new ClientError('USDC is the native Arc asset; omit tokenAddress');
+    }
+    const fees = await super.getFee(server, wallet, opts);
+    const gasPrice = Number(Number(opts.txType) === 2 ? fees.maxGasFee : fees.gasPrice);
+    if (!Number.isFinite(gasPrice) || gasPrice < Constants.ARC.MIN_GAS_PRICE) {
+      throw new ClientError('Arc gas price must be at least 20 gwei');
+    }
+    // Reserve the fee actually encoded in the transaction, including type-2 caps.
+    const fee = gasPrice * fees.gasLimit;
+    if (opts.sendMax && Number(opts.txType) === 2) {
+      const balance = await util.promisify(server.getBalance).call(server, {});
+      if (balance.availableAmount <= fee) throw Errors.INSUFFICIENT_FUNDS_FOR_FEE;
+      opts.outputs[0].amount = balance.availableAmount - fee;
+    }
+    return { ...fees, fee };
+  }
+
+  checkDust(output, opts) {
+    if (!opts.tokenAddress && output.amount > 0 &&
+        output.toAddress.toLowerCase() === '0x0000000000000000000000000000000000000000') {
+      return new ClientError('Native USDC cannot be sent to the zero address on Arc');
+    }
+  }
+}

package/src/lib/chain/eth/index.ts

@@ -84,6 +84,10 @@ export class EthChain implements IChain {
     return true;
   }
 
+  protected getAdditionalNativeAmount(_txp: TxProposal): bigint {
+    return 0n;
+  }
+
   getWalletBalance(server, wallet, opts, cb) {
     const bc = server._getBlockchainExplorer(wallet.chain || wallet.coin, wallet.network);
 
@@ -106,18 +110,22 @@ export class EthChain implements IChain {
         let fees = 0n;
         let amounts = 0n;
 
-        txps.filter(txp => {
-          // Add gas used for tokens when getting native balance
-          if (!opts.tokenAddress) {
-            fees += txp.fee ? BigInt(txp.fee) : 0n;
-          }
-          // Filter tokens when getting native balance
-          if (txp.tokenAddress && !opts.tokenAddress) {
-            return false;
-          }
-          amounts += txp.amount ? BigInt(txp.amount) : 0n;
-          return true;
-        });
+        try {
+          txps.filter(txp => {
+            // Add gas used for tokens when getting native balance
+            if (!opts.tokenAddress) {
+              fees += txp.fee ? BigInt(txp.fee) : 0n;
+            }
+            // Filter tokens when getting native balance
+            if (txp.tokenAddress && !opts.tokenAddress) {
+              return false;
+            }
+            amounts += BigInt(txp.amount || 0) + this.getAdditionalNativeAmount(txp);
+            return true;
+          });
+        } catch (err) {
+          return cb(err);
+        }
 
         // TODO support big int
         const lockedSum = Number(amounts + fees) || 0;  // previously set to 0 if opts.multisigContractAddress
@@ -175,8 +183,15 @@ export class EthChain implements IChain {
   checkScriptOutput(_output) { }
 
   async getFee(server, wallet, opts) {
+    const { from, txType, priorityFeePercentile, gasLimitBuffer } = opts;
+    const { coin, network, chain } = wallet;
     const hasType2FeeOverride = opts.maxGasFee != null || opts.priorityGasFee != null;
     let { maxGasFee, priorityGasFee } = opts;
+    if (Number(txType) === 2 && !hasType2FeeOverride) {
+      maxGasFee = await server.estimateFee({ network, chain: chain || coin, txType: 2 });
+      priorityGasFee = await server.estimatePriorityFee({ network, chain: chain || coin, percentile: priorityFeePercentile || 15 });
+      maxGasFee = Math.max(maxGasFee, priorityGasFee);
+    }
     if (hasType2FeeOverride) {
       const chain = wallet.chain || wallet.coin;
       // Keep overrides consistent with CWC's chain-specific minimum priority fee.
@@ -185,8 +200,8 @@ export class EthChain implements IChain {
         throw new ClientError(`priorityGasFee must be at least ${minimum} wei for ${chain}`);
       }
     }
-    // Use the explicit rate for both construction and the fee reserved from the wallet balance.
-    const feeOpts = opts.gasPrice != null || hasType2FeeOverride
+    // Reserve the same rate used for construction, including the automatic type-2 fee cap.
+    const feeOpts = opts.gasPrice != null || maxGasFee != null
       ? { ...opts, feePerKb: opts.gasPrice ?? maxGasFee }
       : opts;
     // Fixed fees are converted to a gas price below, once the gas limits are known.
@@ -196,8 +211,6 @@ export class EthChain implements IChain {
       : await util.promisify(server._getFeePerKb).call(server, wallet, feeOpts);
     let feePerKb = inFeePerKb;
     let gasPrice = inFeePerKb;
-    const { from, txType, priorityFeePercentile, gasLimitBuffer } = opts;
-    const { coin, network, chain } = wallet;
     let inGasLimit = 0; // Per recepient gas limit
     let gasLimit = 0; // Gas limit for all recepients. used for contract interactions that rollup recepients
     let fee = 0;
@@ -297,9 +310,9 @@ export class EthChain implements IChain {
       fee += feePerKb * gasLimit;
       logger.info(`[${from}] Top level gas limit with buffer: ${gasLimit}`);
     }
-    if (Number(txType) === 2 && !hasType2FeeOverride) {
-      maxGasFee = await server.estimateFee({ network, chain: wallet.chain || coin, txType: 2 });
-      priorityGasFee = await server.estimatePriorityFee({ network, chain: wallet.chain || coin, percentile: priorityFeePercentile || 15 });
+    // BWC verifies an explicit feePerKb against the request, separately from the type-2 fee cap.
+    if (Number(txType) === 2 && Common.Utils.isNumber(opts.feePerKb)) {
+      feePerKb = opts.feePerKb;
     }
     return { feePerKb, gasPrice, gasLimit, maxGasFee, priorityGasFee, fee };
   }
@@ -482,10 +495,15 @@ export class EthChain implements IChain {
             "gasLimit":200000
         }]
         */
-        const txpTotalAmount =
-          (opts.multisigContractAddress || opts.tokenAddress) && txp.payProUrl
-            ? getInvoiceValue(txp)
-            : txp.getTotalAmountBigInt();
+        let txpTotalAmount;
+        try {
+          txpTotalAmount =
+            (opts.multisigContractAddress || opts.tokenAddress) && txp.payProUrl
+              ? getInvoiceValue(txp)
+              : txp.getTotalAmountBigInt() + this.getAdditionalNativeAmount(txp);
+        } catch (err) {
+          return cb(err);
+        }
 
         if (totalAmount < txpTotalAmount) {
           return cb(Errors.INSUFFICIENT_FUNDS);

package/src/lib/chain/index.ts

@@ -4,6 +4,7 @@ import { IWallet, TxProposal } from '../model';
 import { WalletService } from '../server';
 import logger from './../logger';
 import { ArbChain } from './arb';
+import { ArcChain } from './arc';
 import { BaseChain } from './base';
 import { BchChain } from './bch';
 import { BtcChain } from './btc';
@@ -24,6 +25,7 @@ const chains: { [chain: string]: IChain } = {
   ETH: new EthChain(),
   MATIC: new MaticChain(),
   ARB: new ArbChain(),
+  ARC: new ArcChain(),
   BASE: new BaseChain(),
   OP: new OpChain(),
   XRP: new XrpChain(),

package/src/lib/common/constants.ts

@@ -10,6 +10,7 @@ export const Constants = {
     ARB: 'arb',
     BASE: 'base',
     OP: 'op',
+    ARC: 'arc',
     XRP: 'xrp',
     DOGE: 'doge',
     LTC: 'ltc',
@@ -38,7 +39,8 @@ export const Constants = {
     EUROC: 'euroc',
     USDT: 'usdt',
     WETH: 'weth',
-    SOL: 'sol'
+    SOL: 'sol',
+    ARC: 'arc'
   },
 
   BITPAY_SUPPORTED_ETH_ERC20: {
@@ -60,6 +62,7 @@ export const Constants = {
 
   BITPAY_USD_STABLECOINS: {
     // used for rates
+    ARC: 'arc',
     USDC: 'usdc',
     PYUSD: 'pyusd',
     USDP: 'usdp',
@@ -88,6 +91,7 @@ export const Constants = {
     ARB: 'arb',
     BASE: 'base',
     OP: 'op',
+    ARC: 'arc',
   },
 
   EVM_CHAINS_WITH_ETH_GAS: {
@@ -112,6 +116,7 @@ export const Constants = {
     arb: ['livenet', 'sepolia', 'holesky', 'regtest'],
     base: ['livenet', 'sepolia', 'holesky', 'regtest'],
     op: ['livenet', 'sepolia', 'holesky', 'regtest'],
+    arc: ['livenet', 'testnet'],
     sol: ['livenet', 'testnet', 'devnet', 'regtest']
   } as { [chain: string]: Array<string> },
 
@@ -156,6 +161,9 @@ export const Constants = {
       mainnet: 'livenet',
       testnet: 'sepolia'
     },
+    arc: {
+      mainnet: 'livenet'
+    },
     sol: {
       mainnet: 'livenet',
       testnet: 'devnet'
@@ -200,6 +208,8 @@ export const Constants = {
   ARB_TOKEN_OPTS: CWC.Constants.ARB_TOKEN_OPTS,
   OP_TOKEN_OPTS: CWC.Constants.OP_TOKEN_OPTS,
   BASE_TOKEN_OPTS: CWC.Constants.BASE_TOKEN_OPTS,
+  ARC_TOKEN_OPTS: CWC.Constants.ARC_TOKEN_OPTS,
+  ARC: CWC.Constants.ARC,
   SOL_TOKEN_OPTS: CWC.Constants.SOL_TOKEN_OPTS,
 
   BITPAY_CONTRACTS: {
@@ -219,6 +229,7 @@ export const Constants = {
     bch: { testnet: 300, livenet: 0 },
     eth: { testnet: 300, livenet: 0 },
     matic: { testnet: 300, livenet: 12 }, // MATIC set to 12 because blocks normally occur every 1-2 seconds
+    arc: { testnet: 0, livenet: 0 },
     xrp: { testnet: 300, livenet: 0 },
     doge: { testnet: 300, livenet: 0 },
     ltc: { testnet: 300, livenet: 0 }

package/src/lib/common/defaults.ts

@@ -194,6 +194,34 @@ export const Defaults = {
         defaultValue: 2000000000
       }
     ],
+    // Fallbacks must meet Arc's testnet gas-price floor. Live estimates still take precedence.
+    arc: [
+      {
+        name: 'urgent',
+        nbBlocks: 1,
+        defaultValue: 20000000000
+      },
+      {
+        name: 'priority',
+        nbBlocks: 2,
+        defaultValue: 20000000000
+      },
+      {
+        name: 'normal',
+        nbBlocks: 3,
+        defaultValue: 20000000000
+      },
+      {
+        name: 'economy',
+        nbBlocks: 4,
+        defaultValue: 20000000000
+      },
+      {
+        name: 'superEconomy',
+        nbBlocks: 4,
+        defaultValue: 20000000000
+      }
+    ],
     xrp: [
       {
         name: 'normal',
@@ -362,6 +390,7 @@ export const Defaults = {
     arb: 1000000000000, // 50 Gwei,
     base: 1000000000000, // 50 Gwei,
     op: 1000000000000, // 50 Gwei,
+    arc: 1000000000000,
     xrp: 1000000000000,
     doge: 100000000 * 100,
     ltc: 10000 * 1000, // 10k sat/b
@@ -376,6 +405,7 @@ export const Defaults = {
     arb: 0,
     base: 0,
     op: 0,
+    arc: 0,
     xrp: 0,
     doge: 0,
     ltc: 0,
@@ -390,6 +420,7 @@ export const Defaults = {
     arb: 1 * 1e18, // 1 eth
     base: 1 * 1e18, // 1 eth
     op: 1 * 1e18, // 1 eth
+    arc: 1 * 1e18, // 1 USDC
     xrp: 1 * 1e6, // 1 xrp
     doge: 400 * 1e8,
     ltc: 0.05 * 1e8

package/src/lib/emailservice.ts

@@ -337,6 +337,7 @@ export class EmailService {
       bch: 'BCH',
       eth: 'ETH',
       matic: 'MATIC',
+      arc: 'USDC',
       xrp: 'XRP',
       doge: 'DOGE',
       ltc: 'LTC',
@@ -685,6 +686,7 @@ export class EmailService {
           arb: 'arbitrum-one',
           base: 'base',
           op: 'optimistic-ethereum',
+          arc: 'arc',
           sol: 'solana',
         };
 
@@ -739,4 +741,4 @@ export class EmailService {
       });
     });
   }
-}
+}

package/src/lib/errors/errordefinitions.ts

@@ -37,6 +37,8 @@ interface Errors<T> {
   // Solana Errors
   INSUFFICIENT_SOL_FEE: T;
   LOCKED_SOL_FEE: T;
+  INSUFFICIENT_ARC_FEE: T;
+  LOCKED_ARC_FEE: T;
   HISTORY_LIMIT_EXCEEDED: T;
   MAIN_ADDRESS_GAP_REACHED: T;
   MULTI_TX_UNSUPPORTED: T;
@@ -114,6 +116,8 @@ const errors: Errors<string> = {
   LOCKED_OP_FEE: 'Your linked OP wallet does not have enough ETH for fee',
   INSUFFICIENT_SOL_FEE: 'Your linked SOL wallet does not have enough SOL for fee',
   LOCKED_SOL_FEE: 'Your linked SOL wallet does not have enough SOL for fee',
+  INSUFFICIENT_ARC_FEE: 'Your linked ARC wallet does not have enough USDC for fee',
+  LOCKED_ARC_FEE: 'Your linked ARC wallet USDC is locked by pending spend proposals',
   INVALID_ADDRESS: 'Invalid address',
   INVALID_CHANGE_ADDRESS: 'Invalid change address',
   KEY_IN_COPAYER: 'Key already registered',

package/src/lib/model/preferences.ts

@@ -12,6 +12,7 @@ export interface IPreferences {
   opTokenAddresses?: string[];
   baseTokenAddresses?: string[];
   arbTokenAddresses?: string[];
+  arcTokenAddresses?: string[];
   solTokenAddresses?: string[];
   multisigMaticInfo: object[];
 }
@@ -29,6 +30,7 @@ export class Preferences {
   opTokenAddresses: string[];
   baseTokenAddresses: string[];
   arbTokenAddresses: string[];
+  arcTokenAddresses: string[];
   solTokenAddresses: string[];
   multisigMaticInfo: object[];
 
@@ -50,6 +52,7 @@ export class Preferences {
     x.opTokenAddresses = opts.opTokenAddresses;
     x.baseTokenAddresses = opts.baseTokenAddresses;
     x.arbTokenAddresses = opts.arbTokenAddresses;
+    x.arcTokenAddresses = opts.arcTokenAddresses;
     x.solTokenAddresses = opts.solTokenAddresses;
     x.multisigMaticInfo = opts.multisigMaticInfo;
     // you can't put useDust here since this is copayer's specific.
@@ -72,6 +75,7 @@ export class Preferences {
     x.opTokenAddresses = obj.opTokenAddresses;
     x.baseTokenAddresses = obj.baseTokenAddresses;
     x.arbTokenAddresses = obj.arbTokenAddresses;
+    x.arcTokenAddresses = obj.arcTokenAddresses;
     x.solTokenAddresses = obj.solTokenAddresses;
     x.multisigMaticInfo = obj.multisigMaticInfo;
     return x;

package/src/lib/model/wallet.ts

@@ -24,6 +24,7 @@ const Bitcore = {
   arb: BitcoreLib,
   base: BitcoreLib,
   op: BitcoreLib,
+  arc: BitcoreLib,
   xrp: BitcoreLib,
   doge: BitcoreLibDoge,
   ltc: BitcoreLibLtc,

package/src/lib/pushnotificationsservice.ts

@@ -474,6 +474,7 @@ export class PushNotificationsService {
       bch: 'BCH',
       eth: 'ETH',
       matic: 'MATIC',
+      arc: 'USDC',
       xrp: 'XRP',
       doge: 'DOGE',
       ltc: 'LTC',
@@ -748,6 +749,7 @@ export class PushNotificationsService {
           arb: 'arbitrum-one',
           base: 'base',
           op: 'optimistic-ethereum',
+          arc: 'arc',
           sol: 'solana',
         };
 

package/src/lib/routes/services.ts

@@ -461,7 +461,7 @@ export function registerServiceRoutes(router: express.Router, context: RouteCont
 
   router.post('/v1/service/transak/orderDetails', cors(transakCorsOptions), (req, res) => {
     respondWithAuthServer(req, res, context, server => {
-      return server.externalServices.transak.transakGetOrderDetails(req);
+      return server.externalServices.transak.transakGetOrderDetails(req, server.walletId);
     });
   });
 

package/src/lib/routes/walletdata.ts

@@ -125,11 +125,13 @@ export function registerWalletDataRoutes(router: express.Router, context: RouteC
       const opts: {
         feePerKb?: number;
         feeLevel?: number;
+        txType?: number;
         returnInputs?: boolean;
         excludeUnconfirmedUtxos?: boolean;
       } = {};
       if (query.feePerKb) opts.feePerKb = +query.feePerKb;
       if (query.feeLevel) opts.feeLevel = Number(query.feeLevel);
+      if (query.txType != null) opts.txType = Number(query.txType);
       if (query.excludeUnconfirmedUtxos == '1') opts.excludeUnconfirmedUtxos = true;
       if (query.returnInputs == '1') opts.returnInputs = true;
 

package/src/lib/server.ts

@@ -71,6 +71,7 @@ const Bitcore_ = {
   arb: Bitcore,
   base: Bitcore,
   op: Bitcore,
+  arc: Bitcore,
   xrp: Bitcore,
   doge: BitcoreDoge,
   ltc: BitcoreLtc,
@@ -187,7 +188,7 @@ export class WalletService implements IWalletService {
       sardine: new SardineService(),
       simplex: new SimplexService(),
       thorswap: new ThorswapService(),
-      transak: new TransakService(),
+      transak: new TransakService(this.storage, this.lock),
       coinGecko: new CoinGeckoService(this.storage),
     };
   }
@@ -1330,6 +1331,7 @@ export class WalletService implements IWalletService {
    * @param {string} opts.opTokenAddresses - Linked token addresses
    * @param {string} opts.baseTokenAddresses - Linked token addresses
    * @param {string} opts.arbTokenAddresses - Linked token addresses
+   * @param {string[]} opts.arcTokenAddresses - Linked Arc ERC20 token addresses
    * @param {string} opts.solTokenAddresses - Linked token addresses
    * @param {string} opts.multisigMaticInfo - Linked multisig eth wallet info
    *
@@ -1404,6 +1406,14 @@ export class WalletService implements IWalletService {
           return Array.isArray(value) && value.every(x => Validation.validateAddress('arb', 'mainnet', x));
         }
       },
+      {
+        name: 'arcTokenAddresses',
+        isValid(value) {
+          return Array.isArray(value) && value.every(address =>
+            Validation.validateAddress('arc', 'mainnet', address) &&
+            address.toLowerCase() !== Constants.ARC.USDC_CONTRACT_ADDRESS);
+        }
+      },
       {
         name: 'solTokenAddresses',
         isValid(value) {
@@ -1505,6 +1515,13 @@ export class WalletService implements IWalletService {
             preferences.arbTokenAddresses = _.uniq(oldPref.arbTokenAddresses.concat(opts.arbTokenAddresses));
           }
 
+          if (opts.arcTokenAddresses) {
+            oldPref = oldPref || {} as Preferences;
+            oldPref.arcTokenAddresses = oldPref.arcTokenAddresses || [];
+            preferences.arcTokenAddresses = _.uniq(oldPref.arcTokenAddresses.concat(opts.arcTokenAddresses)
+              .map(address => address.toLowerCase()));
+          }
+
           if (opts.solTokenAddresses) {
             oldPref = oldPref || {} as Preferences;
             oldPref.solTokenAddresses = oldPref.solTokenAddresses || [];
@@ -2502,7 +2519,8 @@ export class WalletService implements IWalletService {
               feePerKb: opts.feePerKb,
               excludeUnconfirmedUtxos: !!opts.excludeUnconfirmedUtxos,
               returnInputs: true,
-              numSignatures: opts.numSignatures
+              numSignatures: opts.numSignatures,
+              txType: opts.txType
             },
             (err, info) => {
               if (err) return next(err);

package/test/blockchainexplorer.test.ts

@@ -39,6 +39,13 @@ describe('BlockChain explorer', function() {
       exp2.should.respondTo('initSocket');
       exp2.should.respondTo('register');
       exp2.should.respondTo('addAddresses');
+
+      for (const [network, apiNetwork] of [['livenet', 'mainnet'], ['testnet', 'testnet']]) {
+        const opts = { coin: 'arc', network };
+        BlockChainExplorer(opts).baseUrl.should.equal(`https://api-eth.bitcore.io/api/ARC/${apiNetwork}`);
+        BlockChainExplorer({ ...opts, url: 'http://localhost:3000' })
+          .baseUrl.should.equal(`http://localhost:3000/api/ARC/${apiNetwork}`);
+      }
     });
     it('should fail on unsupported provider', function() {
       try {

package/test/expressapp.test.ts

@@ -737,6 +737,37 @@ describe('ExpressApp', function() {
         });
       });
 
+      describe('Transak routes', function() {
+        it('/v1/service/transak/orderDetails should check the order against the authenticated wallet', function(done) {
+          const transakGetOrderDetails = sinon.stub().resolves({ data: { status: 'COMPLETED' } });
+          const server = {
+            walletId: 'authenticatedWalletId',
+            externalServices: { transak: { transakGetOrderDetails } },
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstanceWithAuth').callsArgWith(1, null, server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/service/transak/orderDetails',
+              method: 'post',
+              json: { env: 'sandbox', orderId: 'order1', walletId: 'someOtherWalletId' },
+              headers: {
+                'x-identity': 'identity',
+                'x-signature': 'signature'
+              }
+            };
+            request(requestOptions, function(err, res, body) {
+              should.not.exist(err);
+              res.statusCode.should.equal(200);
+              body.data.status.should.equal('COMPLETED');
+              transakGetOrderDetails.calledOnce.should.equal(true);
+              transakGetOrderDetails.firstCall.args[1].should.equal('authenticatedWalletId');
+              done();
+            });
+          });
+        });
+      });
+
       describe('Moralis routes (wallet-authenticated or public)', function() {
         const whitelistedOrigin = 'https://whitelisted-dapp.example';
         let originalMoralisConfig;

package/test/integration/externalservices/coinGecko.test.ts

@@ -224,6 +224,37 @@ describe('CoinGecko integration', function() {
       should.exist(data);
     });
 
+    it('should use the Arc platform for token lists and contract lookups', async () => {
+      forceGlobalCacheMisses();
+      const tokenAddress = '0x3600000000000000000000000000000000000000';
+      const otherToken = { chainId: 5042, address: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        name: 'Arc Test Token', symbol: 'TEST', decimals: 6, logoURI: '' };
+      const tokenList = [{ chainId: 5042, address: tokenAddress, symbol: 'USDC', decimals: 6 }, otherToken];
+      fakeRequest = createCoinGeckoRequestStub({
+        onTokenList: platformId => {
+          platformId.should.equal('arc');
+          return { tokens: tokenList };
+        },
+        onCoinContract: (platformId, address) => {
+          platformId.should.equal('arc');
+          address.should.equal(tokenAddress);
+          return { id: 'usd-coin', symbol: 'usdc', asset_platform_id: 'arc' };
+        },
+        onMarketChart: id => {
+          id.should.equal('usd-coin');
+          return { prices: [[1, 1]] };
+        }
+      });
+      cg().request = fakeRequest;
+
+      const tokens = await getTokens({ params: { chain: 'arc' } });
+      tokens.should.deep.equal([otherToken]);
+      cg().storage.checkAndUseGlobalCache.onSecondCall().callsFake((_key, _duration, cb) => cb(null, tokenList, null));
+      (await getTokens({ params: { chain: 'arc' } })).should.deep.equal([otherToken]);
+      const rates = await getFiatRates({ coin: 'USDC', chain: 'arc', tokenAddress });
+      rates.should.deep.equal([{ ts: 1, rate: 1 }]);
+    });
+
     it('should map chain aliases to the correct token list platform', async () => {
       forceGlobalCacheMisses();
 
@@ -315,6 +346,15 @@ describe('CoinGecko integration', function() {
       data[0].low52w.should.equal(90);
     });
 
+    it('should resolve native Arc market stats and fiat rates to USDC', async () => {
+      const getSpy = sandbox.spy(fakeRequest, 'get');
+      await getMarketStats({ coin: 'arc' });
+      parseRequestedIdsFromMarketsUrl(getSpy.firstCall.args[0]).should.deep.equal(['usd-coin']);
+
+      await getFiatRates({ coin: 'arc' });
+      matchCoinIdFromMarketChartUrl(getSpy.lastCall.args[0]).should.equal('usd-coin');
+    });
+
     it('should reject non-default coin symbols without tokenAddress', async () => {
       try {
         await getMarketStats({ coin: 'WBTC' });
@@ -829,7 +869,7 @@ describe('CoinGecko integration', function() {
       should.exist(data);
       Object.keys(data)
         .sort()
-        .should.deep.equal(['bch', 'btc', 'doge', 'eth', 'ltc', 'pol', 'sol', 'xrp']);
+        .should.deep.equal(['arc', 'bch', 'btc', 'doge', 'eth', 'ltc', 'pol', 'sol', 'xrp']);
     });
 
     it('should reject overly long coin symbols', async () => {
@@ -922,7 +962,7 @@ describe('CoinGecko integration', function() {
       should.exist(data);
       Object.keys(data)
         .sort()
-        .should.deep.equal(['bch', 'btc', 'doge', 'eth', 'ltc', 'pol', 'sol', 'xrp']);
+        .should.deep.equal(['arc', 'bch', 'btc', 'doge', 'eth', 'ltc', 'pol', 'sol', 'xrp']);
 
       data.btc.should.deep.equal([
         { ts: 1, rate: 100 },