santoid-sdk 1.0.0

package/dist/node/auth/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = void 0;
+const fs_1 = __importDefault(require("fs"));
+const constants_1 = require("../../utils/constants");
+async function initialize(options) {
+    var _a;
+    let credentialsBase64;
+    if (options === null || options === void 0 ? void 0 : options.credentials) {
+        if (typeof (options === null || options === void 0 ? void 0 : options.credentials) === 'string') {
+            credentialsBase64 = options === null || options === void 0 ? void 0 : options.credentials;
+        }
+        else if (typeof (options === null || options === void 0 ? void 0 : options.credentials) === 'object') {
+            credentialsBase64 = Buffer.from(JSON.stringify(options === null || options === void 0 ? void 0 : options.credentials)).toString('base64');
+        }
+        else {
+            throw new Error('Invalid credentials');
+        }
+    }
+    else {
+        if (process.env.SANTOID_SDK_CREDENTIALS) {
+            credentialsBase64 = fs_1.default.readFileSync(process.env.SANTOID_SDK_CREDENTIALS, { encoding: 'base64' });
+        }
+        else {
+            throw new Error('Credentials not found');
+        }
+    }
+    if (credentialsBase64) {
+        const response = await fetch((_a = options === null || options === void 0 ? void 0 : options.customApiUrl) !== null && _a !== void 0 ? _a : constants_1.API_GATEWAY_URL, {
+            method: 'POST',
+            body: JSON.stringify({ service_account_base64: credentialsBase64 }),
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const token = await response.json();
+        if (typeof token !== 'string') {
+            throw new Error('Cannot generate token');
+        }
+        return token;
+    }
+}
+exports.initialize = initialize;

package/dist/node/liveness/index.d.ts

@@ -0,0 +1,4 @@
+import { type TNodeSDKOptions } from './utils/types';
+export declare function livenessDetection(options: TNodeSDKOptions): Promise<{
+    stopLivenessDetection: () => Promise<void>;
+}>;

package/dist/node/liveness/index.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.livenessDetection = void 0;
+const constants_1 = require("../../utils/constants");
+const websocket_1 = require("./utils/websocket");
+async function onWebSocketMessage(options, event) {
+    var _a, _b, _c;
+    const message = event.data;
+    let messageObj;
+    try {
+        messageObj = JSON.parse(message);
+    }
+    catch (err) {
+        console.error('Cannot parse API message', err);
+    }
+    if ((messageObj === null || messageObj === void 0 ? void 0 : messageObj.next_step) && !messageObj.error) {
+        await ((_a = options.nextStepCallback) === null || _a === void 0 ? void 0 : _a.call(options, messageObj.next_step));
+        await ((_b = options[`${messageObj.next_step}Callback`]) === null || _b === void 0 ? void 0 : _b.call(options));
+    }
+    if (messageObj === null || messageObj === void 0 ? void 0 : messageObj.error) {
+        await ((_c = options.errorCallback) === null || _c === void 0 ? void 0 : _c.call(options, { code: 'wrong-position' }));
+    }
+    return messageObj;
+}
+async function livenessDetection(options) {
+    var _a, _b, _c;
+    let websocketClosedBySDK = false;
+    let validationSuccess = false;
+    let endCalled = false;
+    async function stopLivenessDetection(options, websocket, intervalKey) {
+        var _a;
+        if (intervalKey) {
+            clearInterval(intervalKey);
+        }
+        if (websocket) {
+            (0, websocket_1.disconnectFromWebSocket)(websocket);
+        }
+        !endCalled && await ((_a = options.endCallback) === null || _a === void 0 ? void 0 : _a.call(options));
+        endCalled = true;
+        websocketClosedBySDK = true;
+    }
+    let sendFramesIntervalKey;
+    let websocket;
+    try {
+        websocket = await (0, websocket_1.connectToWebSocket)(options);
+        await ((_a = options.nextStepCallback) === null || _a === void 0 ? void 0 : _a.call(options, 'front'));
+        await ((_b = options.frontCallback) === null || _b === void 0 ? void 0 : _b.call(options));
+        let lastMessage;
+        sendFramesIntervalKey = setInterval(async () => {
+            try {
+                if (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.can_send_next_bytes) {
+                    const bytes = await options.getNextFrame();
+                    if (bytes) {
+                        websocket === null || websocket === void 0 ? void 0 : websocket.send(bytes);
+                    }
+                }
+            }
+            catch (err) {
+                await stopLivenessDetection(options, websocket, sendFramesIntervalKey);
+            }
+        }, constants_1.SEND_FRAMES_INTERVAL_MS);
+        websocket.on('message', async (data) => {
+            var _a;
+            const parsedMessage = await onWebSocketMessage(options, { data: Buffer.from(data).toString() });
+            if (parsedMessage) {
+                lastMessage = parsedMessage;
+            }
+            if (parsedMessage === null || parsedMessage === void 0 ? void 0 : parsedMessage.success) {
+                validationSuccess = true;
+                await ((_a = options.successCallback) === null || _a === void 0 ? void 0 : _a.call(options));
+                await stopLivenessDetection(options, websocket, sendFramesIntervalKey);
+            }
+        });
+        websocket.on('error', async (event) => {
+            var _a;
+            !validationSuccess && ((_a = options.errorCallback) === null || _a === void 0 ? void 0 : _a.call(options, { code: 'internal-error' }));
+            await stopLivenessDetection(options, websocket, sendFramesIntervalKey);
+        });
+        websocket.on('close', async () => {
+            var _a;
+            if (!websocketClosedBySDK) {
+                !validationSuccess && ((_a = options.errorCallback) === null || _a === void 0 ? void 0 : _a.call(options, { code: 'internal-error' }));
+                await stopLivenessDetection(options, websocket, sendFramesIntervalKey);
+            }
+        });
+        lastMessage = { can_send_next_bytes: true };
+        return {
+            stopLivenessDetection: async () => { await stopLivenessDetection(options, websocket, sendFramesIntervalKey); },
+        };
+    }
+    catch (err) {
+        console.error('catch error', err);
+        !validationSuccess && ((_c = options.errorCallback) === null || _c === void 0 ? void 0 : _c.call(options, { code: 'internal-error' }));
+        await stopLivenessDetection(options, websocket, sendFramesIntervalKey);
+        throw err;
+    }
+}
+exports.livenessDetection = livenessDetection;

package/dist/node/liveness/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function decodeJwt(token: string): any;

package/dist/node/liveness/utils/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeJwt = void 0;
+function decodeJwt(token) {
+    return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+}
+exports.decodeJwt = decodeJwt;

package/dist/node/liveness/utils/types.d.ts

@@ -0,0 +1,6 @@
+import { type Data } from 'ws';
+import { type ISDKOptions } from '../../../utils/types';
+export type TNodeSDKOptions = ISDKOptions & {
+    getNextFrame: () => Promise<Data | null>;
+};
+export * from '../../../utils/types';

package/dist/node/liveness/utils/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../../utils/types"), exports);

package/dist/node/liveness/utils/websocket.d.ts

@@ -0,0 +1,5 @@
+import WebSocket from 'ws';
+import { type TNodeSDKOptions } from './types';
+export declare function waitForWebSocketConnection(websocket: WebSocket): Promise<void>;
+export declare function connectToWebSocket(options: TNodeSDKOptions): Promise<WebSocket>;
+export declare function disconnectFromWebSocket(websocket: WebSocket): void;

package/dist/node/liveness/utils/websocket.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disconnectFromWebSocket = exports.connectToWebSocket = exports.waitForWebSocketConnection = void 0;
+const ws_1 = __importDefault(require("ws"));
+const _1 = require(".");
+const constants_1 = require("../../../utils/constants");
+async function waitForWebSocketConnection(websocket) {
+    await new Promise((resolve) => {
+        const intervalKey = setInterval(() => {
+            if ([3, 1].includes(websocket.readyState)) {
+                clearInterval(intervalKey);
+                resolve();
+            }
+        }, 5);
+    });
+    if (websocket.readyState === 3) {
+        throw new Error('Cannot connect to server');
+    }
+}
+exports.waitForWebSocketConnection = waitForWebSocketConnection;
+async function connectToWebSocket(options) {
+    var _a;
+    const decodedToken = (0, _1.decodeJwt)(options.token);
+    const query = `?x_endpoint_api_userinfo=${options.token}&domain=${decodedToken.claims.domain}&track=${options.track}&customerRequestId=${options.customId}`;
+    const websocket = new ws_1.default(`${(_a = options.customWebSocketUrl) !== null && _a !== void 0 ? _a : constants_1.WEBSOCKET_BASE_URL}${query}`);
+    await waitForWebSocketConnection(websocket);
+    return websocket;
+}
+exports.connectToWebSocket = connectToWebSocket;
+function disconnectFromWebSocket(websocket) {
+    var _a;
+    if (![2, 3].includes(websocket.readyState)) {
+        (_a = websocket.close) === null || _a === void 0 ? void 0 : _a.call(websocket);
+    }
+}
+exports.disconnectFromWebSocket = disconnectFromWebSocket;

package/dist/utils/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const WEBSOCKET_BASE_URL = "ws://santoid-liveness-w4ynos5dlq-ue.a.run.app/ws";
+export declare const API_GATEWAY_URL = "https://api.santoid.com.br/api/v1/service-account/refresh-token";
+export declare const SEND_FRAMES_INTERVAL_MS = 100;

package/dist/utils/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEND_FRAMES_INTERVAL_MS = exports.API_GATEWAY_URL = exports.WEBSOCKET_BASE_URL = void 0;
+exports.WEBSOCKET_BASE_URL = 'ws://santoid-liveness-w4ynos5dlq-ue.a.run.app/ws';
+exports.API_GATEWAY_URL = 'https://api.santoid.com.br/api/v1/service-account/refresh-token';
+exports.SEND_FRAMES_INTERVAL_MS = 100;

package/dist/utils/types.d.ts

@@ -0,0 +1,31 @@
+export type TCallbackFunction = (...args: any[]) => void | Promise<void>;
+export type TPositions = 'front' | 'right' | 'left' | 'up' | 'bottom';
+export type TErrorCode = 'wrong-position' | 'internal-error';
+export interface IDecodedToken {
+    claims: {
+        domain: string;
+    };
+}
+export interface ISDKOptions {
+    token: string;
+    track: string;
+    customId?: string;
+    nextStepCallback?: (step: TPositions) => void | Promise<void>;
+    frontCallback?: TCallbackFunction;
+    rightCallback?: TCallbackFunction;
+    leftCallback?: TCallbackFunction;
+    upCallback?: TCallbackFunction;
+    bottomCallback?: TCallbackFunction;
+    errorCallback?: (error: {
+        code: TErrorCode;
+    }) => void | Promise<void>;
+    successCallback?: TCallbackFunction;
+    endCallback?: TCallbackFunction;
+    customWebSocketUrl?: string;
+}
+export interface IWebSocketMessage {
+    success?: boolean;
+    error?: boolean;
+    can_send_next_bytes?: boolean;
+    next_step?: TPositions;
+}

package/dist/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "santoid-sdk",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/esm/liveness/index.js",
+  "types": "dist/esm/liveness/index.d.ts",
+  "scripts": {
+    "expose:cmd": "mv -v dist/* ./",
+    "dev:webpack": "webpack --mode=development --watch --progress",
+    "build:browser-node": "webpack --mode=production",
+    "build:typescript": "rm -rf ./dist/esm && tsc",
+    "build": "npm run build:typescript && npm run build:browser-node"
+  },
+  "exports": {
+    ".": "./dist",
+    "./liveness": "./dist/esm/liveness/index.js",
+    "./node/liveness": "./dist/node/liveness/index.js",
+    "./node/auth": "./dist/node/auth/index.js"
+  },
+  "typesVersions": {
+    "*": {
+      "liveness": [
+        "dist/esm/liveness/index.d.ts"
+      ],
+      "node/liveness": [
+        "dist/node/liveness/index.d.ts"
+      ],
+      "node/auth": [
+        "dist/node/auth/index.d.ts"
+      ]
+    }
+  },
+  "keywords": [],
+  "author": "SantoDigital",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^20.6.2",
+    "@types/ws": "^8.5.6",
+    "@typescript-eslint/eslint-plugin": "^6.4.0",
+    "clean-webpack-plugin": "^4.0.0",
+    "eslint": "^8.0.1",
+    "eslint-config-standard-with-typescript": "^39.0.0",
+    "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-n": "^15.0.0 || ^16.0.0 ",
+    "eslint-plugin-promise": "^6.0.0",
+    "ts-loader": "^9.4.4",
+    "ts-node": "^10.9.1",
+    "typescript": "*",
+    "webpack": "^5.88.2",
+    "webpack-cli": "^5.1.4",
+    "webpack-node-externals": "^3.0.0"
+  },
+  "dependencies": {
+    "ws": "^8.14.2"
+  }
+}

package/src/esm/liveness/index.ts

@@ -0,0 +1,134 @@
+import { type IWebSocketMessage, type TWebSDKOptions } from './utils/types'
+import { SEND_FRAMES_INTERVAL_MS } from '../../utils/constants'
+import { builtInGetNextFrame, type builtInGetNextFrameReturn } from './utils/getNextFrame'
+
+import { connectToWebSocket, disconnectFromWebSocket } from './utils/websocket'
+
+export * from './utils/types'
+
+async function onWebSocketMessage (options: TWebSDKOptions, event: MessageEvent) {
+  const message = event.data
+
+  let messageObj: IWebSocketMessage | undefined
+
+  try {
+    messageObj = JSON.parse(message)
+  } catch (err) {
+    console.error('Cannot parse API message', err)
+  }
+
+  if (messageObj?.next_step && !messageObj.error) {
+    await options.nextStepCallback?.(messageObj.next_step)
+    await options[`${messageObj.next_step}Callback`]?.()
+  }
+
+  if (messageObj?.error) {
+    await options.errorCallback?.({ code: 'wrong-position' })
+  }
+
+  return messageObj
+}
+
+export async function livenessDetection (options: TWebSDKOptions) {
+  let websocketClosedBySDK = false
+  let builtInGetNextFrameReturn: builtInGetNextFrameReturn | undefined
+  let validationSuccess = false
+  let endCalled = false
+
+  async function stopLivenessDetection (options: TWebSDKOptions, websocket?: WebSocket, intervalKey?: any) {
+    if (intervalKey) {
+      clearInterval(intervalKey)
+    }
+
+    if (websocket) {
+      disconnectFromWebSocket(websocket)
+    }
+
+    if (builtInGetNextFrameReturn) {
+      builtInGetNextFrameReturn.stopGetNextFrame()
+    }
+
+    !endCalled && await options.endCallback?.()
+    endCalled = true
+
+    websocketClosedBySDK = true
+  }
+
+  let sendFramesIntervalKey: any
+  let websocket: WebSocket | undefined
+
+  try {
+    websocket = await connectToWebSocket(options)
+
+    await options.nextStepCallback?.('front')
+    await options.frontCallback?.()
+
+    let lastMessage: IWebSocketMessage | undefined
+
+    if (!options.getNextFrame && !builtInGetNextFrameReturn) {
+      builtInGetNextFrameReturn = await builtInGetNextFrame()
+    }
+
+    sendFramesIntervalKey = setInterval(async () => {
+      try {
+        if (lastMessage?.can_send_next_bytes) {
+          let bytes
+
+          if (options.getNextFrame) {
+            bytes = await options.getNextFrame()
+          } else {
+            bytes = await builtInGetNextFrameReturn?.getNextFrame()
+          }
+
+          if (bytes) {
+            websocket?.send(bytes)
+          }
+        }
+      } catch (err) {
+        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
+      }
+    }, SEND_FRAMES_INTERVAL_MS)
+
+    websocket.addEventListener('message', async (event) => {
+      const parsedMessage = await onWebSocketMessage(options, event)
+
+      if (parsedMessage) {
+        lastMessage = parsedMessage
+      }
+
+      if (parsedMessage?.success) {
+        validationSuccess = true
+        await options.successCallback?.()
+        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
+      }
+    })
+
+    websocket.addEventListener('error', async () => {
+      !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
+      await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
+    })
+
+    websocket.addEventListener('close', async () => {
+      if (!websocketClosedBySDK) {
+        !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
+        await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
+      }
+    })
+
+    lastMessage = { can_send_next_bytes: true }
+
+    return {
+      stopLivenessDetection: async () => { await stopLivenessDetection(options, websocket, sendFramesIntervalKey) },
+      videoStream: builtInGetNextFrameReturn?.videoStream,
+    }
+  } catch (err) {
+    !validationSuccess && options.errorCallback?.({ code: 'internal-error' })
+    await stopLivenessDetection(options, websocket, sendFramesIntervalKey)
+    throw err
+  }
+}
+
+// Class for use in browsers
+export default class SantoiDSDK {
+  static livenessDetection = livenessDetection
+}

package/src/esm/liveness/utils/getNextFrame.ts

@@ -0,0 +1,71 @@
+export interface builtInGetNextFrameReturn {
+  getNextFrame: () => Promise<Blob | null>
+  stopGetNextFrame: () => void
+  videoStream: MediaStream | undefined
+}
+
+export async function builtInGetNextFrame (): Promise<builtInGetNextFrameReturn> {
+  let videoStream: MediaStream | undefined
+  let videoElement: HTMLVideoElement | undefined
+  let canvasElement: HTMLCanvasElement | undefined
+
+  async function getNextFrame (): Promise<Blob | null> {
+    if (canvasElement && videoElement) {
+      const ctx = canvasElement.getContext('2d')
+
+      canvasElement.width = videoElement.videoWidth
+      canvasElement.height = videoElement.videoHeight
+
+      ctx?.drawImage(videoElement, 0, 0, canvasElement.width, canvasElement.height)
+
+      return await new Promise((resolve, reject) => {
+        if (!canvasElement) {
+          resolve(null)
+          return
+        }
+
+        canvasElement.toBlob((blob) => {
+          resolve(blob)
+        })
+      })
+    } else {
+      throw new Error('Cannot found video element')
+    }
+  }
+
+  function stopGetNextFrame () {
+    if (videoElement) {
+      document.body.removeChild(videoElement)
+      videoElement = undefined
+    }
+
+    if (canvasElement) {
+      canvasElement = undefined
+    }
+
+    videoStream?.getTracks().forEach(track => { track.stop() })
+    videoStream = undefined
+  }
+
+  if (!videoStream || !videoElement || !canvasElement) {
+    videoStream = await navigator.mediaDevices.getUserMedia({ video: true })
+
+    videoElement = document.createElement('video')
+    videoElement.setAttribute('autoplay', 'true')
+
+    videoElement.style.position = 'absolute'
+    videoElement.style.left = '99999px'
+
+    document.body.appendChild(videoElement)
+
+    videoElement.srcObject = videoStream
+
+    canvasElement = document.createElement('canvas')
+  }
+
+  return {
+    getNextFrame,
+    stopGetNextFrame,
+    videoStream,
+  }
+}

package/src/esm/liveness/utils/index.ts

@@ -0,0 +1,16 @@
+export function decodeJwt (token: string) {
+  const base64Url = token.split('.')[1]
+  const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/')
+
+  const jsonPayload = decodeURIComponent(
+    window
+      .atob(base64)
+      .split('')
+      .map((c) => {
+        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)
+      })
+      .join(''),
+  )
+
+  return JSON.parse(jsonPayload)
+}

package/src/esm/liveness/utils/types.ts

@@ -0,0 +1,7 @@
+import { type ISDKOptions } from '../../../utils/types'
+
+export type TWebSDKOptions = ISDKOptions & {
+  getNextFrame?: () => Promise<Blob | null>
+}
+
+export * from '../../../utils/types'

package/src/esm/liveness/utils/websocket.ts

@@ -0,0 +1,33 @@
+import { decodeJwt } from '.'
+import { WEBSOCKET_BASE_URL } from '../../../utils/constants'
+import { type IDecodedToken, type TWebSDKOptions } from './types'
+
+async function waitForWebSocketConnection (websocket: WebSocket) {
+  await new Promise<void>((resolve) => {
+    const intervalKey = setInterval(() => {
+      if ([3, 1].includes(websocket.readyState)) {
+        clearInterval(intervalKey)
+        resolve()
+      }
+    }, 5)
+  })
+
+  if (websocket.readyState === 3) {
+    throw new Error('Cannot connect to server')
+  }
+}
+
+export async function connectToWebSocket (options: TWebSDKOptions) {
+  const decodedToken: IDecodedToken = decodeJwt(options.token)
+  const query = `?x_endpoint_api_userinfo=${options.token}&domain=${decodedToken.claims.domain}&track=${options.track}&customerRequestId=${options.customId}`
+
+  const websocket = new WebSocket(`${options.customWebSocketUrl ?? WEBSOCKET_BASE_URL}${query}`)
+  await waitForWebSocketConnection(websocket)
+  return websocket
+}
+
+export function disconnectFromWebSocket (websocket: WebSocket) {
+  if (![2, 3].includes(websocket.readyState)) {
+    websocket.close?.()
+  }
+}

package/src/node/auth/index.ts

@@ -0,0 +1,43 @@
+import fs from 'fs'
+import { API_GATEWAY_URL } from '../../utils/constants'
+
+export interface IInitalizeOptions {
+  customApiUrl?: string
+  credentials?: string | Record<string, string>
+}
+
+export async function initialize (options?: IInitalizeOptions) {
+  let credentialsBase64
+
+  if (options?.credentials) {
+    if (typeof options?.credentials === 'string') {
+      credentialsBase64 = options?.credentials
+    } else if (typeof options?.credentials === 'object') {
+      credentialsBase64 = Buffer.from(JSON.stringify(options?.credentials)).toString('base64')
+    } else {
+      throw new Error('Invalid credentials')
+    }
+  } else {
+    if (process.env.SANTOID_SDK_CREDENTIALS) {
+      credentialsBase64 = fs.readFileSync(process.env.SANTOID_SDK_CREDENTIALS, { encoding: 'base64' })
+    } else {
+      throw new Error('Credentials not found')
+    }
+  }
+
+  if (credentialsBase64) {
+    const response = await fetch(options?.customApiUrl ?? API_GATEWAY_URL, {
+      method: 'POST',
+      body: JSON.stringify({ service_account_base64: credentialsBase64 }),
+      headers: { 'Content-Type': 'application/json' },
+    })
+
+    const token = await response.json()
+
+    if (typeof token !== 'string') {
+      throw new Error('Cannot generate token')
+    }
+
+    return token
+  }
+}