@riocrypto/common-server 1.0.2842 → 1.0.2844

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/cluster-client.d.ts

@@ -180,7 +180,7 @@ declare class ClusterClient {
     stopExternalTradingAlgorithm(id: string): Promise<ExternalTradingAlgorithm>;
     getExternalTradingAlgorithm(id: string): Promise<ExternalTradingAlgorithm>;
     getExternalTrade(id: string): Promise<ExternalTrade>;
-    placeExternalTrade({ provider, type, originCurrency, destinationCurrency, requestedOriginAmount, requestedDestinationAmount, limitPrice, twoWaySettlementDateOffset, arbitrageSessionId, fxTradeId, timeInForce, valueDate, }: {
+    placeExternalTrade({ provider, type, originCurrency, destinationCurrency, requestedOriginAmount, requestedDestinationAmount, limitPrice, twoWaySettlementDateOffset, arbitrageSessionId, fxTradeId, internalTradeId, timeInForce, valueDate, }: {
         provider: ExternalTradingProvider;
         type: ExternalTradeType;
         originCurrency: Crypto | Fiat;
@@ -191,6 +191,7 @@ declare class ClusterClient {
         twoWaySettlementDateOffset?: number;
         arbitrageSessionId?: string;
         fxTradeId?: string;
+        internalTradeId?: string;
         timeInForce?: "day" | "gtc" | "ioc" | "fok";
         valueDate?: string;
     }): Promise<ExternalTrade>;

package/build/clients/cluster-client.js

@@ -654,7 +654,7 @@ class ClusterClient {
             return response.data;
         });
     }
-    placeExternalTrade({ provider, type, originCurrency, destinationCurrency, requestedOriginAmount, requestedDestinationAmount, limitPrice, twoWaySettlementDateOffset, arbitrageSessionId, fxTradeId, timeInForce, valueDate, }) {
+    placeExternalTrade({ provider, type, originCurrency, destinationCurrency, requestedOriginAmount, requestedDestinationAmount, limitPrice, twoWaySettlementDateOffset, arbitrageSessionId, fxTradeId, internalTradeId, timeInForce, valueDate, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.axios.post(`${this.baseUrl}/api/trading/external/trades`, {
                 provider,
@@ -667,6 +667,7 @@ class ClusterClient {
                 twoWaySettlementDateOffset,
                 arbitrageSessionId,
                 fxTradeId,
+                internalTradeId,
                 timeInForce,
                 valueDate,
             }, {

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

@@ -0,0 +1,78 @@
+import { RioEnv } from "@riocrypto/common";
+export declare const KRAKEN_ASSET_USD = "ZUSD";
+export interface KrakenDepositMethod {
+    method: string;
+    limit: string | boolean;
+    fee?: string;
+    "gen-address"?: boolean;
+    "address-setup-fee"?: string;
+}
+export interface KrakenDepositAddress {
+    address: string;
+    expiretm: string;
+    new?: boolean;
+    tag?: string;
+    memo?: string;
+}
+export interface KrakenFundingStatus {
+    method: string;
+    aclass: string;
+    asset: string;
+    refid: string;
+    txid: string;
+    info: string;
+    amount: string;
+    fee: string;
+    time: number;
+    status: string;
+    "status-prop"?: string;
+}
+export interface KrakenWithdrawInfo {
+    method: string;
+    limit: string;
+    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[]>;
+    getDepositAddresses(asset: string, method: string, isNew?: boolean): Promise<KrakenDepositAddress[]>;
+    getDepositStatus(asset: string, method?: string): Promise<KrakenFundingStatus[]>;
+    getWithdrawInfo(asset: string, key: string, amount: number): Promise<KrakenWithdrawInfo>;
+    withdraw(asset: string, key: string, amount: number): Promise<string>;
+    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

@@ -0,0 +1,253 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildKrakenClient = exports.KRAKEN_ASSET_USD = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const common_1 = require("@riocrypto/common");
+const axios_with_logging_1 = require("./axios-with-logging");
+const secret_manager_client_1 = require("./secret-manager-client");
+// Kraken REST hosts. There is no public Kraken spot testnet, but institutional
+// clients get a separate UAT environment. The host is selected purely from
+// RIO_ENV: only production talks to the live account; every other environment
+// points at the UAT host so it can never move funds on the real account.
+const KRAKEN_PROD_REST_BASE_URL = "https://api.kraken.com";
+const KRAKEN_UAT_REST_BASE_URL = "https://api.uat.kraken.com";
+const getKrakenRestBaseUrl = (env) => env === common_1.RioEnv.Production
+    ? KRAKEN_PROD_REST_BASE_URL
+    : KRAKEN_UAT_REST_BASE_URL;
+// Kraken Balance keys. Fiat USD is `ZUSD`; the stablecoins use their ticker.
+exports.KRAKEN_ASSET_USD = "ZUSD";
+class KrakenClient {
+    constructor(apiKey, apiSecret, env) {
+        this.apiKey = apiKey;
+        this.env = env;
+        // 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);
+    }
+    // Fail-closed guard: a non-production environment must never move funds
+    // against the LIVE Kraken host. The host is derived from RIO_ENV, so this
+    // also catches an unknown/unset RIO_ENV resolving to the live host.
+    assertFundingAllowed() {
+        const isLiveHost = this.restBaseUrl === KRAKEN_PROD_REST_BASE_URL;
+        if (this.env !== common_1.RioEnv.Production && isLiveHost) {
+            throw new Error("Refusing to move Kraken funds: a non-production environment is pointed at the live Kraken host.");
+        }
+    }
+    nextNonce() {
+        const now = Date.now();
+        const nonce = now > this.lastNonce ? now : this.lastNonce + 1;
+        this.lastNonce = nonce;
+        return nonce;
+    }
+    sign(path, nonce, postData) {
+        // API-Sign = base64( HMAC-SHA512( path + SHA256(nonce + postData),
+        // base64decode(secret) ) )
+        const sha256 = crypto_1.default
+            .createHash("sha256")
+            .update(nonce + postData)
+            .digest();
+        const message = Buffer.concat([Buffer.from(path, "utf8"), sha256]);
+        return crypto_1.default
+            .createHmac("sha512", this.decodedSecret)
+            .update(message)
+            .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();
+            const form = new URLSearchParams();
+            form.set("nonce", String(nonce));
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    form.set(key, String(value));
+                }
+            }
+            const postData = form.toString();
+            const signature = this.sign(path, nonce, postData);
+            const { data } = yield this.axiosClient.post(`${this.restBaseUrl}${path}`, postData, {
+                headers: {
+                    "API-Key": this.apiKey,
+                    "API-Sign": signature,
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+            });
+            // Kraken returns HTTP 200 with errors inside an `error` array.
+            if ((data === null || data === void 0 ? void 0 : data.error) && data.error.length > 0) {
+                throw new Error(`Kraken API error: ${data.error.join(", ")}`);
+            }
+            return data.result;
+        });
+    }
+    // ----- Balances -----
+    getBalance(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const balances = yield this.privatePost("Balance", {});
+            const value = balances[asset];
+            return value ? parseFloat(value) : 0;
+        });
+    }
+    getAllBalances(assets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const balances = yield this.privatePost("Balance", {});
+            const result = {};
+            for (const asset of assets) {
+                result[asset] = balances[asset] ? parseFloat(balances[asset]) : 0;
+            }
+            return result;
+        });
+    }
+    // ----- Deposits -----
+    getDepositMethods(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.privatePost("DepositMethods", { asset });
+        });
+    }
+    // Retrieve (or generate) deposit addresses for an asset + method. `method`
+    // must exactly match one of the values returned by DepositMethods.
+    getDepositAddresses(asset, method, isNew = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.privatePost("DepositAddresses", {
+                asset,
+                method,
+                new: isNew ? true : undefined,
+            });
+        });
+    }
+    getDepositStatus(asset, method) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.privatePost("DepositStatus", {
+                asset,
+                method,
+            });
+        });
+    }
+    // ----- Withdrawals -----
+    getWithdrawInfo(asset, key, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.privatePost("WithdrawInfo", {
+                asset,
+                key,
+                amount,
+            });
+        });
+    }
+    // Withdraw to a pre-configured, account-whitelisted address referenced by
+    // `key` (Kraken does not allow withdrawing to an arbitrary address via API).
+    // Returns Kraken's withdrawal reference id (refid).
+    withdraw(asset, key, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertFundingAllowed();
+            const result = yield this.privatePost("Withdraw", {
+                asset,
+                key,
+                amount,
+            });
+            if (!(result === null || result === void 0 ? void 0 : result.refid)) {
+                throw new Error("Kraken Withdraw returned no refid");
+            }
+            return result.refid;
+        });
+    }
+    getWithdrawStatus(asset, method) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.privatePost("WithdrawStatus", {
+                asset,
+                method,
+            });
+        });
+    }
+    getWithdrawStatusByRefid(asset, refid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield this.getWithdrawStatus(asset);
+            return statuses.find((s) => s.refid === refid);
+        });
+    }
+    getDepositByTxId(asset, txid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statuses = yield this.getDepositStatus(asset);
+            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
+// `EAPI:Invalid nonce`.
+let krakenClient = null;
+let krakenClientPromise = null;
+const buildKrakenClient = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (krakenClient) {
+        return krakenClient;
+    }
+    if (!krakenClientPromise) {
+        krakenClientPromise = (() => __awaiter(void 0, void 0, void 0, function* () {
+            const KRAKEN_API_KEY = yield secret_manager_client_1.secretManagerClient.getSecretValue("KRAKEN_API_KEY");
+            if (!KRAKEN_API_KEY) {
+                throw new common_1.SecretManagerError();
+            }
+            const KRAKEN_API_SECRET = yield secret_manager_client_1.secretManagerClient.getSecretValue("KRAKEN_API_SECRET");
+            if (!KRAKEN_API_SECRET) {
+                throw new common_1.SecretManagerError();
+            }
+            krakenClient = new KrakenClient(KRAKEN_API_KEY, KRAKEN_API_SECRET, process.env.RIO_ENV);
+            return krakenClient;
+        }))();
+    }
+    try {
+        return yield krakenClientPromise;
+    }
+    catch (err) {
+        krakenClientPromise = null;
+        throw err;
+    }
+});
+exports.buildKrakenClient = buildKrakenClient;

package/build/index.d.ts

@@ -148,6 +148,7 @@ export * from "./clients/circle-client";
 export * from "./clients/coincover-client";
 export * from "./clients/google-sheets-api-client";
 export * from "./clients/binance-client";
+export * from "./clients/kraken-client";
 export * from "./helpers/get-user-helper";
 export * from "./helpers/get-processor-fees";
 export * from "./helpers/get-network-fees";

package/build/index.js

@@ -164,6 +164,7 @@ __exportStar(require("./clients/circle-client"), exports);
 __exportStar(require("./clients/coincover-client"), exports);
 __exportStar(require("./clients/google-sheets-api-client"), exports);
 __exportStar(require("./clients/binance-client"), exports);
+__exportStar(require("./clients/kraken-client"), exports);
 __exportStar(require("./helpers/get-user-helper"), exports);
 __exportStar(require("./helpers/get-processor-fees"), exports);
 __exportStar(require("./helpers/get-network-fees"), exports);

package/build/models/external-trade.d.ts

@@ -19,6 +19,8 @@ interface ExternalTradeAttrs {
     associatedMidmarketPrice?: number;
     status: ExternalTradeStatus;
     fxTradeId?: string;
+    internalTradeId?: string;
+    coinbaseConversionId?: string;
     providerOptions?: {
         emarkets?: {
             settlementType?: EmarketsSettlementType;
@@ -60,6 +62,8 @@ interface ExternalTradeDoc extends Document {
     associatedMidmarketPrice?: number;
     status: ExternalTradeStatus;
     fxTradeId?: string;
+    internalTradeId?: string;
+    coinbaseConversionId?: string;
     providerOptions?: {
         emarkets?: {
             settlementType?: EmarketsSettlementType;

package/build/models/external-trade.js

@@ -32,6 +32,12 @@ const buildExternalTrade = (mongoose) => {
         fxTradeId: {
             type: String,
         },
+        internalTradeId: {
+            type: String,
+        },
+        coinbaseConversionId: {
+            type: String,
+        },
         provider: {
             type: String,
             required: true,

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

@@ -28,6 +28,9 @@ interface InternalBalancesDoc extends mongoose.Document {
     binance: {
         [key in Fiat & Crypto]: number;
     };
+    kraken: {
+        [key in Fiat & Crypto]: number;
+    };
     brex: {
         [key in Fiat & Crypto]: number;
     };

package/build/models/internal-balances.js

@@ -20,6 +20,9 @@ const buildInternalBalances = (mongoose) => {
         [common_1.TreasuryProvider.Binance]: {
             type: Object,
         },
+        [common_1.TreasuryProvider.Kraken]: {
+            type: Object,
+        },
         [common_1.TreasuryProvider.Brex]: {
             type: Object,
         },

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

@@ -19,6 +19,7 @@ interface InternalTradeAttrs {
     amountFilled?: number;
     limitPrice?: number;
     coinbaseConversionId?: string;
+    externalTradeId?: string;
 }
 interface InternalTradeDoc extends mongoose.Document {
     id: string;
@@ -40,6 +41,7 @@ interface InternalTradeDoc extends mongoose.Document {
     amountFilled?: number;
     limitPrice?: number;
     coinbaseConversionId?: string;
+    externalTradeId?: string;
 }
 interface InternalTradeModel extends mongoose.Model<InternalTradeDoc> {
     build(attrs: InternalTradeAttrs): HydratedDocument<InternalTradeDoc>;

package/build/models/internal-trade.js

@@ -67,6 +67,9 @@ const buildInternalTrade = (mongoose) => {
         coinbaseConversionId: {
             type: String,
         },
+        externalTradeId: {
+            type: String,
+        },
     }, {
         toJSON: {
             transform(doc, ret) {

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.2842",
+  "version": "1.0.2844",
   "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.2643",
+    "@riocrypto/common": "1.0.2649",
     "@slack/web-api": "^7.15.0",
     "@types/express": "^4.17.25",
     "axios": "1.16.0",