@riocrypto/common-server 1.0.2842 → 1.0.2843

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

@@ -0,0 +1,60 @@
+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;
+}
+declare class KrakenClient {
+    private apiKey;
+    private env;
+    private axiosClient;
+    private decodedSecret;
+    private lastNonce;
+    private restBaseUrl;
+    constructor(apiKey: string, apiSecret: string, env: RioEnv);
+    private assertFundingAllowed;
+    private nextNonce;
+    private sign;
+    private privatePost;
+    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>;
+}
+export declare const buildKrakenClient: () => Promise<KrakenClient>;
+export type { KrakenClient };

package/build/clients/kraken-client.js

@@ -0,0 +1,219 @@
+"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;
+        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* () {
+            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);
+        });
+    }
+}
+// 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2842",
+  "version": "1.0.2843",
   "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.2647",
     "@slack/web-api": "^7.15.0",
     "@types/express": "^4.17.25",
     "axios": "1.16.0",