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

package/package.json

@@ -2,7 +2,7 @@
   "name": "@bitpay-labs/bitcore-wallet-service",
   "description": "A service for Mutisig HD Bitcoin Wallets",
   "author": "BitPay Inc",
-  "version": "11.11.2",
+  "version": "11.11.4",
   "license": "MIT",
   "main": "ts_build/src/index.js",
   "types": "./ts_build/src/index.d.ts",
@@ -42,8 +42,8 @@
   },
   "dependencies": {
     "@bitpay-labs/bitcore-logging": "^11.11.2",
-    "@bitpay-labs/bitcore-tss": "^11.11.2",
-    "@bitpay-labs/crypto-wallet-core": "^11.11.2",
+    "@bitpay-labs/bitcore-tss": "^11.11.4",
+    "@bitpay-labs/crypto-wallet-core": "^11.11.4",
     "@sendgrid/mail": "6.5.4",
     "abi-decoder": "2.4.0",
     "async": "0.9.2",
@@ -107,5 +107,5 @@
       "email": "kjoseph@bitpay.com"
     }
   ],
-  "gitHead": "1a044f2c984f6856f569981eebd91b051ab130d8"
+  "gitHead": "1eb34cc33d0628f9304be08a19da5315f140e70f"
 }

package/src/config.ts

@@ -130,6 +130,14 @@ const Config = (): any => {
           url: 'https://api-eth.bitcore.io'
         }
       },
+      arc: {
+        livenet: {
+          url: 'https://api-eth.bitcore.io'
+        },
+        testnet: {
+          url: 'https://api-eth.bitcore.io'
+        }
+      },
       sol: {
         livenet: {
           url: 'https://api-sol.bitcore.io'

package/src/externalservices/coingecko.ts

@@ -64,6 +64,7 @@ const DEFAULT_COINS: Record<string, string> = {
   pol: 'polygon-ecosystem-token',
   sol: 'solana',
   xrp: 'ripple',
+  arc: 'usd-coin',
 };
 
 const DEFAULT_COIN_ENTRIES = Object.entries(DEFAULT_COINS);
@@ -79,6 +80,7 @@ const CHAIN_ALIASES = {
 } as const satisfies Record<string, BitPayTokenChain>;
 
 const COINGECKO_PLATFORM_ID_BY_CHAIN = {
+  [Constants.EVM_CHAINS.ARC]: 'arc',
   [Constants.EVM_CHAINS.ARB]: 'arbitrum-one',
   [Constants.EVM_CHAINS.BASE]: 'base',
   [Constants.EVM_CHAINS.ETH]: 'ethereum',
@@ -527,7 +529,7 @@ export class CoinGeckoService {
 
     const cacheKey = `cgTokenList:${platformId}`;
 
-    return this.withGlobalCache(cacheKey, Defaults.COIN_GECKO_CACHE_DURATION, async () => {
+    const tokenList = await this.withGlobalCache(cacheKey, Defaults.COIN_GECKO_CACHE_DURATION, async () => {
       const { API_KEY } = this.coinGeckoGetCredentials();
       const headers = this.coinGeckoGetHeaders(API_KEY);
 
@@ -543,5 +545,8 @@ export class CoinGeckoService {
         return { ...t, logoURI };
       });
     });
+    return platformId === 'arc'
+      ? tokenList.filter(token => token?.address?.toLowerCase() !== Constants.ARC.USDC_CONTRACT_ADDRESS)
+      : tokenList;
   }
 }

package/src/externalservices/transak.ts

@@ -1,12 +1,106 @@
+import * as crypto from 'crypto';
+import { Web3 } from '@bitpay-labs/crypto-wallet-core';
 import * as request from 'request';
 import config from '../config';
 import { Utils } from '../lib/common/utils';
 import { ClientError } from '../lib/errors/clienterror';
+import { Lock } from '../lib/lock';
 import logger from '../lib/logger';
 import { checkRequired } from '../lib/server';
+import { Storage } from '../lib/storage';
+
+interface TransakKeys {
+  ENV: string;
+  API: string;
+  API_KEY: string;
+  SECRET_KEY: string;
+  WIDGET_API: string;
+}
+
+interface TransakPartnerToken {
+  accessToken: string;
+  /** Unix epoch in milliseconds */
+  expiresAt: number;
+  /** Unix epoch in milliseconds */
+  fetchedAt: number;
+}
+
+// The partner access token from /partners/api/v2/refresh-token is scoped to
+// BitPay's whole Transak account (it can read every order), so it must never
+// leave BWS. It is cached in the shared global cache so every BWS instance
+// reuses one token until it nears expiry, as Transak requires.
+const PARTNER_TOKEN_CACHE_PREFIX = 'transakPartnerToken:';
+const PARTNER_TOKEN_CACHE_MAX_AGE = 7 * 24 * 60 * 60 * 1000;
+const PARTNER_TOKEN_REFRESH_BUFFER = 10 * 60 * 1000;
+// Used if Transak omits expiresAt or returns one that is already (nearly) past.
+const PARTNER_TOKEN_FALLBACK_TTL = 60 * 60 * 1000;
+// If Transak rejects a token fetched less than this long ago, the rejection
+// isn't about token age, so don't refresh again.
+const PARTNER_TOKEN_MIN_FORCED_REFRESH_AGE = 60 * 1000;
+// Statuses that mean Transak rejected the token itself.
+const PARTNER_TOKEN_REJECTED_STATUSES = [401, 403];
+// If a refresh can't happen, keep serving the current token until this close
+// to its real expiry.
+const PARTNER_TOKEN_EXPIRY_MARGIN = 30 * 1000;
+const PARTNER_TOKEN_REQUEST_TIMEOUT = 10 * 1000;
+// Lock time is well above the request timeout so a holder never outlives its
+// lock (Lock.release is not owner-checked).
+const PARTNER_TOKEN_LOCK_TIME = 30 * 1000;
+const PARTNER_TOKEN_LOCK_WAIT = 15 * 1000;
+// After a failed refresh, don't retry for this long (shared across instances),
+// so an outage or disabled key doesn't turn every checkout into a refresh call.
+const PARTNER_TOKEN_FAILURE_PREFIX = 'transakPartnerTokenFailure:';
+const PARTNER_TOKEN_FAILURE_BACKOFF = 30 * 1000;
+
+// App builds and the bitpay.com widget still call getAccessToken and refuse to
+// continue without a non-empty accessToken and an integer expiresAt (seconds).
+// They get this placeholder; BWS ignores whatever token a client sends back.
+const CLIENT_TOKEN_PLACEHOLDER = 'server-managed';
+// Short so a rollback (or old pods during a rolling deploy) only sees the
+// placeholder briefly; getAccessToken no longer calls Transak, so it's cheap.
+const CLIENT_TOKEN_PLACEHOLDER_TTL = 2 * 60; // seconds
+
+// Only these client fields are forwarded to Transak's front-end widget.
+const WIDGET_PARAMS = [
+  'walletAddress',
+  'disableWalletAddressForm',
+  'redirectURL',
+  'exchangeScreenTitle',
+  'fiatAmount',
+  'fiatCurrency',
+  'network',
+  'defaultNetwork',
+  'cryptoCurrencyCode',
+  'cryptoCurrencyList',
+  'hideExchangeScreen',
+  'themeColor',
+  'hideMenu',
+  'partnerOrderId',
+  'partnerCustomerId',
+  'paymentMethod',
+  'defaultPaymentMethod',
+];
+
+const ORDER_ID_PATTERN = /^[A-Za-z0-9-]{1,64}$/;
+
+// Transak's error message, if any, for logs. Never the whole body.
+function transakErrorDetail(data): string {
+  const message = data?.body?.error?.message ?? data?.body?.message;
+  if (message == null) return '';
+  const text = typeof message === 'string' ? message : JSON.stringify(message);
+  return ` (${text.slice(0, 200)})`;
+}
 
 export class TransakService {
   request: any = request;
+  storage: Storage;
+  lock: Lock;
+  partnerTokenLockWait = PARTNER_TOKEN_LOCK_WAIT;
+
+  constructor(storage: Storage, lock?: Lock) {
+    this.storage = storage;
+    this.lock = lock ?? new Lock(storage);
+  }
 
   private transakGetKeys(req, cleanBody: boolean = true) {
     if (!config.transak) throw new Error('Transak missing credentials');
@@ -22,12 +116,8 @@ export class TransakService {
       delete req.body.context;
     }
 
-    const keys: {
-      API: string;
-      API_KEY: string;
-      SECRET_KEY: string;
-      WIDGET_API: string;
-    } = {
+    const keys: TransakKeys = {
+      ENV: env,
       API: config.transak[env].api,
       API_KEY: config.transak[env].apiKey,
       SECRET_KEY: config.transak[env].secretKey,
@@ -55,15 +145,94 @@ export class TransakService {
     return userIp || '';
   }
 
-  transakGetAccessToken(req): Promise<any> {
-    return new Promise((resolve, reject) => {
-      const userIp = this.transakGetUserIp(req);
-      let keys;
-      try {
-        keys = this.transakGetKeys(req);
-      } catch (err) {
-        return reject(err);
+  /**
+   * Kept for clients that still fetch a token before checkout. Returns a
+   * placeholder in the shape they expect; the real partner token stays in BWS.
+   */
+  async transakGetAccessToken(req): Promise<{ data: { accessToken: string; expiresAt: number } }> {
+    this.transakGetKeys(req);
+    return {
+      data: {
+        accessToken: CLIENT_TOKEN_PLACEHOLDER,
+        expiresAt: Math.floor(Date.now() / 1000) + CLIENT_TOKEN_PLACEHOLDER_TTL
       }
+    };
+  }
+
+  /**
+   * Cache/lock id for a partner token. Includes a hash of the API key so a
+   * rotated key never reuses a token minted for the old one.
+   */
+  private partnerTokenId(keys: TransakKeys): string {
+    const keyHash = crypto.createHash('sha256').update(String(keys.API_KEY)).digest('hex').slice(0, 12);
+    return `${keys.ENV}:${keyHash}`;
+  }
+
+  private readCachedPartnerToken(id: string): Promise<TransakPartnerToken | null> {
+    return new Promise(resolve => {
+      this.storage.checkAndUseGlobalCache(PARTNER_TOKEN_CACHE_PREFIX + id, PARTNER_TOKEN_CACHE_MAX_AGE, (err, values) => {
+        if (err) {
+          logger.warn(`Transak partner token cache read failed: ${err.message || err}`);
+          return resolve(null);
+        }
+        return resolve(values?.accessToken ? values : null);
+      });
+    });
+  }
+
+  private storeCachedPartnerToken(id: string, token: TransakPartnerToken): Promise<void> {
+    return new Promise(resolve => {
+      this.storage.storeGlobalCache(PARTNER_TOKEN_CACHE_PREFIX + id, token, err => {
+        if (err) logger.warn(`Transak partner token cache write failed: ${err.message || err}`);
+        return resolve();
+      });
+    });
+  }
+
+  private recentRefreshFailed(id: string): Promise<boolean> {
+    return new Promise(resolve => {
+      this.storage.checkAndUseGlobalCache(PARTNER_TOKEN_FAILURE_PREFIX + id, PARTNER_TOKEN_FAILURE_BACKOFF, (err, values) => {
+        return resolve(!err && !!values);
+      });
+    });
+  }
+
+  private markRefreshFailed(id: string): Promise<void> {
+    return new Promise(resolve => {
+      this.storage.storeGlobalCache(PARTNER_TOKEN_FAILURE_PREFIX + id, { failedAt: Date.now() }, () => resolve());
+    });
+  }
+
+  private acquirePartnerTokenLock(id: string): Promise<((cb?: () => void) => void) | null> {
+    return new Promise(resolve => {
+      this.lock.acquire(
+        PARTNER_TOKEN_CACHE_PREFIX + id,
+        { lockTime: PARTNER_TOKEN_LOCK_TIME, waitTime: this.partnerTokenLockWait },
+        (err, release) => {
+          if (err) {
+            logger.warn(`Transak partner token lock not acquired: ${err.message || err}`);
+            return resolve(null);
+          }
+          return resolve(release);
+        }
+      );
+    });
+  }
+
+  private isUsablePartnerToken(token: TransakPartnerToken | null, staleToken?: string): boolean {
+    return !!token?.accessToken
+      && token.accessToken !== staleToken
+      && token.expiresAt - PARTNER_TOKEN_REFRESH_BUFFER > Date.now();
+  }
+
+  private isUnexpiredPartnerToken(token: TransakPartnerToken | null, staleToken?: string): boolean {
+    return !!token?.accessToken
+      && token.accessToken !== staleToken
+      && token.expiresAt - PARTNER_TOKEN_EXPIRY_MARGIN > Date.now();
+  }
+
+  private fetchPartnerToken(keys: TransakKeys, userIp: string): Promise<TransakPartnerToken> {
+    return new Promise((resolve, reject) => {
       const API = keys.API;
       const API_KEY = keys.API_KEY;
       const SECRET_KEY = keys.SECRET_KEY;
@@ -86,27 +255,166 @@ export class TransakService {
         {
           headers,
           body,
-          json: true
+          json: true,
+          timeout: PARTNER_TOKEN_REQUEST_TIMEOUT
         },
         (err, data) => {
           if (err) {
             logger.error(`Transak request failed with error (${URL}): ${err.stack || err}`);
             return reject(new ClientError('Failed to get Transak access token'));
-          } else {
-            const success = data.statusCode >= 200 && data.statusCode < 300;
-            if (!success) {
-              logger.warn(`Transak request failed with status code ${data.statusCode}: ${URL}`);
-            }
-            if (!data.body) {
-              return reject(new ClientError('Transak did not return an access token'));
-            }
-            return resolve(data.body);
           }
+          const success = data.statusCode >= 200 && data.statusCode < 300;
+          const accessToken = data.body?.data?.accessToken;
+          if (!success || !accessToken || typeof accessToken !== 'string') {
+            logger.warn(`Transak request failed with status code ${data.statusCode}: ${URL}${transakErrorDetail(data)}`);
+            return reject(new ClientError('Transak did not return an access token'));
+          }
+
+          // Transak returns expiresAt in seconds; accept milliseconds too. If it
+          // is missing or already inside the refresh buffer (e.g. a duration
+          // instead of a timestamp), use a fallback TTL rather than treating the
+          // token as expired and refreshing on every request.
+          const now = Date.now();
+          const rawExpiresAt = Number(data.body.data.expiresAt);
+          let expiresAt = rawExpiresAt < 1e12 ? rawExpiresAt * 1000 : rawExpiresAt;
+          if (!Number.isFinite(expiresAt) || expiresAt - PARTNER_TOKEN_REFRESH_BUFFER <= now) {
+            logger.warn(`Transak returned an unusable access token expiresAt (${data.body.data.expiresAt}); using fallback TTL`);
+            expiresAt = now + PARTNER_TOKEN_FALLBACK_TTL;
+          }
+          return resolve({ accessToken, expiresAt, fetchedAt: now });
         }
       );
     });
   }
 
+  /**
+   * Returns the cached partner token if usable, or null if a refresh is
+   * needed. Throws if a refresh must not happen right now.
+   */
+  private async checkPartnerTokenCache(id: string, staleToken?: string): Promise<string | null> {
+    const cached = await this.readCachedPartnerToken(id);
+    if (this.isUsablePartnerToken(cached, staleToken)) return cached.accessToken;
+
+    if (staleToken && cached?.accessToken === staleToken
+      && Date.now() - (cached.fetchedAt || 0) < PARTNER_TOKEN_MIN_FORCED_REFRESH_AGE) {
+      throw new ClientError('Transak rejected the access token');
+    }
+    if (await this.recentRefreshFailed(id)) {
+      throw new ClientError('Failed to get Transak access token');
+    }
+    return null;
+  }
+
+  /**
+   * Returns the cached partner access token, refreshing it at most once across
+   * all BWS instances when it is missing, near expiry, or equal to staleToken
+   * (a token Transak just rejected).
+   */
+  private async getPartnerToken(keys: TransakKeys, userIp: string, staleToken?: string): Promise<string> {
+    const id = this.partnerTokenId(keys);
+
+    const cached = await this.readCachedPartnerToken(id);
+    if (this.isUsablePartnerToken(cached, staleToken)) return cached.accessToken;
+
+    try {
+      return await this.refreshPartnerToken(keys, userIp, id, staleToken);
+    } catch (err) {
+      // The refresh buffer is proactive. If the refresh can't happen right now
+      // (backoff, lock timeout, Transak error), keep serving the current token
+      // while Transak would still accept it.
+      const current = await this.readCachedPartnerToken(id);
+      if (this.isUnexpiredPartnerToken(current, staleToken)) {
+        logger.warn(`Transak partner token refresh unavailable; using current token: ${err?.message || err}`);
+        return current.accessToken;
+      }
+      throw err;
+    }
+  }
+
+  private async refreshPartnerToken(keys: TransakKeys, userIp: string, id: string, staleToken?: string): Promise<string> {
+    const cached = await this.checkPartnerTokenCache(id, staleToken);
+    if (cached) return cached;
+
+    const release = await this.acquirePartnerTokenLock(id);
+    if (!release) {
+      // Never refresh without the lock: if the holder is slow, every waiter
+      // would time out together and refresh at once.
+      const afterWait = await this.readCachedPartnerToken(id);
+      if (this.isUsablePartnerToken(afterWait, staleToken)) return afterWait.accessToken;
+      throw new ClientError('Failed to get Transak access token');
+    }
+
+    try {
+      // Another instance may have refreshed (or failed) while we waited.
+      const recheck = await this.checkPartnerTokenCache(id, staleToken);
+      if (recheck) return recheck;
+
+      let fresh: TransakPartnerToken;
+      try {
+        fresh = await this.fetchPartnerToken(keys, userIp);
+      } catch (err) {
+        await this.markRefreshFailed(id);
+        throw err;
+      }
+      await this.storeCachedPartnerToken(id, fresh);
+      return fresh.accessToken;
+    } finally {
+      release();
+    }
+  }
+
+  /**
+   * Calls a Transak endpoint with the partner token. If Transak rejects the
+   * token (revoked or expired early), refreshes it once and retries.
+   */
+  private async withPartnerToken(
+    keys: TransakKeys,
+    userIp: string,
+    call: (accessToken: string) => Promise<any>
+  ): Promise<any> {
+    const accessToken = await this.getPartnerToken(keys, userIp);
+    const data = await call(accessToken);
+    if (!PARTNER_TOKEN_REJECTED_STATUSES.includes(data?.statusCode)) return data;
+
+    logger.warn('Transak rejected the cached partner token; refreshing');
+    const freshToken = await this.getPartnerToken(keys, userIp, accessToken);
+    return call(freshToken);
+  }
+
+  /**
+   * True if address is one of the wallet's addresses in BWS. EVM addresses
+   * are matched in any case, since BWS stores them checksummed.
+   */
+  private isWalletAddress(walletId: string, address: string): Promise<boolean> {
+    if (!walletId || !address || typeof address !== 'string') return Promise.resolve(false);
+    const candidates = new Set([address]);
+    if (/^0x[0-9a-fA-F]{40}$/.test(address)) {
+      candidates.add(address.toLowerCase());
+      candidates.add(Web3.utils.toChecksumAddress(address));
+    }
+    return new Promise(resolve => {
+      this.storage.fetchAddressesByWalletId(walletId, [...candidates], (err, addresses) => {
+        if (err) {
+          logger.warn(`Transak order address lookup failed: ${err.message || err}`);
+          return resolve(false);
+        }
+        return resolve(!!addresses?.length);
+      });
+    });
+  }
+
+  private sendRequest(method: 'get' | 'post', URL: string, opts: any, errorMessage: string): Promise<any> {
+    return new Promise((resolve, reject) => {
+      this.request[method](URL, { ...opts, json: true }, (err, data) => {
+        if (err) {
+          logger.error(`Transak request failed with error (${URL}): ${err.stack || err}`);
+          return reject(new ClientError(errorMessage));
+        }
+        return resolve(data);
+      });
+    });
+  }
+
   transakGetCryptoCurrencies(req): Promise<any> {
     return new Promise((resolve, reject) => {
       let keys;
@@ -259,7 +567,6 @@ export class TransakService {
   transakGetSignedPaymentUrl(req): Promise<{ urlWithSignature: string }> {
     return new Promise(async (resolve, reject) => {
       const appRequiredParams = [
-        'accessToken',
         'walletAddress',
         'redirectURL',
         'fiatAmount',
@@ -270,7 +577,7 @@ export class TransakService {
         'partnerCustomerId',
       ];
 
-      const requiredParams = req.body.context === 'web' ? ['accessToken'] : appRequiredParams;
+      const requiredParams = req.body.context === 'web' ? [] : appRequiredParams;
       const referrerDomain = req.body.referrerDomain ?? req.body.context === 'web' ? 'bitpay.com' : 'bitpay';
       const userIp = this.transakGetUserIp(req);
       let keys;
@@ -289,13 +596,16 @@ export class TransakService {
       const headers = {
         Accept: 'application/json',
         'Content-Type': 'application/json',
-        'access-token': req.body.accessToken,
         'x-api-key': API_KEY,
         'x-user-ip': userIp,
       };
 
-      const widgetBody = { ...req.body };
-      delete widgetBody.deviceIp;
+      // Build widgetParams from an allowlist. Spreading req.body here used to
+      // forward accessToken, env and context into Transak's front-end widget.
+      const widgetBody = {};
+      for (const param of WIDGET_PARAMS) {
+        if (req.body[param] !== undefined) widgetBody[param] = req.body[param];
+      }
       const body = {
         widgetParams: {
           ...widgetBody,
@@ -306,27 +616,31 @@ export class TransakService {
 
       const URL: string = WIDGET_API + '/api/v2/auth/session';
 
-      this.request.post(
-        URL,
-        {
-          headers,
-          body,
-          json: true
-        },
-        (err, data) => {
-          if (err) {
-            logger.error(`Transak request failed with error (${URL}): ${err.stack || err}`);
-            return reject(new ClientError('Failed to get Transak signed payment URL'));
-          } else {
-            return resolve({ urlWithSignature: data?.body?.data?.widgetUrl ?? data?.data?.widgetUrl });
-          }
+      try {
+        const data = await this.withPartnerToken(keys, userIp, accessToken =>
+          this.sendRequest(
+            'post',
+            URL,
+            { headers: { ...headers, 'access-token': accessToken }, body },
+            'Failed to get Transak signed payment URL'
+          )
+        );
+        const widgetUrl = data?.body?.data?.widgetUrl ?? data?.data?.widgetUrl;
+        const success = data?.statusCode >= 200 && data?.statusCode < 300;
+        if (!success || !widgetUrl) {
+          logger.warn(`Transak request failed with status code ${data?.statusCode}: ${URL}${transakErrorDetail(data)}`);
+          return reject(new ClientError('Failed to get Transak signed payment URL'));
         }
-      );
+        return resolve({ urlWithSignature: widgetUrl });
+      } catch (err) {
+        return reject(err);
+      }
     });
   }
 
-  transakGetOrderDetails(req): Promise<any> {
+  transakGetOrderDetails(req, walletId: string): Promise<any> {
     return new Promise(async (resolve, reject) => {
+      const userIp = this.transakGetUserIp(req);
       let keys;
       try {
         keys = this.transakGetKeys(req, false);
@@ -336,41 +650,51 @@ export class TransakService {
       const API = keys.API;
       const API_KEY = keys.API_KEY;
 
-      if (!checkRequired(req.body, ['orderId', 'accessToken'])) {
+      if (!checkRequired(req.body, ['orderId'])) {
         return reject(new ClientError("Transak's request missing arguments"));
       }
 
+      // orderId goes into the URL path of a request made with the partner token;
+      // reject anything that could change the path (e.g. "../orders").
+      const orderId = String(req.body.orderId);
+      if (!ORDER_ID_PATTERN.test(orderId)) {
+        return reject(new ClientError('Invalid Transak orderId'));
+      }
+
       const headers = {
         Accept: 'application/json',
-        'access-token': req.body.accessToken,
         'x-api-key': API_KEY,
-        'x-user-ip': Utils.getIpFromReq(req),
+        'x-user-ip': userIp,
       };
 
-      const URL: string = API + `/partners/api/v2/order/${req.body.orderId}`;
+      const URL: string = API + `/partners/api/v2/order/${orderId}`;
 
-      this.request.get(
-        URL,
-        {
-          headers,
-          json: true
-        },
-        (err, data) => {
-          if (err) {
-            logger.error(`Transak request failed with error (${URL}): ${err.stack || err}`);
-            return reject(new ClientError('Failed to get Transak order details'));
-          } else {
-            const success = data.statusCode >= 200 && data.statusCode < 300;
-            if (!success) {
-              logger.warn(`Transak request failed with status code ${data.statusCode}: ${URL}`);
-            }
-            if (!data.body) {
-              return reject(new ClientError('Transak did not return order details'));
-            }
-            return resolve(data.body);
-          }
+      try {
+        const data = await this.withPartnerToken(keys, userIp, accessToken =>
+          this.sendRequest(
+            'get',
+            URL,
+            { headers: { ...headers, 'access-token': accessToken } },
+            'Failed to get Transak order details'
+          )
+        );
+        const success = data.statusCode >= 200 && data.statusCode < 300;
+        if (!success) {
+          logger.warn(`Transak request failed with status code ${data.statusCode}: ${URL}${transakErrorDetail(data)}`);
         }
-      );
+        if (!data.body) {
+          return reject(new ClientError('Transak did not return order details'));
+        }
+        // An order ID alone isn't proof of ownership: only return an order
+        // whose destination address belongs to the requesting wallet.
+        if (success && !(await this.isWalletAddress(walletId, data.body?.data?.walletAddress))) {
+          logger.warn(`Transak order ${orderId} is not for an address of wallet ${walletId}`);
+          return reject(new ClientError('Transak order not found'));
+        }
+        return resolve(data.body);
+      } catch (err) {
+        return reject(err);
+      }
     });
   }
 }

package/src/lib/blockchainexplorer.ts

@@ -48,6 +48,10 @@ const PROVIDERS = {
       livenet: 'https://api-eth.bitcore.io',
       sepolia: 'https://api-eth.bitcore.io'
     },
+    arc: {
+      livenet: 'https://api-eth.bitcore.io',
+      testnet: 'https://api-eth.bitcore.io'
+    },
     sol: {
       livenet: 'https://api-sol.bitcore.io',
       testnet: 'https://api-sol.bitcore.io',

package/src/lib/blockchainexplorers/v8.ts

@@ -29,6 +29,7 @@ const Bitcore_ = {
   arb: Bitcore,
   op: Bitcore,
   base: Bitcore,
+  arc: Bitcore,
   sol: Bitcore
 };
 

package/src/lib/blockchainmonitor.ts

@@ -75,6 +75,7 @@ export class BlockchainMonitor {
             doge: {},
             ltc: {},
             arb: {},
+            arc: {},
             base: {},
             op: {},
             sol: {},