@moneypot/hub 0.0.1

package/dist/src/db/index.d.ts

@@ -0,0 +1,89 @@
+import pg, { QueryResult, QueryResultRow } from "pg";
+import stream from "node:stream";
+import { DbCasino, DbExperience, DbSession, DbTransferStatusKind, DbUser, DbWithdrawal } from "./types.js";
+import { TransferStatusKind } from "../__generated__/graphql.js";
+export * from "./types.js";
+export * from "./public.js";
+export * from "./util.js";
+export declare function getPgClient(connectionString: string): pg.Client;
+export declare const postgraphilePool: pg.Pool;
+export declare const superuserPool: pg.Pool;
+interface QueryExecutor {
+    query<T extends QueryResultRow = QueryResultRow>(_queryText: string, _values?: unknown[]): Promise<QueryResult<T>>;
+}
+export declare class UserFriendlyError extends Error {
+    constructor(userFriendlyMessage: string);
+}
+export declare function withPgPoolTransaction<T>(pool: pg.Pool, callback: (_client: pg.PoolClient) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
+export declare function userFromActiveSessionKey(pool: pg.Pool, sessionKey: string): Promise<{
+    user: DbUser;
+    sessionId: DbSession["id"];
+} | null>;
+declare class DatabaseNotifier extends stream.EventEmitter {
+    private client;
+    constructor(connectionString: string);
+    close(): Promise<void>;
+    listen(): Promise<void>;
+}
+export declare const notifier: DatabaseNotifier;
+export declare function getTransferCursor(pool: pg.Pool, { casinoId, }: {
+    casinoId: string;
+}): Promise<string | undefined>;
+export declare function setTransferCursor(pool: pg.Pool, { cursor, casinoId, }: {
+    casinoId: string;
+    cursor: string;
+}): Promise<void>;
+export declare function upsertUser(pool: pg.Pool, { uname, casinoId, mpUserId, }: {
+    uname: string;
+    casinoId: string;
+    mpUserId: string;
+}): Promise<DbUser>;
+export declare function upsertExperience(pool: pg.Pool, { casinoId, mpExperienceId, name, }: {
+    casinoId: string;
+    mpExperienceId: string;
+    name: string;
+}): Promise<DbExperience>;
+export declare function insertDeposit(pool: pg.Pool, o: {
+    casinoId: string;
+    mpTransferId: string;
+    userId: string;
+    experienceId: string;
+    amount: number;
+    currency: string;
+}): Promise<null | undefined>;
+export declare function processWithdrawal(pool: pg.Pool, { casinoId, mpTransferId, userId, experienceId, amount, currency, status, }: {
+    casinoId: string;
+    mpTransferId: string;
+    userId: string;
+    experienceId: string;
+    amount: number;
+    currency: string;
+    status: Extract<TransferStatusKind, "PENDING" | "COMPLETED" | "CANCELED">;
+}): Promise<void>;
+export declare function getUnconfirmedWithdrawals(pool: pg.Pool, { casinoId, limit, }: {
+    casinoId: string;
+    limit: number;
+}): Promise<(DbWithdrawal & {
+    mp_experience_id: string;
+    mp_user_id: string;
+})[]>;
+export declare function getPendingWithdrawals(pool: pg.Pool, { casinoId, limit, }: {
+    casinoId: string;
+    limit: number;
+}): Promise<(DbWithdrawal & {
+    mp_experience_id: string;
+    mp_user_id: string;
+})[]>;
+export declare function settleWithdrawal({ withdrawalId, newStatus, }: {
+    withdrawalId: string;
+    newStatus: Extract<DbTransferStatusKind, "COMPLETED" | "CANCELED">;
+}): Promise<void>;
+export declare function listCasinos(pool: pg.Pool): Promise<DbCasino[]>;
+export declare function upsertCurrencies(pgClient: QueryExecutor, { casinoId, currencies, }: {
+    casinoId: string;
+    currencies: {
+        id: string;
+        displayUnitName: string;
+        displayUnitScale: number;
+    }[];
+}): Promise<pg.QueryResult<pg.QueryResultRow>>;

package/dist/src/db/index.js

@@ -0,0 +1,339 @@
+import pg from "pg";
+import config from "../config.js";
+import stream from "node:stream";
+import { exactlyOneRow, maybeOneRow } from "./util.js";
+import { logger } from "../logger.js";
+import { setTimeout } from "node:timers/promises";
+import { assert } from "tsafe";
+export * from "./types.js";
+export * from "./public.js";
+export * from "./util.js";
+export function getPgClient(connectionString) {
+    const client = new pg.Client({ connectionString });
+    return client;
+}
+export const postgraphilePool = new pg.Pool({
+    connectionString: config.DATABASE_URL,
+    allowExitOnIdle: config.NODE_ENV !== "production",
+});
+export const superuserPool = new pg.Pool({
+    connectionString: config.SUPERUSER_DATABASE_URL,
+    allowExitOnIdle: config.NODE_ENV !== "production",
+});
+export class UserFriendlyError extends Error {
+    constructor(userFriendlyMessage) {
+        super(userFriendlyMessage);
+        this.name = "UserFriendlyError";
+    }
+}
+const PG_ERROR_CODE = {
+    deadlock: "40P01",
+    serializationFailure: "40001",
+};
+export async function withPgPoolTransaction(pool, callback, retryCount = 0, maxRetries = 3) {
+    let client = null;
+    try {
+        client = await pool.connect();
+        await client.query("begin isolation level serializable");
+        const result = await callback(client);
+        await client.query("commit");
+        return result;
+    }
+    catch (error) {
+        if (client) {
+            try {
+                await client.query("rollback");
+            }
+            catch (rollbackError) {
+                logger.error("Original error:", error);
+                logger.error("Rollback failed:", rollbackError);
+                client.release(true);
+                client = null;
+                throw error;
+            }
+            if (retryCount < maxRetries &&
+                error instanceof pg.DatabaseError &&
+                (error.code === PG_ERROR_CODE.deadlock ||
+                    error.code === PG_ERROR_CODE.serializationFailure)) {
+                const backoffMs = Math.min(100 * Math.pow(2, retryCount), 2000);
+                logger.warn(`Rerunning in ${backoffMs}ms (attempt ${retryCount + 1}/${maxRetries}) due to pg error code ${error.code}`);
+                await setTimeout(backoffMs);
+                return withPgPoolTransaction(pool, callback, retryCount + 1, maxRetries);
+            }
+        }
+        throw error;
+    }
+    finally {
+        if (client) {
+            client.release();
+        }
+    }
+}
+export async function userFromActiveSessionKey(pool, sessionKey) {
+    const result = await pool
+        .query(`
+        select u.id, u.uname, u.casino_id, s.experience_id, u.mp_user_id, s.id as session_id
+        from hub.active_session s
+        join hub.user u on s.user_id = u.id
+        join hub.experience e on e.id = s.experience_id
+        where s.key = $1
+    `, [sessionKey])
+        .then(maybeOneRow);
+    if (!result) {
+        return null;
+    }
+    const { session_id, ...user } = result;
+    return {
+        user,
+        sessionId: session_id,
+    };
+}
+class DatabaseNotifier extends stream.EventEmitter {
+    client;
+    constructor(connectionString) {
+        super();
+        this.client = new pg.Client({ connectionString });
+    }
+    async close() {
+        await this.client.end();
+        logger.info("[DatabaseNotifier] Database connection closed");
+    }
+    async listen() {
+        logger.info("[DatabaseNotifier] listening for balance updates");
+        await this.client.connect();
+        await this.client.query("LISTEN balance_update");
+        this.client.on("notification", (notification) => {
+            if (!notification.payload) {
+                logger.error("[DatabaseNotifier] postgres notification missing payload");
+                return;
+            }
+            const payload = JSON.parse(notification.payload);
+            switch (notification.channel) {
+                case "balance_update":
+                    this.emit(`balance:${payload.user_id}:${payload.experience_id}`, {
+                        currencyKey: payload.currency_key,
+                        amount: payload.amount,
+                    });
+                    break;
+            }
+        });
+    }
+}
+export const notifier = new DatabaseNotifier(config.DATABASE_URL);
+export async function getTransferCursor(pool, { casinoId, }) {
+    const row = await pool
+        .query("select cursor from hub_hidden.transfer_cursor where casino_id = $1", [casinoId])
+        .then(maybeOneRow);
+    return row?.cursor;
+}
+export async function setTransferCursor(pool, { cursor, casinoId, }) {
+    console.log(`[setTransferCursor] SETTING CURSOR..... ${cursor}`);
+    await pool.query(`
+    insert into hub_hidden.transfer_cursor (casino_id, cursor)
+    values ($1, $2)
+    on conflict (casino_id) do update set cursor = $2
+    returning cursor
+    `, [casinoId, cursor]);
+}
+export async function upsertUser(pool, { uname, casinoId, mpUserId, }) {
+    const user = await pool
+        .query(`
+        WITH ins AS (
+            INSERT INTO hub.user (casino_id, mp_user_id, uname)
+            VALUES ($1, $2, $3)
+            ON CONFLICT (casino_id, mp_user_id) DO NOTHING
+            RETURNING *
+        )
+        SELECT * FROM ins
+        UNION ALL
+        SELECT * FROM hub.user
+        WHERE casino_id = $1 AND mp_user_id = $2
+        LIMIT 1;
+    `, [casinoId, mpUserId, uname])
+        .then(exactlyOneRow);
+    return user;
+}
+export async function upsertExperience(pool, { casinoId, mpExperienceId, name, }) {
+    return pool
+        .query(`
+            WITH ins AS (
+                INSERT INTO hub.experience (casino_id, mp_experience_id, name)
+                VALUES ($1, $2, $3)
+                ON CONFLICT (casino_id, mp_experience_id) DO NOTHING
+                RETURNING *
+            )
+            SELECT * FROM ins
+            UNION ALL
+            SELECT * FROM hub.experience
+            WHERE casino_id = $1 AND mp_experience_id = $2
+            LIMIT 1;
+        `, [casinoId, mpExperienceId, name])
+        .then(exactlyOneRow);
+}
+export async function insertDeposit(pool, o) {
+    if (o.amount <= 0) {
+        throw new UserFriendlyError("amount must be positive");
+    }
+    return withPgPoolTransaction(pool, async (client) => {
+        const result = await client.query(`
+        INSERT INTO hub.deposit(casino_id, mp_transfer_id, user_id, experience_id, amount, currency_key)
+        VALUES ($1, $2, $3, $4, $5, $6)
+        ON CONFLICT (casino_id, mp_transfer_id) DO NOTHING
+        RETURNING id
+      `, [
+            o.casinoId,
+            o.mpTransferId,
+            o.userId,
+            o.experienceId,
+            o.amount,
+            o.currency,
+        ]);
+        if (result.rowCount === 0) {
+            return null;
+        }
+        await client.query(`
+        insert into hub.balance(casino_id, user_id, experience_id, currency_key, amount)
+        values ($1, $2, $3, $4, $5)
+        on conflict (casino_id, user_id, experience_id, currency_key) do update
+        set amount = balance.amount + excluded.amount
+      `, [o.casinoId, o.userId, o.experienceId, o.currency, o.amount]);
+    });
+}
+export async function processWithdrawal(pool, { casinoId, mpTransferId, userId, experienceId, amount, currency, status, }) {
+    return withPgPoolTransaction(pool, async (client) => {
+        await client.query(`
+      INSERT INTO hub.withdrawal (
+        casino_id, 
+        mp_transfer_id, 
+        user_id, 
+        uname,
+        experience_id, 
+        amount, 
+        currency_key,
+        status,
+        status_at
+      )
+      VALUES ($1, $2, $3, $4, $5, $6, $7::hub.transfer_status_kind, now())
+      ON CONFLICT (casino_id, mp_transfer_id) DO UPDATE 
+      SET status = EXCLUDED.status,
+          status_at = CASE 
+            WHEN withdrawal.status != EXCLUDED.status
+            THEN now() 
+            ELSE withdrawal.status_at 
+          END
+      `, [
+            casinoId,
+            mpTransferId,
+            userId,
+            experienceId,
+            amount,
+            currency,
+            status,
+        ]);
+    });
+}
+export async function getUnconfirmedWithdrawals(pool, { casinoId, limit, }) {
+    const result = await pool.query(`
+        select 
+          e.mp_experience_id mp_experience_id, 
+          u.mp_user_id mp_user_id,
+          w.* 
+        from hub.withdrawal w
+        join hub.experience e on w.experience_id = e.id
+        join hub.user u on w.user_id = u.id
+        where w.casino_id = $1 
+          and w.mp_transfer_id is null
+        order by w.id asc
+        limit $2
+    `, [casinoId, limit]);
+    return result.rows;
+}
+export async function getPendingWithdrawals(pool, { casinoId, limit, }) {
+    const result = await pool.query(`
+        select 
+          e.mp_experience_id mp_experience_id, 
+          u.mp_user_id mp_user_id,
+          w.* 
+        from hub.withdrawal w
+        join hub.experience e on w.experience_id = e.id
+        join hub.user u on w.user_id = u.id
+        where w.casino_id = $1 
+          and w.status = 'PENDING'
+        order by w.id asc
+        limit $2
+    `, [casinoId, limit]);
+    return result.rows;
+}
+export async function settleWithdrawal({ withdrawalId, newStatus, }) {
+    return withPgPoolTransaction(superuserPool, async (pgClient) => {
+        const dbWithdrawal = await pgClient
+            .query(`
+        select * 
+        from hub.withdrawal
+        where id = $1
+
+        FOR UPDATE
+
+      `, [withdrawalId])
+            .then(maybeOneRow);
+        assert(dbWithdrawal, `Expected to find PENDING withdrawal by id ${withdrawalId}`);
+        assert(dbWithdrawal.status === "PENDING", `Expected PENDING withdrawal, got ${dbWithdrawal.status}`);
+        await pgClient.query(`
+        update hub.withdrawal
+        set status = $1,
+            status_at = now()
+        where id = $2
+      `, [newStatus, withdrawalId]);
+        if (newStatus === "CANCELED") {
+            await pgClient.query(`
+            select 1
+            from hub.balance
+            where casino_id = $1
+              and user_id = $2
+              and experience_id = $3
+              and currency_key = $4
+              
+            FOR UPDATE
+          `, [
+                dbWithdrawal.casino_id,
+                dbWithdrawal.user_id,
+                dbWithdrawal.experience_id,
+                dbWithdrawal.currency_key,
+            ]);
+            await pgClient.query(`
+        insert into hub.balance(casino_id, user_id, experience_id, currency_key, amount)
+        values ($1, $2, $3, $4, $5)
+        on conflict (casino_id, user_id, experience_id, currency_key) do update
+        set amount = balance.amount + excluded.amount
+      `, [
+                dbWithdrawal.casino_id,
+                dbWithdrawal.user_id,
+                dbWithdrawal.experience_id,
+                dbWithdrawal.currency_key,
+                dbWithdrawal.amount,
+            ]);
+        }
+    });
+}
+export async function listCasinos(pool) {
+    const result = await pool.query("select * from hub.casino");
+    return result.rows;
+}
+export async function upsertCurrencies(pgClient, { casinoId, currencies, }) {
+    const values = currencies
+        .map((_, index) => `($1, $${index * 3 + 2}, $${index * 3 + 3}, $${index * 3 + 4})`)
+        .join(", ");
+    const query = `
+    INSERT INTO hub.currency(casino_id, key, display_unit_name, display_unit_scale)
+    VALUES ${values}
+    ON CONFLICT (casino_id, key) 
+    DO UPDATE SET 
+      display_unit_name = EXCLUDED.display_unit_name,
+      display_unit_scale = EXCLUDED.display_unit_scale
+  `;
+    const queryParams = [casinoId];
+    for (const c of currencies) {
+        queryParams.push(c.id, c.displayUnitName, String(c.displayUnitScale));
+    }
+    return pgClient.query(query, queryParams);
+}

package/dist/src/db/internal.d.ts

@@ -0,0 +1,7 @@
+import { Pool } from "pg";
+import { DbCasino, DbCasinoSecret } from "./types.js";
+type NewCasino = Pick<DbCasino, "name" | "base_url" | "graphql_url"> & Pick<DbCasinoSecret, "controller_id" | "api_key">;
+export declare function dbInsertCasino(pool: Pool, input: NewCasino): Promise<DbCasino>;
+export declare function dbGetCasinoById(pool: Pool, casinoId: DbCasino["id"]): Promise<DbCasino | undefined>;
+export declare function dbGetCasinoSecretById(pool: Pool, casinoId: DbCasino["id"]): Promise<DbCasinoSecret | undefined>;
+export {};

package/dist/src/db/internal.js

@@ -0,0 +1,33 @@
+import { exactlyOneRow, maybeOneRow } from "./util.js";
+export async function dbInsertCasino(pool, input) {
+    const casino = await pool
+        .query(`
+    INSERT INTO hub.casino (name, base_url, graphql_url)
+    VALUES ($1, $2, $3)
+    RETURNING *
+  `, [input.name, input.base_url, input.graphql_url])
+        .then(exactlyOneRow);
+    await pool.query(`
+    INSERT INTO hub.casino_secret (id, controller_id, api_key)
+    VALUES ($1, $2, $3)
+  `, [casino.id, input.controller_id, input.api_key]);
+    return casino;
+}
+export async function dbGetCasinoById(pool, casinoId) {
+    return pool
+        .query(`
+    SELECT *
+    FROM hub.casino
+    WHERE id = $1
+  `, [casinoId])
+        .then(maybeOneRow);
+}
+export async function dbGetCasinoSecretById(pool, casinoId) {
+    return pool
+        .query(`
+    SELECT *
+    FROM hub.casino_secret
+    WHERE id = $1
+  `, [casinoId])
+        .then(maybeOneRow);
+}

package/dist/src/db/public.d.ts

@@ -0,0 +1,7 @@
+import * as pg from "pg";
+import { DbCurrency, DbSession } from "./types.js";
+export declare function getActiveSessionById(pgClient: pg.PoolClient, sessionId: string): Promise<DbSession | undefined>;
+export declare function getCasinoCurrencyByKey(pgClient: pg.PoolClient, { currencyKey, casinoId }: {
+    currencyKey: string;
+    casinoId: string;
+}): Promise<DbCurrency | undefined>;

package/dist/src/db/public.js

@@ -0,0 +1,20 @@
+import { maybeOneRow } from "./util.js";
+export async function getActiveSessionById(pgClient, sessionId) {
+    return pgClient
+        .query("select * from hub.active_session where id = $1", [
+        sessionId,
+    ])
+        .then(maybeOneRow);
+}
+export async function getCasinoCurrencyByKey(pgClient, { currencyKey, casinoId }) {
+    return pgClient
+        .query({
+        text: `
+        SELECT *
+        FROM hub.currency
+        WHERE key = $1 AND casino_id = $2
+      `,
+        values: [currencyKey, casinoId],
+    })
+        .then(maybeOneRow);
+}

package/dist/src/db/types.d.ts

@@ -0,0 +1,80 @@
+import * as jose from "jose";
+export type DbSession = {
+    id: string;
+    user_id: string;
+    experience_id: string;
+    casino_id: string;
+    key: string;
+};
+export type DbUser = {
+    id: string;
+    mp_user_id: string;
+    experience_id: string;
+    casino_id: string;
+    uname: string;
+};
+export type DbTransferStatusKind = "PENDING" | "COMPLETED" | "CANCELED" | "UNCLAIMED" | "EXPIRED";
+export type DbWithdrawal = {
+    id: string;
+    mp_transfer_id: string;
+    casino_id: string;
+    user_id: string;
+    experience_id: string;
+    uname: string;
+    amount: number;
+    currency_key: string;
+    status: DbTransferStatusKind;
+    status_at: Date;
+};
+export type DbWithdrawalRequest = {
+    id: string;
+    mp_transfer_id: string | null;
+    user_id: string;
+    experience_id: string;
+    casino_id: string;
+    currency_key: string;
+    amount: number;
+};
+export type DbDeposit = {
+    id: string;
+    mp_transfer_id: string;
+    casino_id: string;
+    user_id: string;
+    uname: string;
+    amount: number;
+    currency_key: string;
+};
+export type DbExperience = {
+    id: string;
+    casino_id: string;
+    mp_experience_id: string;
+};
+export type DbCasino = {
+    id: string;
+    name: string;
+    base_url: string;
+    graphql_url: string;
+};
+export type DbCasinoSecret = {
+    id: string;
+    controller_id: string;
+    api_key: string;
+};
+export type DbCurrency = {
+    key: string;
+    casino_id: string;
+    display_unit_name: string;
+    display_unit_scale: number;
+};
+export type DbCasinoJwks = {
+    casino_id: string;
+    jwks: jose.JSONWebKeySet;
+    updated_at: Date;
+    forced_at: Date | null;
+};
+export type DbBankroll = {
+    id: string;
+    casino_id: string;
+    currency_key: string;
+    amount: number;
+};

package/dist/src/db/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/db/util.d.ts

@@ -0,0 +1,6 @@
+import { QueryResult, QueryResultRow } from "pg";
+import { PgClientResult } from "postgraphile/@dataplan/pg";
+type ResultType<T> = PgClientResult<T> | QueryResult<T extends QueryResultRow ? T : never>;
+export declare function maybeOneRow<T>(result: ResultType<T>): T | undefined;
+export declare function exactlyOneRow<T>(result: ResultType<T>): T;
+export {};

package/dist/src/db/util.js

@@ -0,0 +1,9 @@
+import { assert } from "tsafe";
+export function maybeOneRow(result) {
+    assert(result.rows.length <= 1, `maybeOneRow: Expected at most one row, got ${result.rows.length}`);
+    return result.rows[0];
+}
+export function exactlyOneRow(result) {
+    assert(result.rows.length === 1, `exactlyOneRow: Expected exactly one row, got ${result.rows.length}`);
+    return result.rows[0];
+}

package/dist/src/express.d.ts

@@ -0,0 +1,13 @@
+import { DbSession, DbUser } from "./db/types.js";
+import { Request } from "express";
+export { Express, Request, Response, Router, NextFunction } from "express";
+export interface HubRequest extends Request {
+    identity?: {
+        kind: "user";
+        user: DbUser;
+        sessionId: DbSession["id"];
+    } | {
+        kind: "operator";
+        apiKey: string;
+    };
+}

package/dist/src/express.js

@@ -0,0 +1 @@
+export { Router } from "express";

package/dist/src/grafast.d.ts

@@ -0,0 +1 @@
+export * from "postgraphile/grafast";

package/dist/src/grafast.js

@@ -0,0 +1 @@
+export * from "postgraphile/grafast";

package/dist/src/graphile.d.ts

@@ -0,0 +1 @@
+export { makeExtendSchemaPlugin, gql } from "postgraphile/utils";

package/dist/src/graphile.js

@@ -0,0 +1 @@
+export { makeExtendSchemaPlugin, gql } from "postgraphile/utils";

package/dist/src/graphql-client.d.ts

@@ -0,0 +1,6 @@
+import { GraphQLClient } from "graphql-request";
+import { DbCasino, DbCasinoSecret } from "./db/index.js";
+export declare function createGraphqlClient({ graphqlUrl, apiKey, }: {
+    graphqlUrl: DbCasino["graphql_url"];
+    apiKey: DbCasinoSecret["api_key"];
+}): GraphQLClient;

package/dist/src/graphql-client.js

@@ -0,0 +1,8 @@
+import { GraphQLClient } from "graphql-request";
+export function createGraphqlClient({ graphqlUrl, apiKey, }) {
+    return new GraphQLClient(graphqlUrl, {
+        headers: {
+            Authorization: `apikey:${apiKey}`,
+        },
+    });
+}

package/dist/src/graphql-queries.d.ts

@@ -0,0 +1,18 @@
+export declare const GET_USER_FROM_USER_TOKEN: import("@graphql-typed-document-node/core").TypedDocumentNode<import("./__generated__/graphql.js").GetUserFromUserTokenMutation, import("./__generated__/graphql.js").Exact<{
+    token: import("./__generated__/graphql.js").Scalars["UUID"]["input"];
+}>>;
+export declare const START_PENDING_EXPERIENCE_TRANSFER: import("@graphql-typed-document-node/core").TypedDocumentNode<import("./__generated__/graphql.js").StartPendingExperienceTransferMutation, import("./__generated__/graphql.js").Exact<{
+    mpUserId: import("./__generated__/graphql.js").Scalars["UUID"]["input"];
+    mpExperienceId: import("./__generated__/graphql.js").Scalars["UUID"]["input"];
+    amount: import("./__generated__/graphql.js").Scalars["Int"]["input"];
+    currency: import("./__generated__/graphql.js").Scalars["String"]["input"];
+    metadata: import("./__generated__/graphql.js").Scalars["JSON"]["input"];
+}>>;
+export declare const PAGINATE_TRANSFERS: import("@graphql-typed-document-node/core").TypedDocumentNode<import("./__generated__/graphql.js").PaginateTransfersQuery, import("./__generated__/graphql.js").Exact<{
+    controllerId: import("./__generated__/graphql.js").Scalars["UUID"]["input"];
+    after?: import("./__generated__/graphql.js").InputMaybe<import("./__generated__/graphql.js").Scalars["Cursor"]["input"]>;
+    limit?: import("./__generated__/graphql.js").InputMaybe<import("./__generated__/graphql.js").Scalars["Int"]["input"]>;
+}>>;
+export declare const GET_CURRENCIES: import("@graphql-typed-document-node/core").TypedDocumentNode<import("./__generated__/graphql.js").GetCurrenciesQuery, import("./__generated__/graphql.js").Exact<{
+    [key: string]: never;
+}>>;