@metamask/ramps-controller 8.0.0 → 9.0.0

package/dist/TransakService.mjs

@@ -0,0 +1,582 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TransakService_instances, _TransakService_messenger, _TransakService_fetch, _TransakService_policy, _TransakService_environment, _TransakService_context, _TransakService_orderRetryDelayMs, _TransakService_apiKey, _TransakService_accessToken, _TransakService_ensureApiKey, _TransakService_ensureAccessToken, _TransakService_getHeaders, _TransakService_transakGet, _TransakService_transakPost, _TransakService_transakPatch, _TransakService_transakDelete, _TransakService_ordersApiGet;
+import { createServicePolicy, HttpError } from "@metamask/controller-utils";
+// === ENVIRONMENT ===
+export var TransakEnvironment;
+(function (TransakEnvironment) {
+    TransakEnvironment["Production"] = "production";
+    TransakEnvironment["Staging"] = "staging";
+})(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.Staging
+            ? 'transak-native-staging'
+            : 'transak-native';
+        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',
+    '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.
+ * 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',
+};
+function normalizePaymentMethodForTranslation(paymentMethod) {
+    if (!paymentMethod) {
+        return undefined;
+    }
+    return RAMPS_TO_DEPOSIT_PAYMENT_METHOD[paymentMethod] ?? paymentMethod;
+}
+function getTransakApiBaseUrl(environment) {
+    switch (environment) {
+        case TransakEnvironment.Production:
+            return 'https://api-gateway.transak.com';
+        case TransakEnvironment.Staging:
+            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';
+        default:
+            throw new Error(`Invalid Transak environment: ${String(environment)}`);
+    }
+}
+function getRampsProviderPath(environment) {
+    const providerId = environment === TransakEnvironment.Staging
+        ? TransakApiProviders.TransakNativeStaging
+        : TransakApiProviders.TransakNative;
+    return `/providers/${providerId}`;
+}
+function getPaymentWidgetBaseUrl(environment) {
+    switch (environment) {
+        case TransakEnvironment.Production:
+            return 'https://global.transak.com';
+        case TransakEnvironment.Staging:
+            return 'https://global-stg.transak.com';
+        default:
+            throw new Error(`Invalid Transak environment: ${String(environment)}`);
+    }
+}
+// === TRANSAK API ERROR ===
+const TRANSAK_ORDER_EXISTS_CODE = '4005';
+export class TransakApiError extends HttpError {
+    constructor(status, message, errorCode) {
+        super(status, message);
+        this.errorCode = errorCode;
+    }
+}
+// === SERVICE DEFINITION ===
+export class TransakService {
+    constructor({ messenger, environment = TransakEnvironment.Staging, context, fetch: fetchFunction, apiKey, policyOptions = {}, orderRetryDelayMs = 2000, }) {
+        _TransakService_instances.add(this);
+        _TransakService_messenger.set(this, void 0);
+        _TransakService_fetch.set(this, void 0);
+        _TransakService_policy.set(this, void 0);
+        _TransakService_environment.set(this, void 0);
+        _TransakService_context.set(this, void 0);
+        _TransakService_orderRetryDelayMs.set(this, void 0);
+        _TransakService_apiKey.set(this, null);
+        _TransakService_accessToken.set(this, null);
+        this.name = serviceName;
+        __classPrivateFieldSet(this, _TransakService_messenger, messenger, "f");
+        __classPrivateFieldSet(this, _TransakService_fetch, fetchFunction, "f");
+        __classPrivateFieldSet(this, _TransakService_policy, createServicePolicy(policyOptions), "f");
+        __classPrivateFieldSet(this, _TransakService_environment, environment, "f");
+        __classPrivateFieldSet(this, _TransakService_context, context, "f");
+        __classPrivateFieldSet(this, _TransakService_apiKey, apiKey ?? null, "f");
+        __classPrivateFieldSet(this, _TransakService_orderRetryDelayMs, orderRetryDelayMs, "f");
+        __classPrivateFieldGet(this, _TransakService_messenger, "f").registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+    }
+    setApiKey(apiKey) {
+        __classPrivateFieldSet(this, _TransakService_apiKey, apiKey, "f");
+    }
+    getApiKey() {
+        return __classPrivateFieldGet(this, _TransakService_apiKey, "f");
+    }
+    setAccessToken(token) {
+        __classPrivateFieldSet(this, _TransakService_accessToken, token, "f");
+    }
+    getAccessToken() {
+        return __classPrivateFieldGet(this, _TransakService_accessToken, "f");
+    }
+    clearAccessToken() {
+        __classPrivateFieldSet(this, _TransakService_accessToken, null, "f");
+    }
+    // === PUBLIC API METHODS ===
+    async sendUserOtp(email) {
+        const result = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/api/v2/auth/login', { email });
+        return result;
+    }
+    async verifyUserOtp(email, verificationCode, stateToken) {
+        const responseData = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/api/v2/auth/verify', {
+            email,
+            otp: verificationCode,
+            stateToken,
+        });
+        const accessToken = {
+            accessToken: responseData.accessToken,
+            ttl: responseData.ttl,
+            created: new Date(responseData.created),
+        };
+        this.setAccessToken(accessToken);
+        return accessToken;
+    }
+    async logout() {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        try {
+            const result = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/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() {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        return __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakGet).call(this, '/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 __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakGet).call(this, '/api/v2/lookup/quotes', params);
+    }
+    async getKycRequirement(quoteId) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        const result = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakGet).call(this, '/api/v2/kyc/requirement', {
+            'metadata[quoteId]': quoteId,
+        });
+        return result;
+    }
+    async getAdditionalRequirements(quoteId) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        return __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakGet).call(this, '/api/v2/kyc/additional-requirements', { 'metadata[quoteId]': quoteId });
+    }
+    async createOrder(quoteId, walletAddress, paymentMethodId) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        const normalizedPaymentMethod = normalizePaymentMethodForTranslation(paymentMethodId);
+        const translation = await this.getTranslation({
+            paymentMethod: normalizedPaymentMethod,
+        });
+        const paymentInstrumentId = translation.paymentMethod ?? normalizedPaymentMethod;
+        try {
+            const transakOrder = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/api/v2/orders', {
+                quoteId,
+                walletAddress,
+                paymentInstrumentId,
+            });
+            const depositOrderId = TransakOrderIdTransformer.transakOrderIdToDepositOrderId(transakOrder.orderId, __classPrivateFieldGet(this, _TransakService_environment, "f"));
+            return this.getOrder(depositOrderId, transakOrder.walletAddress, transakOrder.paymentDetails);
+        }
+        catch (error) {
+            if (error instanceof TransakApiError &&
+                error.httpStatus === 409 &&
+                error.errorCode === TRANSAK_ORDER_EXISTS_CODE) {
+                await this.cancelAllActiveOrders();
+                await new Promise((resolve) => setTimeout(resolve, __classPrivateFieldGet(this, _TransakService_orderRetryDelayMs, "f")));
+                const retryOrder = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/api/v2/orders', {
+                    quoteId,
+                    walletAddress,
+                    paymentInstrumentId,
+                });
+                const retryDepositOrderId = TransakOrderIdTransformer.transakOrderIdToDepositOrderId(retryOrder.orderId, __classPrivateFieldGet(this, _TransakService_environment, "f"));
+                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, __classPrivateFieldGet(this, _TransakService_environment, "f"));
+        }
+        const transakOrderId = TransakOrderIdTransformer.extractTransakOrderId(depositOrderId);
+        const order = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ordersApiGet).call(this, `/orders/${transakOrderId}`, { wallet });
+        const orderWithId = {
+            ...order,
+            id: depositOrderId,
+            orderType: 'DEPOSIT',
+        };
+        if (paymentDetails && paymentDetails.length > 0) {
+            return { ...orderWithId, paymentDetails };
+        }
+        if (__classPrivateFieldGet(this, _TransakService_accessToken, "f")?.accessToken) {
+            try {
+                const transakOrder = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakGet).call(this, `/api/v2/orders/${transakOrderId}`);
+                return { ...orderWithId, paymentDetails: transakOrder.paymentDetails };
+            }
+            catch {
+                return orderWithId;
+            }
+        }
+        return orderWithId;
+    }
+    async getUserLimits(fiatCurrency, paymentMethod, kycType) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        const translation = await this.getTranslation({
+            paymentMethod: normalizePaymentMethodForTranslation(paymentMethod),
+        });
+        const params = {
+            isBuyOrSell: 'BUY',
+            kycType,
+            fiatCurrency,
+        };
+        if (translation.paymentMethod) {
+            params.paymentCategory = translation.paymentMethod;
+        }
+        return __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakGet).call(this, '/api/v2/orders/user-limit', params);
+    }
+    async requestOtt() {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        const result = await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/api/v2/auth/request-ott');
+        return result;
+    }
+    generatePaymentWidgetUrl(ottToken, quote, walletAddress, extraParams) {
+        const apiKey = __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureApiKey).call(this);
+        const widgetBaseUrl = getPaymentWidgetBaseUrl(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+        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();
+    }
+    async submitPurposeOfUsageForm(purpose) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/api/v2/kyc/purpose-of-usage', {
+            purposeList: purpose,
+        });
+    }
+    async patchUser(data) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        return __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPatch).call(this, '/api/v2/kyc/user', data);
+    }
+    async submitSsnDetails(ssn, quoteId) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        return __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/api/v2/kyc/ssn', { ssn, quoteId });
+    }
+    async confirmPayment(orderId, paymentMethodId) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        const normalizedPaymentMethod = normalizePaymentMethodForTranslation(paymentMethodId);
+        const translation = await this.getTranslation({
+            paymentMethod: normalizedPaymentMethod,
+        });
+        const transakOrderId = TransakOrderIdTransformer.extractTransakOrderId(orderId);
+        return __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakPost).call(this, '/api/v2/orders/payment-confirmation', {
+            orderId: transakOrderId,
+            paymentMethod: translation.paymentMethod ?? normalizedPaymentMethod,
+        });
+    }
+    async getTranslation(translationRequest) {
+        const baseUrl = getRampsBaseUrl(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+        const providerPath = getRampsProviderPath(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+        const url = new URL(`${providerPath}/native/translate`, baseUrl);
+        url.searchParams.set('action', 'deposit');
+        url.searchParams.set('context', __classPrivateFieldGet(this, _TransakService_context, "f"));
+        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 __classPrivateFieldGet(this, _TransakService_policy, "f").execute(async () => {
+            const fetchResponse = await __classPrivateFieldGet(this, _TransakService_fetch, "f").call(this, 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) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        return __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakGet).call(this, '/api/v2/kyc/id-proof-status', { workFlowRunId });
+    }
+    async cancelOrder(depositOrderId) {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        const transakOrderId = TransakOrderIdTransformer.extractTransakOrderId(depositOrderId);
+        await __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakDelete).call(this, `/api/v2/orders/${transakOrderId}`, {
+            cancelReason: 'Creating new order',
+        });
+    }
+    async cancelAllActiveOrders() {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        const activeOrders = await this.getActiveOrders();
+        const errors = [];
+        await Promise.all(activeOrders.map(async (order) => {
+            try {
+                const depositOrderId = TransakOrderIdTransformer.transakOrderIdToDepositOrderId(order.orderId, __classPrivateFieldGet(this, _TransakService_environment, "f"));
+                await this.cancelOrder(depositOrderId);
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error : new Error(String(error)));
+            }
+        }));
+        return errors;
+    }
+    async getActiveOrders() {
+        __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureAccessToken).call(this);
+        return __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_transakGet).call(this, '/api/v2/active-orders');
+    }
+}
+_TransakService_messenger = new WeakMap(), _TransakService_fetch = new WeakMap(), _TransakService_policy = new WeakMap(), _TransakService_environment = new WeakMap(), _TransakService_context = new WeakMap(), _TransakService_orderRetryDelayMs = new WeakMap(), _TransakService_apiKey = new WeakMap(), _TransakService_accessToken = new WeakMap(), _TransakService_instances = new WeakSet(), _TransakService_ensureApiKey = function _TransakService_ensureApiKey() {
+    if (!__classPrivateFieldGet(this, _TransakService_apiKey, "f")) {
+        throw new Error('Transak API key is required but not set.');
+    }
+    return __classPrivateFieldGet(this, _TransakService_apiKey, "f");
+}, _TransakService_ensureAccessToken = function _TransakService_ensureAccessToken() {
+    if (!__classPrivateFieldGet(this, _TransakService_accessToken, "f")?.accessToken) {
+        throw new HttpError(401, 'Authentication required. Please log in to continue.');
+    }
+    const createdTime = new Date(__classPrivateFieldGet(this, _TransakService_accessToken, "f").created).getTime();
+    const tokenAgeMs = Date.now() - createdTime;
+    if (tokenAgeMs > __classPrivateFieldGet(this, _TransakService_accessToken, "f").ttl * 1000) {
+        this.clearAccessToken();
+        throw new HttpError(401, 'Authentication token has expired. Please log in again.');
+    }
+}, _TransakService_getHeaders = function _TransakService_getHeaders() {
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+    };
+    if (__classPrivateFieldGet(this, _TransakService_accessToken, "f")?.accessToken) {
+        headers.authorization = __classPrivateFieldGet(this, _TransakService_accessToken, "f").accessToken;
+    }
+    return headers;
+}, _TransakService_transakGet = async function _TransakService_transakGet(path, params) {
+    const baseUrl = getTransakApiBaseUrl(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+    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 = __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureApiKey).call(this);
+    url.searchParams.set('apiKey', apiKey);
+    const response = await __classPrivateFieldGet(this, _TransakService_policy, "f").execute(async () => {
+        const fetchResponse = await __classPrivateFieldGet(this, _TransakService_fetch, "f").call(this, url.toString(), {
+            method: 'GET',
+            headers: __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_getHeaders).call(this),
+        });
+        if (!fetchResponse.ok) {
+            throw new HttpError(fetchResponse.status, `Fetching '${url.toString()}' failed with status '${fetchResponse.status}'`);
+        }
+        return fetchResponse.json();
+    });
+    return response.data;
+}, _TransakService_transakPost = async function _TransakService_transakPost(path, body) {
+    const apiKey = __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureApiKey).call(this);
+    const baseUrl = getTransakApiBaseUrl(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+    const url = new URL(path, baseUrl);
+    const requestBody = {
+        ...(body ?? {}),
+        apiKey,
+    };
+    const response = await __classPrivateFieldGet(this, _TransakService_policy, "f").execute(async () => {
+        const fetchResponse = await __classPrivateFieldGet(this, _TransakService_fetch, "f").call(this, url.toString(), {
+            method: 'POST',
+            headers: __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_getHeaders).call(this),
+            body: JSON.stringify(requestBody),
+        });
+        if (!fetchResponse.ok) {
+            let errorBody = '';
+            let errorCode;
+            try {
+                errorBody = await fetchResponse.text();
+                const parsed = JSON.parse(errorBody);
+                errorCode = parsed?.error?.code;
+            }
+            catch {
+                // ignore body read/parse failures
+            }
+            throw new TransakApiError(fetchResponse.status, `Fetching '${url.toString()}' failed with status '${fetchResponse.status}'${errorBody ? `: ${errorBody}` : ''}`, errorCode);
+        }
+        return fetchResponse.json();
+    });
+    return response.data;
+}, _TransakService_transakPatch = async function _TransakService_transakPatch(path, body) {
+    const apiKey = __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureApiKey).call(this);
+    const baseUrl = getTransakApiBaseUrl(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+    const url = new URL(path, baseUrl);
+    url.searchParams.set('apiKey', apiKey);
+    const response = await __classPrivateFieldGet(this, _TransakService_policy, "f").execute(async () => {
+        const fetchResponse = await __classPrivateFieldGet(this, _TransakService_fetch, "f").call(this, url.toString(), {
+            method: 'PATCH',
+            headers: __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_getHeaders).call(this),
+            body: JSON.stringify(body),
+        });
+        if (!fetchResponse.ok) {
+            throw new HttpError(fetchResponse.status, `Fetching '${url.toString()}' failed with status '${fetchResponse.status}'`);
+        }
+        return fetchResponse.json();
+    });
+    return response.data;
+}, _TransakService_transakDelete = async function _TransakService_transakDelete(path, params) {
+    const apiKey = __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_ensureApiKey).call(this);
+    const baseUrl = getTransakApiBaseUrl(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+    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 __classPrivateFieldGet(this, _TransakService_policy, "f").execute(async () => {
+        const fetchResponse = await __classPrivateFieldGet(this, _TransakService_fetch, "f").call(this, url.toString(), {
+            method: 'DELETE',
+            headers: __classPrivateFieldGet(this, _TransakService_instances, "m", _TransakService_getHeaders).call(this),
+        });
+        if (!fetchResponse.ok) {
+            throw new HttpError(fetchResponse.status, `Fetching '${url.toString()}' failed with status '${fetchResponse.status}'`);
+        }
+    });
+}, _TransakService_ordersApiGet = async function _TransakService_ordersApiGet(path, params) {
+    const baseUrl = getRampsBaseUrl(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+    const providerPath = getRampsProviderPath(__classPrivateFieldGet(this, _TransakService_environment, "f"));
+    const url = new URL(`${providerPath}${path}`, baseUrl);
+    url.searchParams.set('action', 'deposit');
+    url.searchParams.set('context', __classPrivateFieldGet(this, _TransakService_context, "f"));
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== null && value !== undefined) {
+                url.searchParams.set(key, value);
+            }
+        }
+    }
+    const response = await __classPrivateFieldGet(this, _TransakService_policy, "f").execute(async () => {
+        const fetchResponse = await __classPrivateFieldGet(this, _TransakService_fetch, "f").call(this, 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;
+};
+//# sourceMappingURL=TransakService.mjs.map