How to use Payment Methods: Bank Transfer

1
const BASE = "https://api-gateway-stg.transak.com";
2
3
interface Quote {
4
  quoteId: string;
5
  cryptoAmount: number;
6
  fiatAmount: number;
7
  totalFee: number;
8
  feeBreakdown: { id: string; name: string; value: number }[];
9
  expiresAt: string;
10
}
11
12
async function getBankTransferQuote(params: {
13
  fiatCurrency: "EUR" | "GBP";
14
  cryptoCurrency: string;
15
  fiatAmount: number;
16
  network: string;
17
  apiKey: string;
18
  userIp: string;
19
}): Promise<Quote> {
20
  const paymentMethod =
21
    params.fiatCurrency === "GBP" ? "gbp_bank_transfer" : "sepa_bank_transfer";
22
23
  const qs = new URLSearchParams({
24
    fiatCurrency: params.fiatCurrency,
25
    cryptoCurrency: params.cryptoCurrency,
26
    isBuyOrSell: "BUY",
27
    fiatAmount: String(params.fiatAmount),
28
    network: params.network,
29
    paymentMethod,
30
  });
31
32
  const res = await fetch(`${BASE}/api/v2/lookup/quotes?${qs}`, {
33
    headers: { "x-api-key": params.apiKey, "x-user-ip": params.userIp },
34
  });
35
  const json = await res.json();
36
  if (!res.ok) throw new Error(json.message ?? `HTTP ${res.status}`);
37
  return json.data as Quote;
38
}

1
const BASE = "https://api-gateway-stg.transak.com";
2
3
interface VirtualAccountResponse {
4
  status: "INITIATED" | "COMPLETED" | "FAILED";
5
  message: string;
6
}
7
8
async function createVirtualAccount(params: {
9
  quoteId: string;
10
  apiKey: string;
11
  userIp: string;
12
  accessToken: string;
13
}): Promise<VirtualAccountResponse> {
14
  const res = await fetch(
15
    `${BASE}/api/whitelabel/payments/bank-transfer/create-virtual-account`,
16
    {
17
      method: "POST",
18
      headers: {
19
        "x-api-key": params.apiKey,
20
        "x-user-ip": params.userIp,
21
      },
22
      body: JSON.stringify({ quoteId: params.quoteId }),
23
    }
24
  );
25
  const json = await res.json();
26
  if (!res.ok) throw new Error(json.message ?? `HTTP ${res.status}`);
27
  return json.data as VirtualAccountResponse;
28
}

1
const BASE = "https://api-gateway-stg.transak.com";
2
3
type PaymentInstrumentId = "sepa_bank_transfer" | "gbp_bank_transfer";
4
5
async function pollPaymentInstrumentStatus(params: {
6
  paymentInstrumentId: PaymentInstrumentId;
7
  quoteId: string;
8
  apiKey: string;
9
  userIp: string;
10
  accessToken: string;
11
  intervalMs?: number;
12
  timeoutMs?: number;
13
}): Promise<void> {
14
  const { intervalMs = 3000, timeoutMs = 120_000 } = params;
15
  const deadline = Date.now() + timeoutMs;
16
17
  while (Date.now() < deadline) {
18
    const qs = new URLSearchParams({
19
      paymentInstrumentId: params.paymentInstrumentId,
20
      quoteId: params.quoteId,
21
    });
22
    const res = await fetch(
23
      `${BASE}/api/whitelabel/payments/bank-transfer/get-payment-instrument-status?${qs}`,
24
      {
25
        headers: {
26
          "x-api-key": params.apiKey,
27
          "x-user-ip": params.userIp,
28
        },
29
      }
30
    );
31
    const json = await res.json();
32
    if (!res.ok) throw new Error(json.message ?? `HTTP ${res.status}`);
33
34
    const status: string =
35
      json.data.paymentInstruments[params.paymentInstrumentId]?.status;
36
37
    if (status === "COMPLETED") return;
38
    if (status === "FAILED") throw new Error("Virtual account setup failed");
39
40
    await new Promise(resolve => setTimeout(resolve, intervalMs));
41
  }
42
43
  throw new Error("Timed out waiting for payment instrument to be COMPLETED");
44
}

1
const BASE = "https://api-gateway-stg.transak.com";
2
3
interface Vasp {
4
  vaspId: string;
5
  name: string;
6
}
7
8
async function getVasps(params: {
9
  apiKey: string;
10
  userIp: string;
11
  accessToken: string;
12
}): Promise<Vasp[]> {
13
  const res = await fetch(
14
    `${BASE}/api/whitelabel/payments/bank-transfer/get-vasps`,
15
    {
16
      headers: {
17
        "x-api-key": params.apiKey,
18
        "x-user-ip": params.userIp,
19
        Authorization: params.accessToken,
20
      },
21
    }
22
  );
23
  const json = await res.json();
24
  if (!res.ok) throw new Error(json.message ?? `HTTP ${res.status}`);
25
  return json.data.vasps as Vasp[];
26
}

1
const BASE = "https://api-gateway-stg.transak.com";
2
3
type PaymentInstrumentId = "sepa_bank_transfer" | "gbp_bank_transfer";
4
5
interface PaymentDetailField {
6
  name: string;
7
  value: string;
8
}
9
10
interface CreateOrderResponse {
11
  orderId: string;
12
  status: string;
13
  paymentDetails: {
14
    name: string;
15
    fields: PaymentDetailField[];
16
  }[];
17
}
18
19
async function createBankTransferOrder(params: {
20
  quoteId: string;
21
  walletAddress: string;
22
  paymentInstrumentId: PaymentInstrumentId;
23
  vaspId?: string;
24
  apiKey: string;
25
  userIp: string;
26
  accessToken: string;
27
}): Promise<CreateOrderResponse> {
28
  const body: Record<string, string> = {
29
    quoteId: params.quoteId,
30
    walletAddress: params.walletAddress,
31
    paymentInstrumentId: params.paymentInstrumentId,
32
  };
33
  if (params.vaspId) body.vaspId = params.vaspId;
34
35
  const res = await fetch(
36
    `${BASE}/api/whitelabel/payments/bank-transfer/create-order`,
37
    {
38
      method: "POST",
39
      headers: {
40
        "x-api-key": params.apiKey,
41
        "x-user-ip": params.userIp,
42
      },
43
      body: JSON.stringify(body),
44
    }
45
  );
46
  const json = await res.json();
47
  if (!res.ok) throw new Error(json.message ?? `HTTP ${res.status}`);
48
  return json.data as CreateOrderResponse;
49
}

1
const BASE = "https://api-gateway-stg.transak.com";
2
3
async function confirmBankTransferPayment(params: {
4
  orderId: string;
5
  apiKey: string;
6
  userIp: string;
7
  accessToken: string;
8
}): Promise<{ orderId: string; status: string }> {
9
  const res = await fetch(
10
    `${BASE}/api/whitelabel/payments/bank-transfer/confirm-payment`,
11
    {
12
      method: "POST",
13
      headers: {
14
        "x-api-key": params.apiKey,
15
        "x-user-ip": params.userIp,
16
      },
17
      body: JSON.stringify({ orderId: params.orderId }),
18
    }
19
  );
20
  const json = await res.json();
21
  if (!res.ok) throw new Error(json.message ?? `HTTP ${res.status}`);
22
  return json.data;
23
}