@riocrypto/common-server 1.0.2843 → 1.0.2845

package/build/clients/bitso-client.d.ts

@@ -91,6 +91,8 @@ declare class BitsoClient {
     createCryptoWithdrawal(amount: number, crypto: Crypto, address: string): Promise<Object>;
     getDepositByHash(hash: string): Promise<Object>;
     getDepositByConcepto(concepto: string): Promise<Object>;
+    listFundings(limit?: number): Promise<any[]>;
+    listWithdrawals(limit?: number): Promise<any[]>;
     signRequest(requestConfig: AxiosRequestConfig): AxiosRequestConfig;
 }
 export declare const buildBitsoClient: () => Promise<BitsoClient>;

package/build/clients/bitso-client.js

@@ -482,6 +482,44 @@ class BitsoClient {
             return data.payload.find((deposit) => deposit.details.concepto === concepto);
         });
     }
+    // List recent fundings (deposits) so callers can import exchange-native
+    // deposits done directly on Bitso. Bitso caps `limit` at 100 per page.
+    listFundings(limit = 100) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestConfig = {
+                method: "GET",
+                url: `${this.baseUrl}/api/v3/fundings/?limit=${limit}`,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            };
+            const signedRequestConfig = this.signRequest(requestConfig);
+            const { data } = yield this.axiosClient(signedRequestConfig);
+            if (!data.success) {
+                throw new Error("Error listing Bitso fundings");
+            }
+            return data.payload;
+        });
+    }
+    // List recent withdrawals so callers can import exchange-native withdrawals
+    // done directly on Bitso. Bitso caps `limit` at 100 per page.
+    listWithdrawals(limit = 100) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestConfig = {
+                method: "GET",
+                url: `${this.baseUrl}/api/v3/withdrawals/?limit=${limit}`,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            };
+            const signedRequestConfig = this.signRequest(requestConfig);
+            const { data } = yield this.axiosClient(signedRequestConfig);
+            if (!data.success) {
+                throw new Error("Error listing Bitso withdrawals");
+            }
+            return data.payload;
+        });
+    }
     signRequest(requestConfig) {
         var _a;
         const url = new URL(requestConfig.url || "");

package/build/clients/coincover-client.js

@@ -57,6 +57,9 @@ class CoincoverClient {
             [common_1.Crypto.SOL]: "solana",
             [common_1.Crypto.XLM]: "stellar",
             [common_1.Crypto.POL]: "matic-network",
+            // Synthetic catch-all for unmapped assets seen on imported treasury
+            // movements; it has no CoinGecko id and is never priced.
+            [common_1.Crypto.Other]: "",
         };
         this.axiosClient = (0, axios_with_logging_1.buildAxiosWithLogging)();
     }

package/build/clients/fireblocks-client.d.ts

@@ -51,6 +51,12 @@ declare class FireblocksClient {
     getSingularExchangeCryptoBalance(id: string, usdType: "usdc" | "usdt"): Promise<number>;
     getExchangeFiatBalance(): Promise<number>;
     getTransactions(vaultId: string, crypto: Crypto, nextPage?: string): Promise<any>;
+    listVaultTransactions(params: {
+        vaultId: string;
+        direction: "incoming" | "outgoing";
+        afterMs: number;
+        status?: string;
+    }): Promise<TransactionResponse[]>;
     getDepositAddress(vaultId: string, crypto: Crypto): Promise<string>;
     createVault(userId: string, name: string, type: "transactional", number?: number): Promise<string>;
     createWallet(vaultId: string, crypto: Crypto): Promise<{

package/build/clients/fireblocks-client.js

@@ -356,6 +356,45 @@ class FireblocksClient {
             return transactionData;
         });
     }
+    // Lists a vault's transactions in one direction (incoming = deposits to the
+    // vault, outgoing = withdrawals from the vault) created at/after `afterMs`
+    // (unix ms). Pages through all results. Used by the treasury import cron to
+    // detect movements performed directly in Fireblocks (not initiated by Rio).
+    //
+    // Note the SDK paging quirk (fireblocks-sdk-js#268): when a page filter is
+    // provided it takes priority over the next-page path, so we pass the filter
+    // only on the first request and the path on subsequent requests.
+    listVaultTransactions(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { vaultId, direction, afterMs, status } = params;
+            const filter = {
+                after: String(Math.floor(afterMs)),
+                orderBy: "createdAt",
+                limit: 200,
+            };
+            if (direction === "incoming") {
+                filter.destId = vaultId;
+            }
+            else {
+                filter.sourceId = vaultId;
+            }
+            if (status) {
+                filter.status = status;
+            }
+            const results = [];
+            let nextPage;
+            let pagesFetched = 0;
+            const MAX_PAGES = 20;
+            do {
+                const response = yield this.fireblocks.getTransactionsWithPageInfo(nextPage ? undefined : filter, nextPage);
+                results.push(...(response.transactions || []));
+                nextPage = ((_a = response.pageDetails) === null || _a === void 0 ? void 0 : _a.nextPage) || undefined;
+                pagesFetched += 1;
+            } while (nextPage && pagesFetched < MAX_PAGES);
+            return results;
+        });
+    }
     getDepositAddress(vaultId, crypto) {
         return __awaiter(this, void 0, void 0, function* () {
             let addresses = yield this.fireblocks.getDepositAddresses(vaultId, crypto);

package/build/clients/kraken-client.d.ts

@@ -33,18 +33,31 @@ export interface KrakenWithdrawInfo {
     amount: string;
     fee: string;
 }
+export interface KrakenLedgerEntry {
+    refid: string;
+    time: number;
+    type: string;
+    subtype: string;
+    aclass: string;
+    asset: string;
+    amount: string;
+    fee: string;
+    balance: string;
+}
 declare class KrakenClient {
     private apiKey;
     private env;
     private axiosClient;
     private decodedSecret;
     private lastNonce;
+    private requestQueue;
     private restBaseUrl;
     constructor(apiKey: string, apiSecret: string, env: RioEnv);
     private assertFundingAllowed;
     private nextNonce;
     private sign;
     private privatePost;
+    private executePrivatePost;
     getBalance(asset: string): Promise<number>;
     getAllBalances(assets: string[]): Promise<Record<string, number>>;
     getDepositMethods(asset: string): Promise<KrakenDepositMethod[]>;
@@ -55,6 +68,11 @@ declare class KrakenClient {
     getWithdrawStatus(asset: string, method?: string): Promise<KrakenFundingStatus[]>;
     getWithdrawStatusByRefid(asset: string, refid: string): Promise<KrakenFundingStatus | undefined>;
     getDepositByTxId(asset: string, txid: string): Promise<KrakenFundingStatus | undefined>;
+    getLedgers(params?: {
+        type?: string;
+        asset?: string;
+        start?: number;
+    }): Promise<Record<string, KrakenLedgerEntry>>;
 }
 export declare const buildKrakenClient: () => Promise<KrakenClient>;
 export type { KrakenClient };

package/build/clients/kraken-client.js

@@ -35,6 +35,12 @@ class KrakenClient {
         // Kraken nonces must strictly increase per key. We keep a monotonic floor so
         // two calls in the same millisecond can't produce a decreasing nonce.
         this.lastNonce = 0;
+        // Serialization queue for private requests. Even with strictly increasing
+        // nonces, concurrent private requests can arrive at Kraken out of order,
+        // which Kraken rejects as `EAPI:Invalid nonce`. Chaining every private
+        // request through this promise guarantees one in-flight request at a time so
+        // nonces always arrive in order.
+        this.requestQueue = Promise.resolve();
         this.decodedSecret = Buffer.from(apiSecret, "base64");
         this.axiosClient = (0, axios_with_logging_1.buildAxiosWithLogging)();
         this.restBaseUrl = getKrakenRestBaseUrl(env);
@@ -68,6 +74,17 @@ class KrakenClient {
             .digest("base64");
     }
     privatePost(method, params = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Queue behind any in-flight private request so nonces reach Kraken in
+            // strictly increasing order. The queue must survive individual failures,
+            // hence the `.catch` on the stored promise (the caller still sees the
+            // original rejection via `run`).
+            const run = this.requestQueue.then(() => this.executePrivatePost(method, params));
+            this.requestQueue = run.catch(() => undefined);
+            return run;
+        });
+    }
+    executePrivatePost(method, params = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const path = `/0/private/${method}`;
             const nonce = this.nextNonce();
@@ -184,6 +201,23 @@ class KrakenClient {
             return statuses.find((s) => s.txid === txid);
         });
     }
+    // ----- Ledgers -----
+    // Returns the ledger entries (keyed by ledger id) for the given filters.
+    // This is the authoritative source for fiat deposits/withdrawals, which do
+    // not appear in DepositStatus/WithdrawStatus. `start` is a unix timestamp in
+    // seconds; Kraken returns the most recent entries (max 50 per page) at or
+    // after it.
+    getLedgers(params = {}) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.privatePost("Ledgers", {
+                type: params.type,
+                asset: params.asset,
+                start: params.start,
+            });
+            return (_a = result === null || result === void 0 ? void 0 : result.ledger) !== null && _a !== void 0 ? _a : {};
+        });
+    }
 }
 // Cache a single client per process so the monotonic nonce floor is effective
 // process-wide; building a fresh client per call would reset it and risk

package/build/models/internal-transfer.d.ts

@@ -1,5 +1,5 @@
 import mongoose, { HydratedDocument } from "mongoose";
-import { InternalTransferType, TreasuryProvider, Fiat, Crypto, InternalTransferOriginStatus, InternalTransferDestinationStatus } from "@riocrypto/common";
+import { InternalTransferType, TreasuryProvider, Fiat, Crypto, InternalTransferOriginStatus, InternalTransferDestinationStatus, OtherProviderMetadata } from "@riocrypto/common";
 interface InternalTransferAttrs {
     createdAt: Date;
     adminId?: string;
@@ -8,6 +8,8 @@ interface InternalTransferAttrs {
     transferType: InternalTransferType;
     amount: number;
     currency: Fiat | Crypto;
+    otherCurrencyCode?: string;
+    isImported?: boolean;
     blockchainTxId?: string;
     reference?: string;
     SPEITrackingNumber?: string;
@@ -17,14 +19,18 @@ interface InternalTransferAttrs {
         providerId?: string;
         amountSent?: number;
         status: InternalTransferOriginStatus;
+        otherStatus?: string;
+        otherProviderMetadata?: OtherProviderMetadata;
     };
     destination: {
         provider: TreasuryProvider;
         providerId?: string;
         amountReceived?: number;
         status: InternalTransferDestinationStatus;
+        otherStatus?: string;
         notifyWhenCredited?: boolean;
         notifyWhenCompleted?: boolean;
+        otherProviderMetadata?: OtherProviderMetadata;
     };
 }
 interface InternalTransferDoc extends mongoose.Document {
@@ -34,6 +40,8 @@ interface InternalTransferDoc extends mongoose.Document {
     liquiditySourcingPlanId?: string;
     createdAt: Date;
     transferType: InternalTransferType;
+    otherCurrencyCode?: string;
+    isImported?: boolean;
     blockchainTxId?: string;
     reference?: string;
     SPEITrackingNumber?: string;
@@ -43,14 +51,18 @@ interface InternalTransferDoc extends mongoose.Document {
         providerId?: string;
         amountSent?: number;
         status: InternalTransferOriginStatus;
+        otherStatus?: string;
+        otherProviderMetadata?: OtherProviderMetadata;
     };
     destination: {
         provider: TreasuryProvider;
         providerId?: string;
         amountReceived?: number;
         status: InternalTransferDestinationStatus;
+        otherStatus?: string;
         notifyWhenCredited?: boolean;
         notifyWhenCompleted?: boolean;
+        otherProviderMetadata?: OtherProviderMetadata;
     };
     amount: number;
     currency: Fiat | Crypto;

package/build/models/internal-transfer.js

@@ -26,6 +26,13 @@ const buildInternalTransfer = (mongoose) => {
             enum: Object.values(common_1.InternalTransferType),
             required: true,
         },
+        otherCurrencyCode: {
+            type: String,
+        },
+        isImported: {
+            type: Boolean,
+            default: false,
+        },
         blockchainTxId: {
             type: String,
         },
@@ -55,6 +62,16 @@ const buildInternalTransfer = (mongoose) => {
                 enum: Object.values(common_1.InternalTransferOriginStatus),
                 required: true,
             },
+            otherStatus: {
+                type: String,
+            },
+            otherProviderMetadata: {
+                blockchainAddress: { type: String },
+                memo: { type: String },
+                bankAccountInfo: { type: String },
+                bankName: { type: String },
+                label: { type: String },
+            },
         },
         destination: {
             provider: {
@@ -73,6 +90,9 @@ const buildInternalTransfer = (mongoose) => {
                 enum: Object.values(common_1.InternalTransferDestinationStatus),
                 required: true,
             },
+            otherStatus: {
+                type: String,
+            },
             notifyWhenCredited: {
                 type: Boolean,
                 default: false,
@@ -81,6 +101,13 @@ const buildInternalTransfer = (mongoose) => {
                 type: Boolean,
                 default: false,
             },
+            otherProviderMetadata: {
+                blockchainAddress: { type: String },
+                memo: { type: String },
+                bankAccountInfo: { type: String },
+                bankName: { type: String },
+                label: { type: String },
+            },
         },
         amount: {
             type: Number,
@@ -99,6 +126,16 @@ const buildInternalTransfer = (mongoose) => {
             },
         },
     });
+    // Indexes to support dedup lookups when importing exchange-native activity.
+    InternalTransferSchema.index({
+        "origin.provider": 1,
+        "origin.providerId": 1,
+    });
+    InternalTransferSchema.index({
+        "destination.provider": 1,
+        "destination.providerId": 1,
+    });
+    InternalTransferSchema.index({ blockchainTxId: 1 });
     InternalTransferSchema.statics.build = (attrs) => {
         return new InternalTransfer(attrs);
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2843",
+  "version": "1.0.2845",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -28,7 +28,7 @@
     "@google-cloud/secret-manager": "^5.6.0",
     "@google-cloud/storage": "^7.19.0",
     "@hyperdx/node-opentelemetry": "^0.10.3",
-    "@riocrypto/common": "1.0.2647",
+    "@riocrypto/common": "1.0.2650",
     "@slack/web-api": "^7.15.0",
     "@types/express": "^4.17.25",
     "axios": "1.16.0",