@polyester/sdk 0.0.0

package/dist/services/auth/token-storage.js

@@ -0,0 +1,61 @@
+import { CookieManager } from "../../utils/cookies.js";
+import "./cookie-constants.js";
+import { getJwtExpiration } from "../../utils/jwt.js";
+//#region src/services/auth/token-storage.ts
+/**
+* Builds cookie write options for auth token storage.
+*/
+function createAuthTokenStorageSetOptions(token) {
+	const exp = getJwtExpiration(token);
+	if (exp === null) return {
+		expiresAt: null,
+		maxAgeSeconds: null
+	};
+	const nowSeconds = Math.floor(Date.now() / 1e3);
+	return {
+		expiresAt: /* @__PURE__ */ new Date(exp * 1e3),
+		maxAgeSeconds: Math.max(0, exp - nowSeconds)
+	};
+}
+/**
+* Creates in-memory auth token storage.
+*/
+function createMemoryAuthTokenStorage(initialToken) {
+	let storedToken = initialToken ?? null;
+	return {
+		get: () => storedToken,
+		set: (token) => {
+			storedToken = token;
+		},
+		clear: () => {
+			storedToken = null;
+		}
+	};
+}
+/**
+* Creates cookie-backed auth token storage.
+*/
+function createCookieAuthTokenStorage(options = {}) {
+	const cookieName = options.cookieName ?? "polyester_auth_token";
+	const path = options.path ?? "/";
+	const cookie = new CookieManager({ name: cookieName });
+	return {
+		get: () => cookie.get(),
+		set: (token, setOptions) => {
+			cookie.set(token, {
+				path,
+				secure: options.secure,
+				sameSite: options.sameSite,
+				maxAge: setOptions.maxAgeSeconds ?? void 0,
+				expires: setOptions.expiresAt ?? void 0
+			});
+		},
+		clear: () => {
+			cookie.clear({ path });
+		}
+	};
+}
+//#endregion
+export { createAuthTokenStorageSetOptions, createCookieAuthTokenStorage, createMemoryAuthTokenStorage };
+
+//# sourceMappingURL=token-storage.js.map

package/dist/services/auth/token-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-storage.js","names":[],"sources":["../../../src/services/auth/token-storage.ts"],"sourcesContent":["import { CookieManager } from \"../../utils/cookies.js\";\nimport { getJwtExpiration } from \"../../utils/jwt.js\";\nimport { POLYESTER_AUTH_TOKEN_COOKIE_NAME } from \"./cookie-constants.js\";\n\nexport interface AuthTokenStorageSetOptions {\n    expiresAt: Date | null;\n    maxAgeSeconds: number | null;\n}\n\nexport interface AuthTokenStorage {\n    get(): string | null;\n    set(token: string, options: AuthTokenStorageSetOptions): void;\n    clear(): void;\n}\n\nexport interface CookieAuthTokenStorageOptions {\n    cookieName?: string;\n    path?: string;\n    secure?: boolean;\n    sameSite?: \"lax\" | \"strict\" | \"none\";\n}\n\n/**\n * Builds cookie write options for auth token storage.\n */\nexport function createAuthTokenStorageSetOptions(token: string): AuthTokenStorageSetOptions {\n    const exp = getJwtExpiration(token);\n    if (exp === null) {\n        return { expiresAt: null, maxAgeSeconds: null };\n    }\n\n    const nowSeconds = Math.floor(Date.now() / 1000);\n    return {\n        expiresAt: new Date(exp * 1000),\n        maxAgeSeconds: Math.max(0, exp - nowSeconds),\n    };\n}\n\n/**\n * Creates in-memory auth token storage.\n */\nexport function createMemoryAuthTokenStorage(initialToken?: string | null): AuthTokenStorage {\n    let storedToken = initialToken ?? null;\n\n    return {\n        get: () => storedToken,\n        set: (token: string) => {\n            storedToken = token;\n        },\n        clear: () => {\n            storedToken = null;\n        },\n    };\n}\n\n/**\n * Creates cookie-backed auth token storage.\n */\nexport function createCookieAuthTokenStorage(\n    options: CookieAuthTokenStorageOptions = {},\n): AuthTokenStorage {\n    const cookieName = options.cookieName ?? POLYESTER_AUTH_TOKEN_COOKIE_NAME;\n    const path = options.path ?? \"/\";\n    const cookie = new CookieManager({ name: cookieName });\n\n    return {\n        get: () => cookie.get(),\n        set: (token: string, setOptions: AuthTokenStorageSetOptions) => {\n            cookie.set(token, {\n                path,\n                secure: options.secure,\n                sameSite: options.sameSite,\n                maxAge: setOptions.maxAgeSeconds ?? undefined,\n                expires: setOptions.expiresAt ?? undefined,\n            });\n        },\n        clear: () => {\n            cookie.clear({ path });\n        },\n    };\n}\n"],"mappings":";;;;;;;AAyBA,SAAgB,iCAAiC,OAA2C;CACxF,MAAM,MAAM,iBAAiB,KAAK;CAClC,IAAI,QAAQ,MACR,OAAO;EAAE,WAAW;EAAM,eAAe;CAAK;CAGlD,MAAM,aAAa,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI;CAC/C,OAAO;EACH,2BAAW,IAAI,KAAK,MAAM,GAAI;EAC9B,eAAe,KAAK,IAAI,GAAG,MAAM,UAAU;CAC/C;AACJ;;;;AAKA,SAAgB,6BAA6B,cAAgD;CACzF,IAAI,cAAc,gBAAgB;CAElC,OAAO;EACH,WAAW;EACX,MAAM,UAAkB;GACpB,cAAc;EAClB;EACA,aAAa;GACT,cAAc;EAClB;CACJ;AACJ;;;;AAKA,SAAgB,6BACZ,UAAyC,CAAC,GAC1B;CAChB,MAAM,aAAa,QAAQ,cAAA;CAC3B,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,SAAS,IAAI,cAAc,EAAE,MAAM,WAAW,CAAC;CAErD,OAAO;EACH,WAAW,OAAO,IAAI;EACtB,MAAM,OAAe,eAA2C;GAC5D,OAAO,IAAI,OAAO;IACd;IACA,QAAQ,QAAQ;IAChB,UAAU,QAAQ;IAClB,QAAQ,WAAW,iBAAiB,KAAA;IACpC,SAAS,WAAW,aAAa,KAAA;GACrC,CAAC;EACL;EACA,aAAa;GACT,OAAO,MAAM,EAAE,KAAK,CAAC;EACzB;CACJ;AACJ"}

package/dist/services/balances/balances.codecs.js

@@ -0,0 +1,29 @@
+import "../../gen/ledger/read/v1/ledger_read_pb.js";
+//#region src/services/balances/balances.codecs.ts
+const BalanceRangeCodec = {
+	inputToProto: {
+		"1d": 1,
+		"7d": 2,
+		"30d": 3,
+		"90d": 4,
+		"180d": 5,
+		"365d": 6
+	},
+	protoToOutput: {
+		[0]: "unspecified",
+		[1]: "1d",
+		[2]: "7d",
+		[3]: "30d",
+		[4]: "90d",
+		[5]: "180d",
+		[6]: "365d"
+	}
+};
+const EquityGroupByCodec = { inputToProto: {
+	account: 1,
+	asset: 2
+} };
+//#endregion
+export { BalanceRangeCodec, EquityGroupByCodec };
+
+//# sourceMappingURL=balances.codecs.js.map

package/dist/services/balances/balances.codecs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"balances.codecs.js","names":[],"sources":["../../../src/services/balances/balances.codecs.ts"],"sourcesContent":["import * as Proto from \"../../gen/ledger/read/v1/ledger_read_pb.js\";\nimport type { InputToProto, ProtoToOutput } from \"../../utils/types.js\";\n\nexport const BALANCE_RANGE_VALUES = [\"1d\", \"7d\", \"30d\", \"90d\", \"180d\", \"365d\"] as const;\nexport type BalanceRangeMapKey = (typeof BALANCE_RANGE_VALUES)[number];\n\nexport const EQUITY_GROUP_BY_VALUES = [\"account\", \"asset\"] as const;\nexport type EquityGroupByMapKey = (typeof EQUITY_GROUP_BY_VALUES)[number];\n\nexport const BalanceRangeCodec = {\n    inputToProto: {\n        \"1d\": Proto.BalanceRange.DAY_1,\n        \"7d\": Proto.BalanceRange.DAY_7,\n        \"30d\": Proto.BalanceRange.DAY_30,\n        \"90d\": Proto.BalanceRange.DAY_90,\n        \"180d\": Proto.BalanceRange.DAY_180,\n        \"365d\": Proto.BalanceRange.DAY_365,\n    } satisfies InputToProto<BalanceRangeMapKey, Proto.BalanceRange>,\n    protoToOutput: {\n        [Proto.BalanceRange.RANGE_UNSPECIFIED]: \"unspecified\",\n        [Proto.BalanceRange.DAY_1]: \"1d\",\n        [Proto.BalanceRange.DAY_7]: \"7d\",\n        [Proto.BalanceRange.DAY_30]: \"30d\",\n        [Proto.BalanceRange.DAY_90]: \"90d\",\n        [Proto.BalanceRange.DAY_180]: \"180d\",\n        [Proto.BalanceRange.DAY_365]: \"365d\",\n    } satisfies ProtoToOutput<Proto.BalanceRange, BalanceRangeMapKey>,\n} as const;\n\nexport const EquityGroupByCodec = {\n    inputToProto: {\n        account: Proto.EquityGroupBy.GROUP_BY_ACCOUNT,\n        asset: Proto.EquityGroupBy.GROUP_BY_ASSET,\n    } satisfies InputToProto<EquityGroupByMapKey, Proto.EquityGroupBy>,\n} as const;\n"],"mappings":";;AASA,MAAa,oBAAoB;CAC7B,cAAc;EACV,MAAA;EACA,MAAA;EACA,OAAA;EACA,OAAA;EACA,QAAA;EACA,QAAA;CACJ;CACA,eAAe;GAC6B,IAAA;GACZ,IAAA;GACA,IAAA;GACC,IAAA;GACA,IAAA;GACC,IAAA;GACA,IAAA;CAClC;AACJ;AAEA,MAAa,qBAAqB,EAC9B,cAAc;CACV,SAAA;CACA,OAAA;AACJ,EACJ"}

package/dist/services/balances/balances.d.ts

@@ -0,0 +1,39 @@
+import { PolyesterRequestOptions } from "../../shared/request-options.js";
+import { AccountScopedInput } from "../../shared/account-scope.js";
+import { SubaccountResolver } from "../subaccount-resolver.js";
+import { PolyesterRealtime } from "../../realtime/types.js";
+import "../../realtime/index.js";
+import { BaseSubscribeInput } from "../../shared/types.js";
+import { SdkScales } from "../../shared/decimal-surface.js";
+import { BalanceHistoryInput, BalanceHistoryResponse, EquityHistoryInput, EquityHistoryResponse, LedgerBalance } from "./balances.schemas.js";
+import { Transport } from "@connectrpc/connect";
+//#region src/services/balances/balances.d.ts
+interface SubscribeBalancesInput extends BaseSubscribeInput<LedgerBalance> {
+  accountId: string;
+}
+/**
+ * Reads and streams ledger balances plus balance and equity history for the authenticated account scope.
+ */
+declare class BalancesService {
+  #private;
+  constructor(transport: Transport, realtime: PolyesterRealtime, resolver: SubaccountResolver | undefined, scales: SdkScales);
+  /**
+   * Returns current asset balances for the resolved root account or subaccount, including trading, funding, reserved, and available amounts as decimal strings.
+   */
+  list(input?: AccountScopedInput, options?: PolyesterRequestOptions): Promise<LedgerBalance[]>;
+  /**
+   * Returns columnar balance history for the resolved account scope over a selected range, optionally filtered by ledger asset and account buckets.
+   */
+  getBalanceHistory(input: BalanceHistoryInput, options?: PolyesterRequestOptions): Promise<BalanceHistoryResponse>;
+  /**
+   * Returns equity history series for the resolved account scope over a selected range, optionally grouped by account or asset and filtered by account buckets.
+   */
+  getEquityHistory(input: EquityHistoryInput, options?: PolyesterRequestOptions): Promise<EquityHistoryResponse>;
+  /**
+   * Subscribes to private balance updates on private:ledger:balances:{accountId}:proto and emits every balance record as a decimal-string row. Records for assets unknown to the catalog route a CatalogLookupError to onError.
+   */
+  subscribe(input: SubscribeBalancesInput): () => void;
+}
+//#endregion
+export { BalancesService };
+//# sourceMappingURL=balances.d.ts.map

package/dist/services/balances/balances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balances.d.ts","names":[],"sources":["../../../src/services/balances/balances.ts"],"mappings":";;;;;;;;;;UA2BU,+BAA+B,mBAAmB;EACxD;;;;;cAMS;;EAUL,YAAA,WAAW,WACX,UAAU,mBACV,UAAU,gCACV,QAAQ;;;;EAcN,KACF,QAAO,oBACP,UAAU,0BACX,QAAQ;;;;EAgBL,kBACF,OAAO,qBACP,UAAU,0BACX,QAAQ;;;;EAWL,iBACF,OAAO,oBACP,UAAU,0BACX,QAAQ;;;;EAcX,UAAU,OAAO"}

package/dist/services/balances/balances.js

@@ -0,0 +1,85 @@
+import { AssetBalanceSchema, LedgerReadService } from "../../gen/ledger/read/v1/ledger_read_pb.js";
+import { toConnectCallOptions } from "../../shared/request-options.js";
+import { resolveAccountScopedInput } from "../subaccount-resolver.js";
+import { accountScopeToSubaccountId } from "../../shared/account-scope.js";
+import { publicationHandlerErrorContext } from "../../shared/subscription-errors.js";
+import { createReadyGate } from "../../shared/decimal-surface.js";
+import { BalanceHistoryInputSchema, BalancesListInputSchema, EquityHistoryInputSchema, createBalanceHistoryResponseSchema, createEquityHistoryResponseSchema, createLedgerBalanceSchema } from "./balances.schemas.js";
+import { createClient } from "@connectrpc/connect";
+import * as v from "valibot";
+//#region src/services/balances/balances.ts
+/**
+* Reads and streams ledger balances plus balance and equity history for the authenticated account scope.
+*/
+var BalancesService = class {
+	#client;
+	#realtime;
+	#resolver;
+	#scales;
+	#ledgerBalanceSchema;
+	#balanceHistoryResponseSchema;
+	#equityHistoryResponseSchema;
+	constructor(transport, realtime, resolver, scales) {
+		this.#client = createClient(LedgerReadService, transport);
+		this.#realtime = realtime;
+		this.#resolver = resolver;
+		this.#scales = scales;
+		this.#ledgerBalanceSchema = createLedgerBalanceSchema();
+		this.#balanceHistoryResponseSchema = createBalanceHistoryResponseSchema();
+		this.#equityHistoryResponseSchema = createEquityHistoryResponseSchema(scales);
+	}
+	/**
+	* Returns current asset balances for the resolved root account or subaccount, including trading, funding, reserved, and available amounts as decimal strings.
+	*/
+	async list(input = {}, options) {
+		await this.#scales.ready();
+		const resolved = resolveAccountScopedInput(input, this.#resolver);
+		const validated = v.parse(BalancesListInputSchema, resolved);
+		const res = await this.#client.getBalances({ subaccountId: accountScopeToSubaccountId(validated.account) }, toConnectCallOptions(options));
+		return v.parse(v.array(this.#ledgerBalanceSchema), res.balances);
+	}
+	/**
+	* Returns columnar balance history for the resolved account scope over a selected range, optionally filtered by ledger asset and account buckets.
+	*/
+	async getBalanceHistory(input, options) {
+		await this.#scales.ready();
+		const resolved = resolveAccountScopedInput(input, this.#resolver);
+		const validated = v.parse(BalanceHistoryInputSchema, resolved);
+		const res = await this.#client.getBalanceHistory(validated, toConnectCallOptions(options));
+		return v.parse(this.#balanceHistoryResponseSchema, res);
+	}
+	/**
+	* Returns equity history series for the resolved account scope over a selected range, optionally grouped by account or asset and filtered by account buckets.
+	*/
+	async getEquityHistory(input, options) {
+		await this.#scales.ready();
+		const resolved = resolveAccountScopedInput(input, this.#resolver);
+		const validated = v.parse(EquityHistoryInputSchema, resolved);
+		const res = await this.#client.getEquityHistorySeries(validated, toConnectCallOptions(options));
+		return v.parse(this.#equityHistoryResponseSchema, res);
+	}
+	/**
+	* Subscribes to private balance updates on private:ledger:balances:{accountId}:proto and emits every balance record as a decimal-string row. Records for assets unknown to the catalog route a CatalogLookupError to onError.
+	*/
+	subscribe(input) {
+		const channel = `private:ledger:balances:${input.accountId}:proto`;
+		const gate = createReadyGate(() => this.#scales.ready(), (error) => input.onError?.(publicationHandlerErrorContext(channel, error)));
+		return this.#realtime.connectProtoChannel({
+			channel,
+			schema: AssetBalanceSchema,
+			onPublication: (data) => {
+				gate.run(() => {
+					const b = v.parse(this.#ledgerBalanceSchema, data);
+					input.onEvent(b);
+				});
+			},
+			onConnected: input.onOpen,
+			onDisconnected: input.onClose,
+			onError: input.onError
+		});
+	}
+};
+//#endregion
+export { BalancesService };
+
+//# sourceMappingURL=balances.js.map

package/dist/services/balances/balances.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"balances.js","names":["#client","Proto.LedgerReadService","#realtime","#resolver","#scales","#ledgerBalanceSchema","#balanceHistoryResponseSchema","#equityHistoryResponseSchema","Proto.AssetBalanceSchema"],"sources":["../../../src/services/balances/balances.ts"],"sourcesContent":["import * as Proto from \"../../gen/ledger/read/v1/ledger_read_pb.js\";\nimport { createClient, type Client, type Transport } from \"@connectrpc/connect\";\nimport { publicationHandlerErrorContext } from \"../../shared/subscription-errors.js\";\nimport * as v from \"valibot\";\nimport type { PolyesterRealtime } from \"../../realtime/index.js\";\nimport { type SubaccountResolver, resolveAccountScopedInput } from \"../subaccount-resolver.js\";\nimport {\n    toConnectCallOptions,\n    type PolyesterRequestOptions,\n} from \"../../shared/request-options.js\";\nimport { accountScopeToSubaccountId, type AccountScopedInput } from \"../../shared/account-scope.js\";\nimport type { BaseSubscribeInput } from \"../../shared/types.js\";\nimport { createReadyGate, type SdkScales } from \"../../shared/decimal-surface.js\";\nimport {\n    BalanceHistoryInputSchema,\n    BalancesListInputSchema,\n    EquityHistoryInputSchema,\n    createBalanceHistoryResponseSchema,\n    createEquityHistoryResponseSchema,\n    createLedgerBalanceSchema,\n    type LedgerBalance,\n    type BalanceHistoryInput,\n    type BalanceHistoryResponse,\n    type EquityHistoryInput,\n    type EquityHistoryResponse,\n} from \"./balances.schemas.js\";\n\ninterface SubscribeBalancesInput extends BaseSubscribeInput<LedgerBalance> {\n    accountId: string;\n}\n\n/**\n * Reads and streams ledger balances plus balance and equity history for the authenticated account scope.\n */\nexport class BalancesService {\n    #client: Client<typeof Proto.LedgerReadService>;\n    #realtime: PolyesterRealtime;\n    #resolver?: SubaccountResolver;\n    #scales: SdkScales;\n    #ledgerBalanceSchema: ReturnType<typeof createLedgerBalanceSchema>;\n    #balanceHistoryResponseSchema: ReturnType<typeof createBalanceHistoryResponseSchema>;\n    #equityHistoryResponseSchema: ReturnType<typeof createEquityHistoryResponseSchema>;\n\n    constructor(\n        transport: Transport,\n        realtime: PolyesterRealtime,\n        resolver: SubaccountResolver | undefined,\n        scales: SdkScales,\n    ) {\n        this.#client = createClient(Proto.LedgerReadService, transport);\n        this.#realtime = realtime;\n        this.#resolver = resolver;\n        this.#scales = scales;\n        this.#ledgerBalanceSchema = createLedgerBalanceSchema();\n        this.#balanceHistoryResponseSchema = createBalanceHistoryResponseSchema();\n        this.#equityHistoryResponseSchema = createEquityHistoryResponseSchema(scales);\n    }\n\n    /**\n     * Returns current asset balances for the resolved root account or subaccount, including trading, funding, reserved, and available amounts as decimal strings.\n     */\n    async list(\n        input: AccountScopedInput = {},\n        options?: PolyesterRequestOptions,\n    ): Promise<LedgerBalance[]> {\n        await this.#scales.ready();\n        const resolved = resolveAccountScopedInput(input, this.#resolver);\n        const validated = v.parse(BalancesListInputSchema, resolved);\n        const res = await this.#client.getBalances(\n            {\n                subaccountId: accountScopeToSubaccountId(validated.account),\n            },\n            toConnectCallOptions(options),\n        );\n        return v.parse(v.array(this.#ledgerBalanceSchema), res.balances);\n    }\n\n    /**\n     * Returns columnar balance history for the resolved account scope over a selected range, optionally filtered by ledger asset and account buckets.\n     */\n    async getBalanceHistory(\n        input: BalanceHistoryInput,\n        options?: PolyesterRequestOptions,\n    ): Promise<BalanceHistoryResponse> {\n        await this.#scales.ready();\n        const resolved = resolveAccountScopedInput(input, this.#resolver);\n        const validated = v.parse(BalanceHistoryInputSchema, resolved);\n        const res = await this.#client.getBalanceHistory(validated, toConnectCallOptions(options));\n        return v.parse(this.#balanceHistoryResponseSchema, res);\n    }\n\n    /**\n     * Returns equity history series for the resolved account scope over a selected range, optionally grouped by account or asset and filtered by account buckets.\n     */\n    async getEquityHistory(\n        input: EquityHistoryInput,\n        options?: PolyesterRequestOptions,\n    ): Promise<EquityHistoryResponse> {\n        await this.#scales.ready();\n        const resolved = resolveAccountScopedInput(input, this.#resolver);\n        const validated = v.parse(EquityHistoryInputSchema, resolved);\n        const res = await this.#client.getEquityHistorySeries(\n            validated,\n            toConnectCallOptions(options),\n        );\n        return v.parse(this.#equityHistoryResponseSchema, res);\n    }\n\n    /**\n     * Subscribes to private balance updates on private:ledger:balances:{accountId}:proto and emits every balance record as a decimal-string row. Records for assets unknown to the catalog route a CatalogLookupError to onError.\n     */\n    subscribe(input: SubscribeBalancesInput): () => void {\n        const channel = `private:ledger:balances:${input.accountId}:proto`;\n        const gate = createReadyGate(\n            () => this.#scales.ready(),\n            (error) => input.onError?.(publicationHandlerErrorContext(channel, error)),\n        );\n        return this.#realtime.connectProtoChannel({\n            channel,\n            schema: Proto.AssetBalanceSchema,\n            onPublication: (data) => {\n                gate.run(() => {\n                    const b = v.parse(this.#ledgerBalanceSchema, data);\n                    input.onEvent(b);\n                });\n            },\n            onConnected: input.onOpen,\n            onDisconnected: input.onClose,\n            onError: input.onError,\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;;;;AAkCA,IAAa,kBAAb,MAA6B;CACzB;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YACI,WACA,UACA,UACA,QACF;EACE,KAAKA,UAAU,aAAaC,mBAAyB,SAAS;EAC9D,KAAKC,YAAY;EACjB,KAAKC,YAAY;EACjB,KAAKC,UAAU;EACf,KAAKC,uBAAuB,0BAA0B;EACtD,KAAKC,gCAAgC,mCAAmC;EACxE,KAAKC,+BAA+B,kCAAkC,MAAM;CAChF;;;;CAKA,MAAM,KACF,QAA4B,CAAC,GAC7B,SACwB;EACxB,MAAM,KAAKH,QAAQ,MAAM;EACzB,MAAM,WAAW,0BAA0B,OAAO,KAAKD,SAAS;EAChE,MAAM,YAAY,EAAE,MAAM,yBAAyB,QAAQ;EAC3D,MAAM,MAAM,MAAM,KAAKH,QAAQ,YAC3B,EACI,cAAc,2BAA2B,UAAU,OAAO,EAC9D,GACA,qBAAqB,OAAO,CAChC;EACA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAKK,oBAAoB,GAAG,IAAI,QAAQ;CACnE;;;;CAKA,MAAM,kBACF,OACA,SAC+B;EAC/B,MAAM,KAAKD,QAAQ,MAAM;EACzB,MAAM,WAAW,0BAA0B,OAAO,KAAKD,SAAS;EAChE,MAAM,YAAY,EAAE,MAAM,2BAA2B,QAAQ;EAC7D,MAAM,MAAM,MAAM,KAAKH,QAAQ,kBAAkB,WAAW,qBAAqB,OAAO,CAAC;EACzF,OAAO,EAAE,MAAM,KAAKM,+BAA+B,GAAG;CAC1D;;;;CAKA,MAAM,iBACF,OACA,SAC8B;EAC9B,MAAM,KAAKF,QAAQ,MAAM;EACzB,MAAM,WAAW,0BAA0B,OAAO,KAAKD,SAAS;EAChE,MAAM,YAAY,EAAE,MAAM,0BAA0B,QAAQ;EAC5D,MAAM,MAAM,MAAM,KAAKH,QAAQ,uBAC3B,WACA,qBAAqB,OAAO,CAChC;EACA,OAAO,EAAE,MAAM,KAAKO,8BAA8B,GAAG;CACzD;;;;CAKA,UAAU,OAA2C;EACjD,MAAM,UAAU,2BAA2B,MAAM,UAAU;EAC3D,MAAM,OAAO,sBACH,KAAKH,QAAQ,MAAM,IACxB,UAAU,MAAM,UAAU,+BAA+B,SAAS,KAAK,CAAC,CAC7E;EACA,OAAO,KAAKF,UAAU,oBAAoB;GACtC;GACA,QAAQM;GACR,gBAAgB,SAAS;IACrB,KAAK,UAAU;KACX,MAAM,IAAI,EAAE,MAAM,KAAKH,sBAAsB,IAAI;KACjD,MAAM,QAAQ,CAAC;IACnB,CAAC;GACL;GACA,aAAa,MAAM;GACnB,gBAAgB,MAAM;GACtB,SAAS,MAAM;EACnB,CAAC;CACL;AACJ"}

package/dist/services/balances/balances.merge.d.ts

@@ -0,0 +1,9 @@
+import { LedgerBalance } from "./balances.schemas.js";
+//#region src/services/balances/balances.merge.d.ts
+/**
+ * Reconciles the atomically versioned trading tuple independently from funding.
+ */
+declare function mergeLedgerBalances(existing: LedgerBalance | undefined, incoming: LedgerBalance): LedgerBalance;
+//#endregion
+export { mergeLedgerBalances };
+//# sourceMappingURL=balances.merge.d.ts.map

package/dist/services/balances/balances.merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balances.merge.d.ts","names":[],"sources":["../../../src/services/balances/balances.merge.ts"],"mappings":";;;;;iBAMgB,oBACZ,UAAU,2BACV,UAAU,gBACX"}

package/dist/services/balances/balances.merge.js

@@ -0,0 +1,31 @@
+import { compareUnsignedIntegerStrings } from "../../shared/reconciliation.js";
+//#region src/services/balances/balances.merge.ts
+/**
+* Reconciles the atomically versioned trading tuple independently from funding.
+*/
+function mergeLedgerBalances(existing, incoming) {
+	if (!existing) return incoming;
+	if (existing.assetId !== incoming.assetId) throw new RangeError(`Cannot merge ledger balances for different assets (${existing.assetId} and ${incoming.assetId})`);
+	if (![
+		incoming.tradingRevision,
+		incoming.fundingRevision,
+		existing.tradingRevision,
+		existing.fundingRevision
+	].some((revision) => compareUnsignedIntegerStrings(revision, "0") > 0)) return incoming;
+	const tradingIsNewer = compareUnsignedIntegerStrings(incoming.tradingRevision, existing.tradingRevision) > 0;
+	const fundingIsNewer = compareUnsignedIntegerStrings(incoming.fundingRevision, existing.fundingRevision) > 0;
+	if (!tradingIsNewer && !fundingIsNewer) return existing;
+	return {
+		assetId: existing.assetId,
+		trading: tradingIsNewer ? incoming.trading : existing.trading,
+		funding: fundingIsNewer ? incoming.funding : existing.funding,
+		reserved: tradingIsNewer ? incoming.reserved : existing.reserved,
+		available: tradingIsNewer ? incoming.available : existing.available,
+		tradingRevision: tradingIsNewer ? incoming.tradingRevision : existing.tradingRevision,
+		fundingRevision: fundingIsNewer ? incoming.fundingRevision : existing.fundingRevision
+	};
+}
+//#endregion
+export { mergeLedgerBalances };
+
+//# sourceMappingURL=balances.merge.js.map

package/dist/services/balances/balances.merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"balances.merge.js","names":[],"sources":["../../../src/services/balances/balances.merge.ts"],"sourcesContent":["import type { LedgerBalance } from \"./balances.schemas.js\";\nimport { compareUnsignedIntegerStrings } from \"../../shared/reconciliation.js\";\n\n/**\n * Reconciles the atomically versioned trading tuple independently from funding.\n */\nexport function mergeLedgerBalances(\n    existing: LedgerBalance | undefined,\n    incoming: LedgerBalance,\n): LedgerBalance {\n    if (!existing) return incoming;\n    if (existing.assetId !== incoming.assetId) {\n        throw new RangeError(\n            `Cannot merge ledger balances for different assets (${existing.assetId} and ${incoming.assetId})`,\n        );\n    }\n\n    const hasRevisions = [\n        incoming.tradingRevision,\n        incoming.fundingRevision,\n        existing.tradingRevision,\n        existing.fundingRevision,\n    ].some((revision) => compareUnsignedIntegerStrings(revision, \"0\") > 0);\n    if (!hasRevisions) return incoming;\n\n    const tradingIsNewer =\n        compareUnsignedIntegerStrings(incoming.tradingRevision, existing.tradingRevision) > 0;\n    const fundingIsNewer =\n        compareUnsignedIntegerStrings(incoming.fundingRevision, existing.fundingRevision) > 0;\n\n    if (!tradingIsNewer && !fundingIsNewer) return existing;\n\n    return {\n        assetId: existing.assetId,\n        trading: tradingIsNewer ? incoming.trading : existing.trading,\n        funding: fundingIsNewer ? incoming.funding : existing.funding,\n        reserved: tradingIsNewer ? incoming.reserved : existing.reserved,\n        available: tradingIsNewer ? incoming.available : existing.available,\n        tradingRevision: tradingIsNewer ? incoming.tradingRevision : existing.tradingRevision,\n        fundingRevision: fundingIsNewer ? incoming.fundingRevision : existing.fundingRevision,\n    };\n}\n"],"mappings":";;;;;AAMA,SAAgB,oBACZ,UACA,UACa;CACb,IAAI,CAAC,UAAU,OAAO;CACtB,IAAI,SAAS,YAAY,SAAS,SAC9B,MAAM,IAAI,WACN,sDAAsD,SAAS,QAAQ,OAAO,SAAS,QAAQ,EACnG;CASJ,IAAI,CANiB;EACjB,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;CACb,CAAC,CAAC,MAAM,aAAa,8BAA8B,UAAU,GAAG,IAAI,CACpD,GAAG,OAAO;CAE1B,MAAM,iBACF,8BAA8B,SAAS,iBAAiB,SAAS,eAAe,IAAI;CACxF,MAAM,iBACF,8BAA8B,SAAS,iBAAiB,SAAS,eAAe,IAAI;CAExF,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,OAAO;CAE/C,OAAO;EACH,SAAS,SAAS;EAClB,SAAS,iBAAiB,SAAS,UAAU,SAAS;EACtD,SAAS,iBAAiB,SAAS,UAAU,SAAS;EACtD,UAAU,iBAAiB,SAAS,WAAW,SAAS;EACxD,WAAW,iBAAiB,SAAS,YAAY,SAAS;EAC1D,iBAAiB,iBAAiB,SAAS,kBAAkB,SAAS;EACtE,iBAAiB,iBAAiB,SAAS,kBAAkB,SAAS;CAC1E;AACJ"}

package/dist/services/balances/balances.schemas.d.ts

@@ -0,0 +1,265 @@
+import { AccountCode } from "../../gen/ledger/v1/catalog_pb.js";
+import { BalanceRange as BalanceRange$1, EquityGroupBy as EquityGroupBy$1 } from "../../gen/ledger/read/v1/ledger_read_pb.js";
+import { DecodedEnum } from "../../utils/types.js";
+import { SdkScales } from "../../shared/decimal-surface.js";
+import { U128Value } from "../../utils/u128.js";
+import { AccountCodeValue } from "../../shared/ledger-codes.js";
+import * as v from "valibot";
+//#region src/services/balances/balances.schemas.d.ts
+/**
+ * AssetBalance u128 fields on the ledger wire are always 18-decimal scaled
+ * (PolyesterChain base units), independent of per-asset quantityScale used
+ * elsewhere for order quantities and transfer inputs.
+ */
+declare function createLedgerBalanceSchema(): v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly assetId: v.NumberSchema<undefined>;
+  readonly trading: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ObjectSchema<{
+    readonly hi: v.BigintSchema<undefined>;
+    readonly lo: v.BigintSchema<undefined>;
+  }, undefined>, undefined>, v.TransformAction<U128Value | undefined, bigint>]>;
+  readonly funding: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ObjectSchema<{
+    readonly hi: v.BigintSchema<undefined>;
+    readonly lo: v.BigintSchema<undefined>;
+  }, undefined>, undefined>, v.TransformAction<U128Value | undefined, bigint>]>;
+  readonly reserved: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ObjectSchema<{
+    readonly hi: v.BigintSchema<undefined>;
+    readonly lo: v.BigintSchema<undefined>;
+  }, undefined>, undefined>, v.TransformAction<U128Value | undefined, bigint>]>;
+  readonly available: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ObjectSchema<{
+    readonly hi: v.BigintSchema<undefined>;
+    readonly lo: v.BigintSchema<undefined>;
+  }, undefined>, undefined>, v.TransformAction<U128Value | undefined, bigint>]>;
+  readonly tradingRevision: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, 0n>, v.TransformAction<bigint, string>]>;
+  readonly fundingRevision: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, 0n>, v.TransformAction<bigint, string>]>;
+}, undefined>, v.TransformAction<{
+  assetId: number;
+  trading?: bigint | undefined;
+  funding?: bigint | undefined;
+  reserved?: bigint | undefined;
+  available?: bigint | undefined;
+  tradingRevision: string;
+  fundingRevision: string;
+}, {
+  assetId: number;
+  funding: string;
+  trading: string;
+  reserved: string;
+  available: string;
+  tradingRevision: string;
+  fundingRevision: string;
+}>]>;
+type LedgerBalance = v.InferOutput<ReturnType<typeof createLedgerBalanceSchema>>;
+declare const BalanceRangeSchema: v.PicklistSchema<readonly ["1d", "7d", "30d", "90d", "180d", "365d"], undefined>;
+type BalanceRange = v.InferOutput<typeof BalanceRangeSchema>;
+declare const EquityGroupBySchema: v.PicklistSchema<readonly ["account", "asset"], undefined>;
+type EquityGroupBy = v.InferOutput<typeof EquityGroupBySchema>;
+declare const BalanceHistoryInputSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly range: v.SchemaWithPipe<readonly [v.PicklistSchema<readonly ["1d", "7d", "30d", "90d", "180d", "365d"], undefined>, v.TransformAction<"1d" | "7d" | "30d" | "90d" | "180d" | "365d", BalanceRange$1.DAY_1 | BalanceRange$1.DAY_7 | BalanceRange$1.DAY_30 | BalanceRange$1.DAY_90 | BalanceRange$1.DAY_180 | BalanceRange$1.DAY_365>]>;
+  readonly ledger: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+  readonly accountCodes: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.PicklistSchema<readonly ["funding", "trading"], undefined>, v.TransformAction<"funding" | "trading", AccountCode.FUNDING | AccountCode.TRADING>]>, undefined>, readonly []>;
+  readonly account: v.OptionalSchema<v.UnionSchema<[v.PicklistSchema<["active", "main"], undefined>, v.StrictObjectSchema<{
+    readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  }, undefined>], undefined>, undefined>;
+}, undefined>, v.TransformAction<{
+  range: BalanceRange$1.DAY_1 | BalanceRange$1.DAY_7 | BalanceRange$1.DAY_30 | BalanceRange$1.DAY_90 | BalanceRange$1.DAY_180 | BalanceRange$1.DAY_365;
+  ledger: number;
+  accountCodes: (AccountCode.FUNDING | AccountCode.TRADING)[];
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+}, {
+  subaccountId: bigint | undefined;
+  range: BalanceRange$1.DAY_1 | BalanceRange$1.DAY_7 | BalanceRange$1.DAY_30 | BalanceRange$1.DAY_90 | BalanceRange$1.DAY_180 | BalanceRange$1.DAY_365;
+  ledger: number;
+  accountCodes: (AccountCode.FUNDING | AccountCode.TRADING)[];
+}>]>;
+type BalanceHistoryInput = v.InferInput<typeof BalanceHistoryInputSchema>;
+declare function createBalanceHistoryResponseSchema(): v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly range: v.SchemaWithPipe<readonly [v.EnumSchema<typeof BalanceRange$1, undefined>, v.TransformAction<BalanceRange$1, "unspecified" | "1d" | "7d" | "30d" | "90d" | "180d" | "365d">]>;
+  readonly bucket: v.StringSchema<undefined>;
+  readonly startTsSec: v.NumberSchema<undefined>;
+  readonly endTsSec: v.NumberSchema<undefined>;
+  readonly points: v.NumberSchema<undefined>;
+  readonly series: v.ArraySchema<v.ObjectSchema<{
+    readonly assetId: v.NumberSchema<undefined>;
+    readonly accountCode: v.EnumSchema<{
+      funding: AccountCode.FUNDING;
+      trading: AccountCode.TRADING;
+    }, undefined>;
+    readonly balanceQ: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>, v.TransformAction<{
+  range: "unspecified" | "1d" | "7d" | "30d" | "90d" | "180d" | "365d";
+  bucket: string;
+  startTsSec: number;
+  endTsSec: number;
+  points: number;
+  series: {
+    assetId: number;
+    accountCode: v.EnumValues<{
+      funding: AccountCode.FUNDING;
+      trading: AccountCode.TRADING;
+    }>;
+    balanceQ: bigint[];
+  }[];
+}, {
+  range: "unspecified" | "1d" | "7d" | "30d" | "90d" | "180d" | "365d";
+  bucket: string;
+  startTsSec: number;
+  endTsSec: number;
+  points: number;
+  series: {
+    assetId: number;
+    accountCode: "funding" | "trading" | "unspecified";
+    balance: string[];
+  }[];
+}>]>;
+type BalanceHistoryResponse = v.InferOutput<ReturnType<typeof createBalanceHistoryResponseSchema>>;
+declare const EquityHistoryInputSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly range: v.SchemaWithPipe<readonly [v.PicklistSchema<readonly ["1d", "7d", "30d", "90d", "180d", "365d"], undefined>, v.TransformAction<"1d" | "7d" | "30d" | "90d" | "180d" | "365d", BalanceRange$1.DAY_1 | BalanceRange$1.DAY_7 | BalanceRange$1.DAY_30 | BalanceRange$1.DAY_90 | BalanceRange$1.DAY_180 | BalanceRange$1.DAY_365>]>;
+  readonly accountCodes: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.PicklistSchema<readonly ["funding", "trading"], undefined>, v.TransformAction<"funding" | "trading", AccountCode.FUNDING | AccountCode.TRADING>]>, undefined>, readonly []>;
+  readonly groupBy: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<readonly ["account", "asset"], undefined>, "account">, v.TransformAction<"account" | "asset", EquityGroupBy$1.GROUP_BY_ACCOUNT | EquityGroupBy$1.GROUP_BY_ASSET>]>;
+  readonly account: v.OptionalSchema<v.UnionSchema<[v.PicklistSchema<["active", "main"], undefined>, v.StrictObjectSchema<{
+    readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  }, undefined>], undefined>, undefined>;
+}, undefined>, v.TransformAction<{
+  range: BalanceRange$1.DAY_1 | BalanceRange$1.DAY_7 | BalanceRange$1.DAY_30 | BalanceRange$1.DAY_90 | BalanceRange$1.DAY_180 | BalanceRange$1.DAY_365;
+  accountCodes: (AccountCode.FUNDING | AccountCode.TRADING)[];
+  groupBy: EquityGroupBy$1.GROUP_BY_ACCOUNT | EquityGroupBy$1.GROUP_BY_ASSET;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+}, {
+  subaccountId: bigint | undefined;
+  range: BalanceRange$1.DAY_1 | BalanceRange$1.DAY_7 | BalanceRange$1.DAY_30 | BalanceRange$1.DAY_90 | BalanceRange$1.DAY_180 | BalanceRange$1.DAY_365;
+  accountCodes: (AccountCode.FUNDING | AccountCode.TRADING)[];
+  groupBy: EquityGroupBy$1.GROUP_BY_ACCOUNT | EquityGroupBy$1.GROUP_BY_ASSET;
+}>]>;
+type EquityHistoryInput = v.InferInput<typeof EquityHistoryInputSchema>;
+type EquitySeriesGrouping = {
+  type: "account";
+  accountCode: DecodedEnum<AccountCodeValue>;
+  name: string;
+} | {
+  type: "asset";
+  assetId: number;
+  symbol: string;
+};
+declare const EquitySeriesSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly grouping: v.UnionSchema<[v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"account", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly accountCode: v.EnumSchema<{
+        funding: AccountCode.FUNDING;
+        trading: AccountCode.TRADING;
+      }, undefined>;
+      readonly name: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"asset", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly id: v.NumberSchema<undefined>;
+      readonly symbol: v.StringSchema<undefined>;
+    }, undefined>;
+  }, undefined>], undefined>;
+  readonly equityQ: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+}, undefined>, v.TransformAction<{
+  grouping: {
+    case: "account";
+    value: {
+      accountCode: v.EnumValues<{
+        funding: AccountCode.FUNDING;
+        trading: AccountCode.TRADING;
+      }>;
+      name: string;
+    };
+  } | {
+    case: "asset";
+    value: {
+      id: number;
+      symbol: string;
+    };
+  };
+  equityQ: bigint[];
+}, {
+  grouping: EquitySeriesGrouping;
+  equity: string[];
+}>]>;
+declare function createEquityHistoryResponseSchema(scales: SdkScales): v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly range: v.SchemaWithPipe<readonly [v.EnumSchema<typeof BalanceRange$1, undefined>, v.TransformAction<BalanceRange$1, "unspecified" | "1d" | "7d" | "30d" | "90d" | "180d" | "365d">]>;
+  readonly bucket: v.StringSchema<undefined>;
+  readonly startTsSec: v.NumberSchema<undefined>;
+  readonly endTsSec: v.NumberSchema<undefined>;
+  readonly quoteAsset: v.StringSchema<undefined>;
+  readonly points: v.NumberSchema<undefined>;
+  readonly series: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly grouping: v.UnionSchema<[v.ObjectSchema<{
+      readonly case: v.LiteralSchema<"account", undefined>;
+      readonly value: v.ObjectSchema<{
+        readonly accountCode: v.EnumSchema<{
+          funding: AccountCode.FUNDING;
+          trading: AccountCode.TRADING;
+        }, undefined>;
+        readonly name: v.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly case: v.LiteralSchema<"asset", undefined>;
+      readonly value: v.ObjectSchema<{
+        readonly id: v.NumberSchema<undefined>;
+        readonly symbol: v.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>], undefined>;
+    readonly equityQ: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+  }, undefined>, v.TransformAction<{
+    grouping: {
+      case: "account";
+      value: {
+        accountCode: v.EnumValues<{
+          funding: AccountCode.FUNDING;
+          trading: AccountCode.TRADING;
+        }>;
+        name: string;
+      };
+    } | {
+      case: "asset";
+      value: {
+        id: number;
+        symbol: string;
+      };
+    };
+    equityQ: bigint[];
+  }, {
+    grouping: EquitySeriesGrouping;
+    equity: string[];
+  }>]>, undefined>;
+  readonly btcPricesQ: v.OptionalSchema<v.ArraySchema<v.BigintSchema<undefined>, undefined>, readonly []>;
+}, undefined>, v.TransformAction<{
+  range: "unspecified" | "1d" | "7d" | "30d" | "90d" | "180d" | "365d";
+  bucket: string;
+  startTsSec: number;
+  endTsSec: number;
+  quoteAsset: string;
+  points: number;
+  series: {
+    grouping: EquitySeriesGrouping;
+    equity: string[];
+  }[];
+  btcPricesQ: bigint[];
+}, {
+  range: "unspecified" | "1d" | "7d" | "30d" | "90d" | "180d" | "365d";
+  bucket: string;
+  startTsSec: number;
+  endTsSec: number;
+  quoteAsset: string;
+  points: number;
+  series: {
+    grouping: EquitySeriesGrouping;
+    equity: string[];
+  }[];
+  btcPrices: string[];
+}>]>;
+type EquitySeries = v.InferOutput<typeof EquitySeriesSchema>;
+type EquityHistoryResponse = v.InferOutput<ReturnType<typeof createEquityHistoryResponseSchema>>;
+//#endregion
+export { BalanceHistoryInput, BalanceHistoryInputSchema, BalanceHistoryResponse, BalanceRange, BalanceRangeSchema, EquityGroupBy, EquityGroupBySchema, EquityHistoryInput, EquityHistoryInputSchema, EquityHistoryResponse, EquitySeries, EquitySeriesGrouping, EquitySeriesSchema, LedgerBalance, createBalanceHistoryResponseSchema, createEquityHistoryResponseSchema, createLedgerBalanceSchema };
+//# sourceMappingURL=balances.schemas.d.ts.map

package/dist/services/balances/balances.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balances.schemas.d.ts","names":[],"sources":["../../../src/services/balances/balances.schemas.ts"],"mappings":";;;;;;;;;;;;;iBAuCgB,6BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+B7B,gBAAgB,EAAE,YAAY,kBAAkB;cAQ/C,oBAAkB,EAAA;KAEnB,eAAe,EAAE,mBAAmB;cAInC,qBAAmB,EAAA;KAEpB,gBAAgB,EAAE,mBAAmB;cAEpC,2BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;KAwB1B,sBAAsB,EAAE,kBAAkB;iBAQtC,sCAAkC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0CtC,yBAAyB,EAAE,YACnC,kBAAkB;cAGT,0BAAwB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;KA2BzB,qBAAqB,EAAE,kBAAkB;KAmBzC;EAEF;EACA,aAAa,YAAY;EACzB;;EAGA;EACA;EACA;;cAGG,oBAAkB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKO,UAAA;EAA8B;;iBA6BpD,kCAAkC,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA7B7B,UAAA;IAA8B;;;;;;;;;;;IAA9B,UAAA;IAA8B;;;;;;;;;;;IAA9B,UAAA;IAA8B;;;;KAiExD,eAAe,EAAE,mBAAmB;KACpC,wBAAwB,EAAE,YAClC,kBAAkB"}