@metamask/ramps-controller 20.2.0 → 21.0.0

package/dist/TransakService.js

@@ -0,0 +1,746 @@
+import { createServicePolicy, HttpError } from '@metamask/controller-utils';
+import packageJson from '../package.json';
+import { addRampsClientIdentityParams } from './client-identity.js';
+import { RAMPS_SDK_VERSION } from './RampsService.js';
+import { TRANSAK_ERROR_CODES } from './transakErrorCodes.js';
+// === ENVIRONMENT ===
+export var TransakEnvironment;
+(function (TransakEnvironment) {
+    TransakEnvironment["Production"] = "production";
+    TransakEnvironment["Staging"] = "staging";
+    TransakEnvironment["Development"] = "development";
+})(TransakEnvironment || (TransakEnvironment = {}));
+var TransakApiProviders;
+(function (TransakApiProviders) {
+    TransakApiProviders["TransakNative"] = "transak-native";
+    TransakApiProviders["TransakNativeStaging"] = "transak-native-staging";
+})(TransakApiProviders || (TransakApiProviders = {}));
+// === ORDER ID UTILITIES ===
+export class TransakOrderIdTransformer {
+    static depositOrderIdToTransakOrderId(depositOrderId) {
+        const parts = depositOrderId.split('/');
+        return parts[parts.length - 1];
+    }
+    static transakOrderIdToDepositOrderId(transakOrderId, environment) {
+        const provider = environment === TransakEnvironment.Production
+            ? 'transak-native'
+            : 'transak-native-staging';
+        return `/providers/${provider}/orders/${transakOrderId}`;
+    }
+    static isDepositOrderId(orderId) {
+        return orderId.startsWith('/providers/');
+    }
+    static extractTransakOrderId(orderId) {
+        return this.isDepositOrderId(orderId)
+            ? this.depositOrderIdToTransakOrderId(orderId)
+            : orderId;
+    }
+}
+// === MESSENGER ===
+const serviceName = 'TransakService';
+const MESSENGER_EXPOSED_METHODS = [
+    'setApiKey',
+    'setAccessToken',
+    'clearAccessToken',
+    'sendUserOtp',
+    'verifyUserOtp',
+    'logout',
+    'getUserDetails',
+    'getBuyQuote',
+    'getKycRequirement',
+    'getAdditionalRequirements',
+    'createOrder',
+    'getOrder',
+    'getUserLimits',
+    'requestOtt',
+    'generatePaymentWidgetUrl',
+    'createWidgetUrl',
+    'submitPurposeOfUsageForm',
+    'patchUser',
+    'submitSsnDetails',
+    'confirmPayment',
+    'getTranslation',
+    'getIdProofStatus',
+    'cancelOrder',
+    'cancelAllActiveOrders',
+    'getActiveOrders',
+];
+// === HELPER FUNCTIONS ===
+/**
+ * Maps ramps API payment method IDs (e.g., "/payments/debit-credit-card")
+ * to the deposit-format IDs expected by the translation endpoint
+ * (e.g., "credit_debit_card").
+ *
+ * The translation endpoint only understands the deposit-format IDs.
+ * Canonical IDs may arrive either with the "/payments/" prefix
+ * (e.g., "/payments/apple-pay") or without it (e.g., "apple-pay"), so both
+ * forms are accepted. If no mapping exists, the input is returned as-is (it
+ * may already be in the deposit format).
+ */
+const RAMPS_TO_DEPOSIT_PAYMENT_METHOD = {
+    '/payments/debit-credit-card': 'credit_debit_card',
+    '/payments/apple-pay': 'apple_pay',
+    '/payments/google-pay': 'google_pay',
+    '/payments/sepa-bank-transfer': 'sepa_bank_transfer',
+    '/payments/wire-transfer': 'wire_transfer',
+    '/payments/gbp-bank-transfer': 'gbp_bank_transfer',
+};
+const PAYMENTS_PREFIX = '/payments/';
+function normalizePaymentMethodForTranslation(paymentMethod) {
+    if (!paymentMethod) {
+        return undefined;
+    }
+    const prefixed = paymentMethod.startsWith(PAYMENTS_PREFIX)
+        ? paymentMethod
+        : `${PAYMENTS_PREFIX}${paymentMethod}`;
+    return (RAMPS_TO_DEPOSIT_PAYMENT_METHOD[paymentMethod] ??
+        RAMPS_TO_DEPOSIT_PAYMENT_METHOD[prefixed] ??
+        paymentMethod);
+}
+function getTransakApiBaseUrl(environment) {
+    switch (environment) {
+        case TransakEnvironment.Production:
+            return 'https://api-gateway.transak.com';
+        // Transak has no dev environment; development uses their staging gateway.
+        case TransakEnvironment.Staging:
+        case TransakEnvironment.Development:
+            return 'https://api-gateway-stg.transak.com';
+        default:
+            throw new Error(`Invalid Transak environment: ${String(environment)}`);
+    }
+}
+function getRampsBaseUrl(environment) {
+    switch (environment) {
+        case TransakEnvironment.Production:
+            return 'https://on-ramp.api.cx.metamask.io';
+        case TransakEnvironment.Staging:
+            return 'https://on-ramp.uat-api.cx.metamask.io';
+        case TransakEnvironment.Development:
+            return 'https://on-ramp.dev-api.cx.metamask.io';
+        default:
+            throw new Error(`Invalid Transak environment: ${String(environment)}`);
+    }
+}
+function getRampsProviderPath(environment) {
+    // The dev ramps API registers the same `transak-native-staging` provider
+    // id as UAT; only production uses `transak-native`.
+    const providerId = environment === TransakEnvironment.Production
+        ? TransakApiProviders.TransakNative
+        : TransakApiProviders.TransakNativeStaging;
+    return `/providers/${providerId}`;
+}
+function getPaymentWidgetBaseUrl(environment) {
+    switch (environment) {
+        case TransakEnvironment.Production:
+            return 'https://global.transak.com';
+        // Transak has no dev environment; development uses their staging widget.
+        case TransakEnvironment.Staging:
+        case TransakEnvironment.Development:
+            return 'https://global-stg.transak.com';
+        default:
+            throw new Error(`Invalid Transak environment: ${String(environment)}`);
+    }
+}
+/**
+ * Transak requires `referrerDomain` in `widgetParams` alongside the partner
+ * API key (which the ramps API proxy injects server-side). Identifies the
+ * MetaMask client to Transak. Default when the client does not pass a
+ * `referrerDomain` constructor option (e.g. the mobile app passes its
+ * package name / bundle id).
+ */
+const TRANSAK_REFERRER_DOMAIN = 'metamask.io';
+// === TRANSAK API ERROR ===
+export class TransakApiError extends HttpError {
+    errorCode;
+    apiMessage;
+    constructor(status, message, errorCode, apiMessage) {
+        super(status, message);
+        this.errorCode = errorCode;
+        this.apiMessage = apiMessage;
+    }
+}
+// === SERVICE DEFINITION ===
+export class TransakService {
+    name;
+    #messenger;
+    #fetch;
+    #policy;
+    #noRetryPolicy;
+    #environment;
+    #context;
+    #orderRetryDelayMs;
+    #apiKey = null;
+    #accessToken = null;
+    /**
+     * Optional ramps API base URL override for local development (mirrors
+     * `RampsService`'s `baseUrlOverride`). Applies to the requests this service
+     * sends to the ramps API (orders, widget-url proxy), not to direct Transak
+     * API calls.
+     */
+    #rampsApiBaseUrlOverride;
+    /**
+     * Identifies the client to Transak in `widgetParams` (e.g. the mobile app's
+     * package name / bundle id). Defaults to `metamask.io`.
+     */
+    #referrerDomain;
+    #clientIdentity;
+    constructor({ messenger, environment = TransakEnvironment.Staging, context, fetch: fetchFunction, apiKey, policyOptions = {}, orderRetryDelayMs = 2000, rampsApiBaseUrlOverride, referrerDomain = TRANSAK_REFERRER_DOMAIN, clientProduct, clientVersion, }) {
+        this.name = serviceName;
+        this.#messenger = messenger;
+        this.#fetch = fetchFunction;
+        this.#policy = createServicePolicy(policyOptions);
+        this.#noRetryPolicy = createServicePolicy({
+            ...policyOptions,
+            maxRetries: 0,
+        });
+        this.#environment = environment;
+        this.#context = context;
+        this.#apiKey = apiKey ?? null;
+        this.#orderRetryDelayMs = orderRetryDelayMs;
+        this.#rampsApiBaseUrlOverride = rampsApiBaseUrlOverride;
+        this.#referrerDomain = referrerDomain;
+        this.#clientIdentity = {
+            clientProduct,
+            clientVersion,
+        };
+        this.#messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+    }
+    setApiKey(apiKey) {
+        this.#apiKey = apiKey;
+    }
+    getApiKey() {
+        return this.#apiKey;
+    }
+    #ensureApiKey() {
+        if (!this.#apiKey) {
+            throw new Error('Transak API key is required but not set.');
+        }
+        return this.#apiKey;
+    }
+    setAccessToken(token) {
+        this.#accessToken = token;
+    }
+    getAccessToken() {
+        return this.#accessToken;
+    }
+    clearAccessToken() {
+        this.#accessToken = null;
+    }
+    #ensureAccessToken() {
+        if (!this.#accessToken?.accessToken) {
+            throw new HttpError(401, 'Authentication required. Please log in to continue.');
+        }
+        const createdTime = new Date(this.#accessToken.created).getTime();
+        const tokenAgeMs = Date.now() - createdTime;
+        if (tokenAgeMs > this.#accessToken.ttl * 1000) {
+            this.clearAccessToken();
+            throw new HttpError(401, 'Authentication token has expired. Please log in again.');
+        }
+    }
+    #getHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        };
+        if (this.#accessToken?.accessToken) {
+            headers.authorization = this.#accessToken.accessToken;
+        }
+        return headers;
+    }
+    async #throwTransakApiError(fetchResponse, url) {
+        let errorBody = '';
+        let errorCode;
+        let apiMessage;
+        try {
+            errorBody = await fetchResponse.text();
+            const parsed = JSON.parse(errorBody);
+            errorCode =
+                parsed?.error?.code ??
+                    (parsed?.error?.errorCode !== null &&
+                        parsed?.error?.errorCode !== undefined
+                        ? String(parsed.error.errorCode)
+                        : undefined);
+            apiMessage =
+                typeof parsed?.error?.message === 'string'
+                    ? parsed.error.message
+                    : undefined;
+        }
+        catch {
+            // ignore body read/parse failures
+        }
+        throw new TransakApiError(fetchResponse.status, `Fetching '${url.toString()}' failed with status '${fetchResponse.status}'${errorBody ? `: ${errorBody}` : ''}`, errorCode, apiMessage);
+    }
+    async #transakGet(path, params) {
+        const baseUrl = getTransakApiBaseUrl(this.#environment);
+        const url = new URL(path, baseUrl);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== null && value !== undefined) {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        const apiKey = this.#ensureApiKey();
+        url.searchParams.set('apiKey', apiKey);
+        const response = await this.#policy.execute(async () => {
+            const fetchResponse = await this.#fetch(url.toString(), {
+                method: 'GET',
+                headers: this.#getHeaders(),
+            });
+            if (!fetchResponse.ok) {
+                await this.#throwTransakApiError(fetchResponse, url);
+            }
+            return fetchResponse.json();
+        });
+        return response.data;
+    }
+    async #transakPost(path, body, options = {}) {
+        const apiKey = this.#ensureApiKey();
+        const baseUrl = getTransakApiBaseUrl(this.#environment);
+        const url = new URL(path, baseUrl);
+        const requestBody = {
+            ...(body ?? {}),
+            apiKey,
+        };
+        const policy = options.policy ?? this.#policy;
+        const response = await policy.execute(async () => {
+            const fetchResponse = await this.#fetch(url.toString(), {
+                method: 'POST',
+                headers: this.#getHeaders(),
+                body: JSON.stringify(requestBody),
+            });
+            if (!fetchResponse.ok) {
+                await this.#throwTransakApiError(fetchResponse, url);
+            }
+            return fetchResponse.json();
+        });
+        return response.data;
+    }
+    async #transakPatch(path, body) {
+        const apiKey = this.#ensureApiKey();
+        const baseUrl = getTransakApiBaseUrl(this.#environment);
+        const url = new URL(path, baseUrl);
+        url.searchParams.set('apiKey', apiKey);
+        const response = await this.#policy.execute(async () => {
+            const fetchResponse = await this.#fetch(url.toString(), {
+                method: 'PATCH',
+                headers: this.#getHeaders(),
+                body: JSON.stringify(body),
+            });
+            if (!fetchResponse.ok) {
+                await this.#throwTransakApiError(fetchResponse, url);
+            }
+            return fetchResponse.json();
+        });
+        return response.data;
+    }
+    async #transakDelete(path, params) {
+        const apiKey = this.#ensureApiKey();
+        const baseUrl = getTransakApiBaseUrl(this.#environment);
+        const url = new URL(path, baseUrl);
+        url.searchParams.set('apiKey', apiKey);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== null && value !== undefined) {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        await this.#policy.execute(async () => {
+            const fetchResponse = await this.#fetch(url.toString(), {
+                method: 'DELETE',
+                headers: this.#getHeaders(),
+            });
+            if (!fetchResponse.ok) {
+                await this.#throwTransakApiError(fetchResponse, url);
+            }
+        });
+    }
+    /**
+     * Gets the ramps API base URL, respecting the local-development override
+     * when set (same semantics as `RampsService`'s `baseUrlOverride`).
+     *
+     * @returns The ramps API base URL to use.
+     */
+    #getRampsApiBaseUrl() {
+        return this.#rampsApiBaseUrlOverride ?? getRampsBaseUrl(this.#environment);
+    }
+    /**
+     * Adds the common request parameters to a ramps API proxy URL, mirroring
+     * `RampsService`'s `#addCommonParams`.
+     *
+     * @param url - The URL to add parameters to.
+     */
+    #addRampsCommonParams(url) {
+        url.searchParams.set('action', 'deposit');
+        url.searchParams.set('sdk', RAMPS_SDK_VERSION);
+        url.searchParams.set('controller', packageJson.version);
+        url.searchParams.set('context', this.#context);
+        // In the query string (not headers) so CDN-cached responses vary per
+        // client product / version.
+        addRampsClientIdentityParams(url, this.#clientIdentity);
+    }
+    async #ordersApiGet(path, params) {
+        const baseUrl = this.#getRampsApiBaseUrl();
+        const providerPath = getRampsProviderPath(this.#environment);
+        const url = new URL(`${providerPath}${path}`, baseUrl);
+        url.searchParams.set('action', 'deposit');
+        url.searchParams.set('context', this.#context);
+        // In the query string (not headers) so CDN-cached responses vary per
+        // client product / version.
+        addRampsClientIdentityParams(url, this.#clientIdentity);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== null && value !== undefined) {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        const response = await this.#policy.execute(async () => {
+            const fetchResponse = await this.#fetch(url.toString(), {
+                method: 'GET',
+                headers: { Accept: 'application/json' },
+            });
+            if (!fetchResponse.ok) {
+                throw new HttpError(fetchResponse.status, `Fetching '${url.toString()}' failed with status '${fetchResponse.status}'`);
+            }
+            return fetchResponse.json();
+        });
+        return response;
+    }
+    // === PUBLIC API METHODS ===
+    async sendUserOtp(email) {
+        const result = await this.#transakPost('/api/v2/auth/login', { email });
+        return result;
+    }
+    async verifyUserOtp(email, verificationCode, stateToken) {
+        const responseData = await this.#transakPost('/api/v2/auth/verify', {
+            email,
+            otp: verificationCode,
+            stateToken,
+        }, { policy: this.#noRetryPolicy });
+        const accessToken = {
+            accessToken: responseData.accessToken,
+            ttl: responseData.ttl,
+            created: new Date(responseData.created),
+        };
+        this.setAccessToken(accessToken);
+        return accessToken;
+    }
+    async logout() {
+        this.#ensureAccessToken();
+        try {
+            const result = await this.#transakPost('/api/v1/auth/logout');
+            this.clearAccessToken();
+            return result;
+        }
+        catch (error) {
+            if (error instanceof HttpError && error.httpStatus === 401) {
+                this.clearAccessToken();
+                return 'user was already logged out';
+            }
+            throw error;
+        }
+    }
+    async getUserDetails() {
+        this.#ensureAccessToken();
+        return this.#transakGet('/api/v2/user/');
+    }
+    async getBuyQuote(genericFiatCurrency, genericCryptoCurrency, genericNetwork, genericPaymentMethod, fiatAmount) {
+        const normalizedPaymentMethod = normalizePaymentMethodForTranslation(genericPaymentMethod || undefined);
+        const translationRequest = {
+            cryptoCurrencyId: genericCryptoCurrency,
+            chainId: genericNetwork,
+            fiatCurrencyId: genericFiatCurrency,
+            paymentMethod: normalizedPaymentMethod,
+        };
+        const translation = await this.getTranslation(translationRequest);
+        const params = {
+            fiatCurrency: translation.fiatCurrency,
+            cryptoCurrency: translation.cryptoCurrency,
+            isBuyOrSell: 'BUY',
+            network: translation.network,
+            fiatAmount,
+            isFeeExcludedFromFiat: 'true',
+        };
+        if (translation.paymentMethod) {
+            params.paymentMethod = translation.paymentMethod;
+        }
+        return this.#transakGet('/api/v2/lookup/quotes', params);
+    }
+    async getKycRequirement(quoteId) {
+        this.#ensureAccessToken();
+        const result = await this.#transakGet('/api/v2/kyc/requirement', {
+            'metadata[quoteId]': quoteId,
+        });
+        return result;
+    }
+    async getAdditionalRequirements(quoteId) {
+        this.#ensureAccessToken();
+        return this.#transakGet('/api/v2/kyc/additional-requirements', { 'metadata[quoteId]': quoteId });
+    }
+    async createOrder(quoteId, walletAddress, paymentMethodId) {
+        this.#ensureAccessToken();
+        const normalizedPaymentMethod = normalizePaymentMethodForTranslation(paymentMethodId);
+        const translation = await this.getTranslation({
+            paymentMethod: normalizedPaymentMethod,
+        });
+        const paymentInstrumentId = translation.paymentMethod ?? normalizedPaymentMethod;
+        try {
+            const transakOrder = await this.#transakPost('/api/v2/orders', {
+                quoteId,
+                walletAddress,
+                paymentInstrumentId,
+            });
+            const depositOrderId = TransakOrderIdTransformer.transakOrderIdToDepositOrderId(transakOrder.orderId, this.#environment);
+            return this.getOrder(depositOrderId, transakOrder.walletAddress, transakOrder.paymentDetails);
+        }
+        catch (error) {
+            if (error instanceof TransakApiError &&
+                error.httpStatus === 409 &&
+                error.errorCode === TRANSAK_ERROR_CODES.ORDER_EXISTS) {
+                await this.cancelAllActiveOrders();
+                await new Promise((resolve) => setTimeout(resolve, this.#orderRetryDelayMs));
+                const retryOrder = await this.#transakPost('/api/v2/orders', {
+                    quoteId,
+                    walletAddress,
+                    paymentInstrumentId,
+                });
+                const retryDepositOrderId = TransakOrderIdTransformer.transakOrderIdToDepositOrderId(retryOrder.orderId, this.#environment);
+                return this.getOrder(retryDepositOrderId, retryOrder.walletAddress, retryOrder.paymentDetails);
+            }
+            throw error;
+        }
+    }
+    async getOrder(orderId, wallet, paymentDetails) {
+        let depositOrderId;
+        if (TransakOrderIdTransformer.isDepositOrderId(orderId)) {
+            depositOrderId = orderId;
+        }
+        else {
+            depositOrderId = TransakOrderIdTransformer.transakOrderIdToDepositOrderId(orderId, this.#environment);
+        }
+        const transakOrderId = TransakOrderIdTransformer.extractTransakOrderId(depositOrderId);
+        const order = await this.#ordersApiGet(`/orders/${transakOrderId}`, { wallet });
+        const orderWithId = {
+            ...order,
+            id: depositOrderId,
+            orderType: 'DEPOSIT',
+        };
+        if (paymentDetails && paymentDetails.length > 0) {
+            return { ...orderWithId, paymentDetails };
+        }
+        if (this.#accessToken?.accessToken) {
+            try {
+                const transakOrder = await this.#transakGet(`/api/v2/orders/${transakOrderId}`);
+                return { ...orderWithId, paymentDetails: transakOrder.paymentDetails };
+            }
+            catch {
+                return orderWithId;
+            }
+        }
+        return orderWithId;
+    }
+    async getUserLimits(fiatCurrency, paymentMethod, kycType) {
+        this.#ensureAccessToken();
+        const translation = await this.getTranslation({
+            paymentMethod: normalizePaymentMethodForTranslation(paymentMethod),
+        });
+        const params = {
+            isBuyOrSell: 'BUY',
+            kycType,
+            fiatCurrency,
+        };
+        if (translation.paymentMethod) {
+            params.paymentCategory = translation.paymentMethod;
+        }
+        return this.#transakGet('/api/v2/orders/user-limit', params);
+    }
+    /**
+     * @deprecated Use {@link createWidgetUrl} instead. The OTT flow requires the
+     * partner API key on the client and Transak is deprecating `request-ott`.
+     * @returns The one-time token response.
+     */
+    async requestOtt() {
+        this.#ensureAccessToken();
+        const result = await this.#transakPost('/api/v2/auth/request-ott');
+        return result;
+    }
+    /**
+     * @deprecated Use {@link createWidgetUrl} instead. This builds the widget
+     * URL client-side and embeds the partner API key in it.
+     * @param ottToken - The one-time token for widget authentication.
+     * @param quote - The buy quote to pre-fill in the widget.
+     * @param walletAddress - The destination wallet address.
+     * @param extraParams - Optional additional URL parameters.
+     * @returns The fully constructed widget URL string.
+     */
+    generatePaymentWidgetUrl(ottToken, quote, walletAddress, extraParams) {
+        const apiKey = this.#ensureApiKey();
+        const widgetBaseUrl = getPaymentWidgetBaseUrl(this.#environment);
+        const defaultParams = {
+            apiKey,
+            ott: ottToken,
+            fiatCurrency: quote.fiatCurrency,
+            cryptoCurrencyCode: quote.cryptoCurrency,
+            productsAvailed: 'BUY',
+            fiatAmount: quote.fiatAmount.toString(),
+            network: quote.network,
+            hideExchangeScreen: 'true',
+            walletAddress,
+            disableWalletAddressForm: 'true',
+            paymentMethod: quote.paymentMethod,
+            redirectURL: 'https://on-ramp-content.api.cx.metamask.io/regions/fake-callback',
+            hideMenu: 'true',
+        };
+        const params = new URLSearchParams({
+            ...defaultParams,
+            ...extraParams,
+        });
+        const widgetUrl = new URL(widgetBaseUrl);
+        widgetUrl.search = params.toString();
+        return widgetUrl.toString();
+    }
+    /**
+     * Creates a Transak payment widget URL through the ramps API proxy
+     * (`POST {rampsBaseUrl}/providers/{providerId}/widget-url`). The proxy
+     * injects the partner API key and derives the user IP server-side, so
+     * neither leaves the backend. Replaces the OTT flow ({@link requestOtt} +
+     * {@link generatePaymentWidgetUrl}).
+     *
+     * Requires both a Transak access token (user must be logged in to Transak)
+     * and a MetaMask bearer token from `AuthenticationController`.
+     *
+     * @param quote - The buy quote to pre-fill in the widget.
+     * @param walletAddress - The destination wallet address.
+     * @param extraParams - Optional additional widget parameters (e.g. theming).
+     * Keys must be on the proxy's allowlist or the request is rejected.
+     * @returns The single-use widget URL (expires after 5 minutes).
+     */
+    async createWidgetUrl(quote, walletAddress, extraParams) {
+        this.#ensureAccessToken();
+        const bearerToken = await this.#messenger.call('AuthenticationController:getBearerToken');
+        const baseUrl = this.#getRampsApiBaseUrl();
+        const providerPath = getRampsProviderPath(this.#environment);
+        const url = new URL(`${providerPath}/widget-url`, baseUrl);
+        this.#addRampsCommonParams(url);
+        const widgetParams = {
+            referrerDomain: this.#referrerDomain,
+            fiatCurrency: quote.fiatCurrency,
+            cryptoCurrencyCode: quote.cryptoCurrency,
+            fiatAmount: quote.fiatAmount,
+            network: quote.network,
+            paymentMethod: quote.paymentMethod,
+            walletAddress,
+            hideExchangeScreen: 'true',
+            disableWalletAddressEdit: 'true',
+            hideMenu: 'true',
+            redirectURL: 'https://on-ramp-content.api.cx.metamask.io/regions/fake-callback',
+            ...extraParams,
+        };
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            Authorization: `Bearer ${bearerToken}`,
+        };
+        if (this.#accessToken?.accessToken) {
+            headers['x-transak-access-token'] = this.#accessToken.accessToken;
+        }
+        const response = await this.#policy.execute(async () => {
+            const fetchResponse = await this.#fetch(url.toString(), {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ widgetParams }),
+            });
+            if (!fetchResponse.ok) {
+                await this.#throwTransakApiError(fetchResponse, url);
+            }
+            return fetchResponse.json();
+        });
+        return response.widgetUrl;
+    }
+    async submitPurposeOfUsageForm(purpose) {
+        this.#ensureAccessToken();
+        await this.#transakPost('/api/v2/kyc/purpose-of-usage', {
+            purposeList: purpose,
+        });
+    }
+    async patchUser(data) {
+        this.#ensureAccessToken();
+        return this.#transakPatch('/api/v2/kyc/user', data);
+    }
+    async submitSsnDetails(ssn, quoteId) {
+        this.#ensureAccessToken();
+        return this.#transakPost('/api/v2/kyc/ssn', { ssn, quoteId });
+    }
+    async confirmPayment(orderId, paymentMethodId) {
+        this.#ensureAccessToken();
+        const normalizedPaymentMethod = normalizePaymentMethodForTranslation(paymentMethodId);
+        const translation = await this.getTranslation({
+            paymentMethod: normalizedPaymentMethod,
+        });
+        const transakOrderId = TransakOrderIdTransformer.extractTransakOrderId(orderId);
+        return this.#transakPost('/api/v2/orders/payment-confirmation', {
+            orderId: transakOrderId,
+            paymentMethod: translation.paymentMethod ?? normalizedPaymentMethod,
+        });
+    }
+    async getTranslation(translationRequest) {
+        const baseUrl = getRampsBaseUrl(this.#environment);
+        const providerPath = getRampsProviderPath(this.#environment);
+        const url = new URL(`${providerPath}/native/translate`, baseUrl);
+        url.searchParams.set('action', 'deposit');
+        url.searchParams.set('context', this.#context);
+        const normalizedRequest = {
+            ...translationRequest,
+            paymentMethod: normalizePaymentMethodForTranslation(translationRequest.paymentMethod),
+        };
+        for (const [key, value] of Object.entries(normalizedRequest)) {
+            if (value !== undefined) {
+                url.searchParams.set(key, value);
+            }
+        }
+        const response = await this.#policy.execute(async () => {
+            const fetchResponse = await this.#fetch(url.toString(), {
+                method: 'GET',
+                headers: { Accept: 'application/json' },
+            });
+            if (!fetchResponse.ok) {
+                throw new HttpError(fetchResponse.status, `Fetching '${url.toString()}' failed with status '${fetchResponse.status}'`);
+            }
+            return fetchResponse.json();
+        });
+        return response;
+    }
+    async getIdProofStatus(workFlowRunId) {
+        this.#ensureAccessToken();
+        return this.#transakGet('/api/v2/kyc/id-proof-status', { workFlowRunId });
+    }
+    async cancelOrder(depositOrderId) {
+        this.#ensureAccessToken();
+        const transakOrderId = TransakOrderIdTransformer.extractTransakOrderId(depositOrderId);
+        await this.#transakDelete(`/api/v2/orders/${transakOrderId}`, {
+            cancelReason: 'Creating new order',
+        });
+    }
+    async cancelAllActiveOrders() {
+        this.#ensureAccessToken();
+        const activeOrders = await this.getActiveOrders();
+        const errors = [];
+        await Promise.all(activeOrders.map(async (order) => {
+            try {
+                const depositOrderId = TransakOrderIdTransformer.transakOrderIdToDepositOrderId(order.orderId, this.#environment);
+                await this.cancelOrder(depositOrderId);
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error : new Error(String(error)));
+            }
+        }));
+        return errors;
+    }
+    async getActiveOrders() {
+        this.#ensureAccessToken();
+        return this.#transakGet('/api/v2/active-orders');
+    }
+}
+//# sourceMappingURL=TransakService.js.map