@polyester/sdk 0.0.0

package/dist/services/guard-signer/guard-signer.schemas.d.ts

@@ -0,0 +1,269 @@
+import { ProtectedAction } from "../../gen/chain/guard/v1/guard_signer_pb.js";
+import * as v from "valibot";
+//#region src/services/guard-signer/guard-signer.schemas.d.ts
+declare const GuardSignerScopedInputSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  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<{
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+}, {
+  subaccountId: bigint | undefined;
+}>]>;
+type GuardSignerScopedInput = v.InferInput<typeof GuardSignerScopedInputSchema>;
+declare const SignProtectedActionInputSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly action: v.PicklistSchema<readonly ["fundingSetExternalWhitelistRequired", "fundingAddExternalWhitelist", "fundingRemoveExternalWhitelist", "fundingAddInternalWhitelist", "fundingRemoveInternalWhitelist", "fundingSetInternalWhitelistRequired"], undefined>;
+  readonly args: v.OptionalSchema<v.VariantSchema<"case", [v.StrictObjectSchema<{
+    readonly case: v.LiteralSchema<"externalWhitelist", undefined>;
+    readonly polychainChainId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>]>;
+    readonly addresses: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
+  }, undefined>, v.StrictObjectSchema<{
+    readonly case: v.LiteralSchema<"internalWhitelist", undefined>;
+    readonly addresses: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
+  }, undefined>, v.StrictObjectSchema<{
+    readonly case: v.LiteralSchema<"whitelistRequirement", undefined>;
+    readonly required: v.BooleanSchema<undefined>;
+  }, undefined>], undefined>, undefined>;
+  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<{
+  action: "fundingSetExternalWhitelistRequired" | "fundingAddExternalWhitelist" | "fundingRemoveExternalWhitelist" | "fundingAddInternalWhitelist" | "fundingRemoveInternalWhitelist" | "fundingSetInternalWhitelistRequired";
+  args?: {
+    case: "externalWhitelist";
+    polychainChainId: number;
+    addresses: string[];
+  } | {
+    case: "internalWhitelist";
+    addresses: string[];
+  } | {
+    case: "whitelistRequirement";
+    required: boolean;
+  } | undefined;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+}, {
+  subaccountId: bigint | undefined;
+  action: ProtectedAction.FUNDING_SET_EXTERNAL_WHITELIST_REQUIRED | ProtectedAction.FUNDING_ADD_EXTERNAL_WHITELIST | ProtectedAction.FUNDING_REMOVE_EXTERNAL_WHITELIST | ProtectedAction.FUNDING_ADD_INTERNAL_WHITELIST | ProtectedAction.FUNDING_REMOVE_INTERNAL_WHITELIST | ProtectedAction.FUNDING_SET_INTERNAL_WHITELIST_REQUIRED;
+  args: {
+    args: {
+      case: "externalWhitelist";
+      value: {
+        polychainChainId: number;
+        addresses: string[];
+        required?: undefined;
+      };
+    };
+  } | {
+    args: {
+      case: "internalWhitelist";
+      value: {
+        addresses: string[];
+        polychainChainId?: undefined;
+        required?: undefined;
+      };
+    };
+  } | {
+    args: {
+      case: "whitelistRequirement";
+      value: {
+        required: boolean;
+        polychainChainId?: undefined;
+        addresses?: undefined;
+      };
+    };
+  } | undefined;
+}>]>;
+type SignProtectedActionInput = v.InferInput<typeof SignProtectedActionInputSchema>;
+declare const BatchSignProtectedActionInputSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly actions: v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
+    readonly action: v.PicklistSchema<readonly ["fundingSetExternalWhitelistRequired", "fundingAddExternalWhitelist", "fundingRemoveExternalWhitelist", "fundingAddInternalWhitelist", "fundingRemoveInternalWhitelist", "fundingSetInternalWhitelistRequired"], undefined>;
+    readonly args: v.OptionalSchema<v.VariantSchema<"case", [v.StrictObjectSchema<{
+      readonly case: v.LiteralSchema<"externalWhitelist", undefined>;
+      readonly polychainChainId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>]>;
+      readonly addresses: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
+    }, undefined>, v.StrictObjectSchema<{
+      readonly case: v.LiteralSchema<"internalWhitelist", undefined>;
+      readonly addresses: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
+    }, undefined>, v.StrictObjectSchema<{
+      readonly case: v.LiteralSchema<"whitelistRequirement", undefined>;
+      readonly required: v.BooleanSchema<undefined>;
+    }, undefined>], undefined>, undefined>;
+  }, undefined>, undefined>, v.MinLengthAction<{
+    action: "fundingSetExternalWhitelistRequired" | "fundingAddExternalWhitelist" | "fundingRemoveExternalWhitelist" | "fundingAddInternalWhitelist" | "fundingRemoveInternalWhitelist" | "fundingSetInternalWhitelistRequired";
+    args?: {
+      case: "externalWhitelist";
+      polychainChainId: number;
+      addresses: string[];
+    } | {
+      case: "internalWhitelist";
+      addresses: string[];
+    } | {
+      case: "whitelistRequirement";
+      required: boolean;
+    } | undefined;
+  }[], 1, "At least one protected action is required.">]>;
+  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<{
+  actions: {
+    action: "fundingSetExternalWhitelistRequired" | "fundingAddExternalWhitelist" | "fundingRemoveExternalWhitelist" | "fundingAddInternalWhitelist" | "fundingRemoveInternalWhitelist" | "fundingSetInternalWhitelistRequired";
+    args?: {
+      case: "externalWhitelist";
+      polychainChainId: number;
+      addresses: string[];
+    } | {
+      case: "internalWhitelist";
+      addresses: string[];
+    } | {
+      case: "whitelistRequirement";
+      required: boolean;
+    } | undefined;
+  }[];
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+}, {
+  subaccountId: bigint | undefined;
+  actions: {
+    action: ProtectedAction.FUNDING_SET_EXTERNAL_WHITELIST_REQUIRED | ProtectedAction.FUNDING_ADD_EXTERNAL_WHITELIST | ProtectedAction.FUNDING_REMOVE_EXTERNAL_WHITELIST | ProtectedAction.FUNDING_ADD_INTERNAL_WHITELIST | ProtectedAction.FUNDING_REMOVE_INTERNAL_WHITELIST | ProtectedAction.FUNDING_SET_INTERNAL_WHITELIST_REQUIRED;
+    args: {
+      args: {
+        case: "externalWhitelist";
+        value: {
+          polychainChainId: number;
+          addresses: string[];
+          required?: undefined;
+        };
+      };
+    } | {
+      args: {
+        case: "internalWhitelist";
+        value: {
+          addresses: string[];
+          polychainChainId?: undefined;
+          required?: undefined;
+        };
+      };
+    } | {
+      args: {
+        case: "whitelistRequirement";
+        value: {
+          required: boolean;
+          polychainChainId?: undefined;
+          addresses?: undefined;
+        };
+      };
+    } | undefined;
+  }[];
+}>]>;
+type BatchSignProtectedActionInput = v.InferInput<typeof BatchSignProtectedActionInputSchema>;
+declare const GuardSignerStatusSchema: v.ObjectSchema<{
+  readonly signerAddress: v.StringSchema<undefined>;
+  readonly onchainSignerAddress: v.StringSchema<undefined>;
+  readonly initialized: v.BooleanSchema<undefined>;
+  readonly nonce: v.StringSchema<undefined>;
+  readonly nonceSpace: v.BigintSchema<undefined>;
+}, undefined>;
+type GuardSignerStatus = v.InferOutput<typeof GuardSignerStatusSchema>;
+declare const GuardApprovalSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly nonceSpace: v.BigintSchema<undefined>;
+  readonly deadlineUnix: v.BigintSchema<undefined>;
+  readonly signature: v.InstanceSchema<Uint8ArrayConstructor, undefined>;
+}, undefined>, v.TransformAction<{
+  nonceSpace: bigint;
+  deadlineUnix: bigint;
+  signature: Uint8Array<ArrayBuffer>;
+}, {
+  nonceSpace: string;
+  deadlineUnix: string;
+  signature: `0x${string}`;
+  raw: {
+    nonceSpace: bigint;
+    deadlineUnix: bigint;
+    signature: Uint8Array<ArrayBuffer>;
+  };
+}>]>;
+type GuardApproval = v.InferOutput<typeof GuardApprovalSchema>;
+declare const BatchGuardApprovalsSchema: v.ObjectSchema<{
+  readonly approvals: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly nonceSpace: v.BigintSchema<undefined>;
+    readonly deadlineUnix: v.BigintSchema<undefined>;
+    readonly signature: v.InstanceSchema<Uint8ArrayConstructor, undefined>;
+  }, undefined>, v.TransformAction<{
+    nonceSpace: bigint;
+    deadlineUnix: bigint;
+    signature: Uint8Array<ArrayBuffer>;
+  }, {
+    nonceSpace: string;
+    deadlineUnix: string;
+    signature: `0x${string}`;
+    raw: {
+      nonceSpace: bigint;
+      deadlineUnix: bigint;
+      signature: Uint8Array<ArrayBuffer>;
+    };
+  }>]>, undefined>;
+}, undefined>;
+type BatchGuardApprovals = v.InferOutput<typeof BatchGuardApprovalsSchema>;
+declare const CreateGuardSignerWalletResultSchema: v.ObjectSchema<{
+  readonly signerAddress: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, undefined>]>;
+}, undefined>;
+type CreateGuardSignerWalletResult = v.InferOutput<typeof CreateGuardSignerWalletResultSchema>;
+declare const RotateGuardSignerWalletResultSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly newSignerAddress: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, undefined>]>;
+  readonly approval: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly nonceSpace: v.BigintSchema<undefined>;
+    readonly deadlineUnix: v.BigintSchema<undefined>;
+    readonly signature: v.InstanceSchema<Uint8ArrayConstructor, undefined>;
+  }, undefined>, v.TransformAction<{
+    nonceSpace: bigint;
+    deadlineUnix: bigint;
+    signature: Uint8Array<ArrayBuffer>;
+  }, {
+    nonceSpace: string;
+    deadlineUnix: string;
+    signature: `0x${string}`;
+    raw: {
+      nonceSpace: bigint;
+      deadlineUnix: bigint;
+      signature: Uint8Array<ArrayBuffer>;
+    };
+  }>]>, undefined>;
+}, undefined>, v.TransformAction<{
+  newSignerAddress: string;
+  approval?: {
+    nonceSpace: string;
+    deadlineUnix: string;
+    signature: `0x${string}`;
+    raw: {
+      nonceSpace: bigint;
+      deadlineUnix: bigint;
+      signature: Uint8Array<ArrayBuffer>;
+    };
+  } | undefined;
+}, {
+  newSignerAddress: string;
+  approval: {
+    nonceSpace: string;
+    deadlineUnix: string;
+    signature: `0x${string}`;
+    raw: {
+      nonceSpace: bigint;
+      deadlineUnix: bigint;
+      signature: Uint8Array<ArrayBuffer>;
+    };
+  } | null;
+}>]>;
+type RotateGuardSignerWalletResult = v.InferOutput<typeof RotateGuardSignerWalletResultSchema>;
+declare const ExportGuardSignerWalletResultSchema: v.ObjectSchema<{
+  readonly privateKey: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, undefined>]>;
+}, undefined>;
+type ExportGuardSignerWalletResult = v.InferOutput<typeof ExportGuardSignerWalletResultSchema>;
+//#endregion
+export { BatchGuardApprovals, BatchGuardApprovalsSchema, BatchSignProtectedActionInput, BatchSignProtectedActionInputSchema, CreateGuardSignerWalletResult, CreateGuardSignerWalletResultSchema, ExportGuardSignerWalletResult, ExportGuardSignerWalletResultSchema, GuardApproval, GuardApprovalSchema, GuardSignerScopedInput, GuardSignerScopedInputSchema, GuardSignerStatus, GuardSignerStatusSchema, RotateGuardSignerWalletResult, RotateGuardSignerWalletResultSchema, SignProtectedActionInput, SignProtectedActionInputSchema };
+//# sourceMappingURL=guard-signer.schemas.d.ts.map

package/dist/services/guard-signer/guard-signer.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard-signer.schemas.d.ts","names":[],"sources":["../../../src/services/guard-signer/guard-signer.schemas.ts"],"mappings":";;;cAYa,8BAA4B,EAAA,yBAAA,EAAA;;;;;;;;;;;KAS7B,yBAAyB,EAAE,kBAAkB;cAoD5C,gCAA8B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAa/B,2BAA2B,EAAE,kBAAkB;cAE9C,qCAAmC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsBpC,gCAAgC,EAAE,kBACnC;cAGE,yBAAuB,EAAA;;;;;;;KAQxB,oBAAoB,EAAE,mBAAmB;cAExC,qBAAmB,EAAA,yBAAA,EAAA;;;;;;;;;;;EAS4B;;;;;;;KAKhD,gBAAgB,EAAE,mBAAmB;cAEpC,2BAAyB,EAAA;;;;;;;;;;;;IAPsB;;;;;;;;KAWhD,sBAAsB,EAAE,mBAAmB;cAE1C,qCAAmC,EAAA;;;KAIpC,gCAAgC,EAAE,mBACnC;cAGE,qCAAmC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;IArBY;;;;;;;;;;;;IAAA;;;;;;;;;;;;IAAA;;;;;;;;KAgChD,gCAAgC,EAAE,mBACnC;cAGE,qCAAmC,EAAA;;;KAIpC,gCAAgC,EAAE,mBACnC"}

package/dist/services/guard-signer/guard-signer.schemas.js

@@ -0,0 +1,93 @@
+import { AccountScopeInputEntries, accountScopeToSubaccountId } from "../../shared/account-scope.js";
+import { PROTECTED_ACTION_VALUES, ProtectedActionCodec } from "./guard-signer.codecs.js";
+import * as v from "valibot";
+import { bytesToHex } from "@noble/hashes/utils.js";
+//#region src/services/guard-signer/guard-signer.schemas.ts
+const HexAddressSchema = v.pipe(v.string(), v.trim(), v.regex(/^0x[0-9a-fA-F]{40}$/));
+const WhitelistAddressSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
+const GuardSignerScopedInputSchema = v.pipe(v.strictObject({ ...AccountScopeInputEntries }), v.transform(({ account }) => ({ subaccountId: accountScopeToSubaccountId(account) })));
+const ProtectedActionArgsInputSchema = v.variant("case", [
+	v.strictObject({
+		case: v.literal("externalWhitelist"),
+		polychainChainId: v.pipe(v.number(), v.integer(), v.gtValue(0)),
+		addresses: v.pipe(v.array(WhitelistAddressSchema), v.minLength(1))
+	}),
+	v.strictObject({
+		case: v.literal("internalWhitelist"),
+		addresses: v.pipe(v.array(WhitelistAddressSchema), v.minLength(1))
+	}),
+	v.strictObject({
+		case: v.literal("whitelistRequirement"),
+		required: v.boolean()
+	})
+]);
+function toProtectedActionArgs(args) {
+	if (args.case === "externalWhitelist") return { args: {
+		case: "externalWhitelist",
+		value: {
+			polychainChainId: args.polychainChainId,
+			addresses: args.addresses
+		}
+	} };
+	if (args.case === "internalWhitelist") return { args: {
+		case: "internalWhitelist",
+		value: { addresses: args.addresses }
+	} };
+	return { args: {
+		case: "whitelistRequirement",
+		value: { required: args.required }
+	} };
+}
+const SignProtectedActionInputSchema = v.pipe(v.strictObject({
+	...AccountScopeInputEntries,
+	action: v.picklist(PROTECTED_ACTION_VALUES),
+	args: v.optional(ProtectedActionArgsInputSchema)
+}), v.transform(({ account, action, args }) => ({
+	subaccountId: accountScopeToSubaccountId(account),
+	action: ProtectedActionCodec.inputToProto[action],
+	args: args ? toProtectedActionArgs(args) : void 0
+})));
+const BatchSignProtectedActionInputSchema = v.pipe(v.strictObject({
+	...AccountScopeInputEntries,
+	actions: v.pipe(v.array(v.strictObject({
+		action: v.picklist(PROTECTED_ACTION_VALUES),
+		args: v.optional(ProtectedActionArgsInputSchema)
+	})), v.minLength(1, "At least one protected action is required."))
+}), v.transform(({ account, actions }) => ({
+	subaccountId: accountScopeToSubaccountId(account),
+	actions: actions.map(({ action, args }) => ({
+		action: ProtectedActionCodec.inputToProto[action],
+		args: args ? toProtectedActionArgs(args) : void 0
+	}))
+})));
+const GuardSignerStatusSchema = v.object({
+	signerAddress: v.string(),
+	onchainSignerAddress: v.string(),
+	initialized: v.boolean(),
+	nonce: v.string(),
+	nonceSpace: v.bigint()
+});
+const GuardApprovalSchema = v.pipe(v.object({
+	nonceSpace: v.bigint(),
+	deadlineUnix: v.bigint(),
+	signature: v.instance(Uint8Array)
+}), v.transform((approval) => ({
+	nonceSpace: approval.nonceSpace.toString(),
+	deadlineUnix: approval.deadlineUnix.toString(),
+	signature: `0x${bytesToHex(approval.signature)}`,
+	raw: approval
+})));
+const BatchGuardApprovalsSchema = v.object({ approvals: v.array(GuardApprovalSchema) });
+const CreateGuardSignerWalletResultSchema = v.object({ signerAddress: HexAddressSchema });
+const RotateGuardSignerWalletResultSchema = v.pipe(v.object({
+	newSignerAddress: HexAddressSchema,
+	approval: v.optional(GuardApprovalSchema)
+}), v.transform((result) => ({
+	newSignerAddress: result.newSignerAddress,
+	approval: result.approval ?? null
+})));
+const ExportGuardSignerWalletResultSchema = v.object({ privateKey: v.pipe(v.string(), v.trim(), v.regex(/^0x[0-9a-fA-F]{64}$/)) });
+//#endregion
+export { BatchGuardApprovalsSchema, BatchSignProtectedActionInputSchema, CreateGuardSignerWalletResultSchema, ExportGuardSignerWalletResultSchema, GuardApprovalSchema, GuardSignerScopedInputSchema, GuardSignerStatusSchema, RotateGuardSignerWalletResultSchema, SignProtectedActionInputSchema };
+
+//# sourceMappingURL=guard-signer.schemas.js.map

package/dist/services/guard-signer/guard-signer.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard-signer.schemas.js","names":[],"sources":["../../../src/services/guard-signer/guard-signer.schemas.ts"],"sourcesContent":["import { bytesToHex } from \"@noble/hashes/utils.js\";\nimport * as v from \"valibot\";\nimport { PROTECTED_ACTION_VALUES, ProtectedActionCodec } from \"./guard-signer.codecs.js\";\nimport {\n    AccountScopeInputEntries,\n    accountScopeToSubaccountId,\n} from \"../../shared/account-scope.js\";\n\nconst HexAddressSchema = v.pipe(v.string(), v.trim(), v.regex(/^0x[0-9a-fA-F]{40}$/));\n\nconst WhitelistAddressSchema = v.pipe(v.string(), v.trim(), v.minLength(1));\n\nexport const GuardSignerScopedInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n    }),\n    v.transform(({ account }) => ({\n        subaccountId: accountScopeToSubaccountId(account),\n    })),\n);\n\nexport type GuardSignerScopedInput = v.InferInput<typeof GuardSignerScopedInputSchema>;\n\nconst ProtectedActionArgsInputSchema = v.variant(\"case\", [\n    v.strictObject({\n        case: v.literal(\"externalWhitelist\"),\n        polychainChainId: v.pipe(v.number(), v.integer(), v.gtValue(0)),\n        addresses: v.pipe(v.array(WhitelistAddressSchema), v.minLength(1)),\n    }),\n    v.strictObject({\n        case: v.literal(\"internalWhitelist\"),\n        addresses: v.pipe(v.array(WhitelistAddressSchema), v.minLength(1)),\n    }),\n    v.strictObject({\n        case: v.literal(\"whitelistRequirement\"),\n        required: v.boolean(),\n    }),\n]);\n\nfunction toProtectedActionArgs(args: v.InferOutput<typeof ProtectedActionArgsInputSchema>) {\n    if (args.case === \"externalWhitelist\") {\n        return {\n            args: {\n                case: \"externalWhitelist\" as const,\n                value: {\n                    polychainChainId: args.polychainChainId,\n                    addresses: args.addresses,\n                },\n            },\n        };\n    }\n\n    if (args.case === \"internalWhitelist\") {\n        return {\n            args: {\n                case: \"internalWhitelist\" as const,\n                value: {\n                    addresses: args.addresses,\n                },\n            },\n        };\n    }\n\n    return {\n        args: {\n            case: \"whitelistRequirement\" as const,\n            value: {\n                required: args.required,\n            },\n        },\n    };\n}\n\nexport const SignProtectedActionInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n        action: v.picklist(PROTECTED_ACTION_VALUES),\n        args: v.optional(ProtectedActionArgsInputSchema),\n    }),\n    v.transform(({ account, action, args }) => ({\n        subaccountId: accountScopeToSubaccountId(account),\n        action: ProtectedActionCodec.inputToProto[action],\n        args: args ? toProtectedActionArgs(args) : undefined,\n    })),\n);\n\nexport type SignProtectedActionInput = v.InferInput<typeof SignProtectedActionInputSchema>;\n\nexport const BatchSignProtectedActionInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n        actions: v.pipe(\n            v.array(\n                v.strictObject({\n                    action: v.picklist(PROTECTED_ACTION_VALUES),\n                    args: v.optional(ProtectedActionArgsInputSchema),\n                }),\n            ),\n            v.minLength(1, \"At least one protected action is required.\"),\n        ),\n    }),\n    v.transform(({ account, actions }) => ({\n        subaccountId: accountScopeToSubaccountId(account),\n        actions: actions.map(({ action, args }) => ({\n            action: ProtectedActionCodec.inputToProto[action],\n            args: args ? toProtectedActionArgs(args) : undefined,\n        })),\n    })),\n);\n\nexport type BatchSignProtectedActionInput = v.InferInput<\n    typeof BatchSignProtectedActionInputSchema\n>;\n\nexport const GuardSignerStatusSchema = v.object({\n    signerAddress: v.string(),\n    onchainSignerAddress: v.string(),\n    initialized: v.boolean(),\n    nonce: v.string(),\n    nonceSpace: v.bigint(),\n});\n\nexport type GuardSignerStatus = v.InferOutput<typeof GuardSignerStatusSchema>;\n\nexport const GuardApprovalSchema = v.pipe(\n    v.object({\n        nonceSpace: v.bigint(),\n        deadlineUnix: v.bigint(),\n        signature: v.instance(Uint8Array),\n    }),\n    v.transform((approval) => ({\n        nonceSpace: approval.nonceSpace.toString(),\n        deadlineUnix: approval.deadlineUnix.toString(),\n        signature: `0x${bytesToHex(approval.signature)}` as `0x${string}`,\n        raw: approval,\n    })),\n);\n\nexport type GuardApproval = v.InferOutput<typeof GuardApprovalSchema>;\n\nexport const BatchGuardApprovalsSchema = v.object({\n    approvals: v.array(GuardApprovalSchema),\n});\n\nexport type BatchGuardApprovals = v.InferOutput<typeof BatchGuardApprovalsSchema>;\n\nexport const CreateGuardSignerWalletResultSchema = v.object({\n    signerAddress: HexAddressSchema,\n});\n\nexport type CreateGuardSignerWalletResult = v.InferOutput<\n    typeof CreateGuardSignerWalletResultSchema\n>;\n\nexport const RotateGuardSignerWalletResultSchema = v.pipe(\n    v.object({\n        newSignerAddress: HexAddressSchema,\n        approval: v.optional(GuardApprovalSchema),\n    }),\n    v.transform((result) => ({\n        newSignerAddress: result.newSignerAddress,\n        approval: result.approval ?? null,\n    })),\n);\n\nexport type RotateGuardSignerWalletResult = v.InferOutput<\n    typeof RotateGuardSignerWalletResultSchema\n>;\n\nexport const ExportGuardSignerWalletResultSchema = v.object({\n    privateKey: v.pipe(v.string(), v.trim(), v.regex(/^0x[0-9a-fA-F]{64}$/)),\n});\n\nexport type ExportGuardSignerWalletResult = v.InferOutput<\n    typeof ExportGuardSignerWalletResultSchema\n>;\n"],"mappings":"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"}

package/dist/services/guard-signer/guard-signer.types.d.ts

@@ -0,0 +1,2 @@
+import { BatchGuardApprovals, BatchSignProtectedActionInput, CreateGuardSignerWalletResult, ExportGuardSignerWalletResult, GuardApproval, GuardSignerScopedInput, GuardSignerStatus, RotateGuardSignerWalletResult, SignProtectedActionInput } from "./guard-signer.schemas.js";
+export type { BatchGuardApprovals, BatchSignProtectedActionInput, CreateGuardSignerWalletResult, ExportGuardSignerWalletResult, GuardApproval, GuardSignerScopedInput, GuardSignerStatus, RotateGuardSignerWalletResult, SignProtectedActionInput };

package/dist/services/guard-signer/index.d.ts

@@ -0,0 +1,4 @@
+import { BatchGuardApprovals, BatchSignProtectedActionInput, CreateGuardSignerWalletResult, ExportGuardSignerWalletResult, GuardApproval, GuardSignerScopedInput, GuardSignerStatus, RotateGuardSignerWalletResult, SignProtectedActionInput } from "./guard-signer.schemas.js";
+import { GuardSignerService } from "./guard-signer.js";
+import "./guard-signer.codecs.js";
+export { GuardSignerService };

package/dist/services/heatmap/heatmap.codecs.d.ts

@@ -0,0 +1,11 @@
+import "../../gen/marketdata/v1/heatmap_pb.js";
+//#region src/services/heatmap/heatmap.codecs.d.ts
+declare const HEATMAP_INTERVAL_VALUES: readonly ["1s", "1m", "5m", "1h"];
+type HeatmapIntervalValue = (typeof HEATMAP_INTERVAL_VALUES)[number];
+declare const HEATMAP_DEPTH_VALUES: readonly [1, 5, 10, 20, 50, 100, 200, 500, 1000];
+type HeatmapDepthValue = (typeof HEATMAP_DEPTH_VALUES)[number];
+declare const HEATMAP_QUANTITY_MODE_VALUES: readonly ["close", "peak"];
+type HeatmapQuantityModeValue = (typeof HEATMAP_QUANTITY_MODE_VALUES)[number];
+//#endregion
+export { HEATMAP_DEPTH_VALUES, HEATMAP_INTERVAL_VALUES, HEATMAP_QUANTITY_MODE_VALUES, HeatmapDepthValue, HeatmapIntervalValue, HeatmapQuantityModeValue };
+//# sourceMappingURL=heatmap.codecs.d.ts.map

package/dist/services/heatmap/heatmap.codecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heatmap.codecs.d.ts","names":[],"sources":["../../../src/services/heatmap/heatmap.codecs.ts"],"mappings":";;cAOa;KACD,+BAA+B;cAE9B;KACD,4BAA4B;cAE3B;KACD,mCAAmC"}

package/dist/services/heatmap/heatmap.codecs.js

@@ -0,0 +1,76 @@
+import "../../gen/marketdata/v1/heatmap_pb.js";
+//#region src/services/heatmap/heatmap.codecs.ts
+const HEATMAP_INTERVAL_VALUES = [
+	"1s",
+	"1m",
+	"5m",
+	"1h"
+];
+const HEATMAP_DEPTH_VALUES = [
+	1,
+	5,
+	10,
+	20,
+	50,
+	100,
+	200,
+	500,
+	1e3
+];
+const HEATMAP_QUANTITY_MODE_VALUES = ["close", "peak"];
+const HeatmapIntervalCodec = {
+	inputToProto: {
+		"1s": 1,
+		"1m": 2,
+		"5m": 3,
+		"1h": 4
+	},
+	protoToOutput: {
+		[0]: "unspecified",
+		[1]: "1s",
+		[2]: "1m",
+		[3]: "5m",
+		[4]: "1h"
+	}
+};
+const HeatmapDepthCodec = {
+	inputToProto: {
+		1: 1,
+		5: 2,
+		10: 3,
+		20: 4,
+		50: 5,
+		100: 6,
+		200: 7,
+		500: 8,
+		1e3: 9
+	},
+	protoToOutput: {
+		[0]: "unspecified",
+		[1]: 1,
+		[2]: 5,
+		[3]: 10,
+		[4]: 20,
+		[5]: 50,
+		[6]: 100,
+		[7]: 200,
+		[8]: 500,
+		[9]: 1e3
+	},
+	supportedDepths: HEATMAP_DEPTH_VALUES
+};
+const HeatmapQuantityModeCodec = {
+	inputToProto: {
+		close: 1,
+		peak: 2
+	},
+	protoToOutput: {
+		[0]: "unspecified",
+		[1]: "close",
+		[2]: "peak"
+	}
+};
+//#endregion
+export { HEATMAP_DEPTH_VALUES, HEATMAP_INTERVAL_VALUES, HEATMAP_QUANTITY_MODE_VALUES, HeatmapDepthCodec, HeatmapIntervalCodec, HeatmapQuantityModeCodec };
+
+//# sourceMappingURL=heatmap.codecs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heatmap.codecs.js","names":[],"sources":["../../../src/services/heatmap/heatmap.codecs.ts"],"sourcesContent":["import {\n    HeatmapDepth,\n    HeatmapInterval,\n    HeatmapQuantityMode,\n} from \"../../gen/marketdata/v1/heatmap_pb.js\";\nimport type { InputToProto, ProtoToOutput } from \"../../utils/types.js\";\n\nexport const HEATMAP_INTERVAL_VALUES = [\"1s\", \"1m\", \"5m\", \"1h\"] as const;\nexport type HeatmapIntervalValue = (typeof HEATMAP_INTERVAL_VALUES)[number];\n\nexport const HEATMAP_DEPTH_VALUES = [1, 5, 10, 20, 50, 100, 200, 500, 1000] as const;\nexport type HeatmapDepthValue = (typeof HEATMAP_DEPTH_VALUES)[number];\n\nexport const HEATMAP_QUANTITY_MODE_VALUES = [\"close\", \"peak\"] as const;\nexport type HeatmapQuantityModeValue = (typeof HEATMAP_QUANTITY_MODE_VALUES)[number];\n\nexport const HeatmapIntervalCodec = {\n    inputToProto: {\n        \"1s\": HeatmapInterval.INTERVAL_1S,\n        \"1m\": HeatmapInterval.INTERVAL_1M,\n        \"5m\": HeatmapInterval.INTERVAL_5M,\n        \"1h\": HeatmapInterval.INTERVAL_1H,\n    } satisfies InputToProto<HeatmapIntervalValue, HeatmapInterval>,\n    protoToOutput: {\n        [HeatmapInterval.INTERVAL_UNSPECIFIED]: \"unspecified\",\n        [HeatmapInterval.INTERVAL_1S]: \"1s\",\n        [HeatmapInterval.INTERVAL_1M]: \"1m\",\n        [HeatmapInterval.INTERVAL_5M]: \"5m\",\n        [HeatmapInterval.INTERVAL_1H]: \"1h\",\n    } satisfies ProtoToOutput<HeatmapInterval, HeatmapIntervalValue>,\n} as const;\n\nexport const HeatmapDepthCodec = {\n    inputToProto: {\n        1: HeatmapDepth.DEPTH_1,\n        5: HeatmapDepth.DEPTH_5,\n        10: HeatmapDepth.DEPTH_10,\n        20: HeatmapDepth.DEPTH_20,\n        50: HeatmapDepth.DEPTH_50,\n        100: HeatmapDepth.DEPTH_100,\n        200: HeatmapDepth.DEPTH_200,\n        500: HeatmapDepth.DEPTH_500,\n        1000: HeatmapDepth.DEPTH_1000,\n    } satisfies InputToProto<HeatmapDepthValue, HeatmapDepth>,\n    protoToOutput: {\n        [HeatmapDepth.DEPTH_UNSPECIFIED]: \"unspecified\",\n        [HeatmapDepth.DEPTH_1]: 1,\n        [HeatmapDepth.DEPTH_5]: 5,\n        [HeatmapDepth.DEPTH_10]: 10,\n        [HeatmapDepth.DEPTH_20]: 20,\n        [HeatmapDepth.DEPTH_50]: 50,\n        [HeatmapDepth.DEPTH_100]: 100,\n        [HeatmapDepth.DEPTH_200]: 200,\n        [HeatmapDepth.DEPTH_500]: 500,\n        [HeatmapDepth.DEPTH_1000]: 1000,\n    } satisfies ProtoToOutput<HeatmapDepth, HeatmapDepthValue>,\n    supportedDepths: HEATMAP_DEPTH_VALUES,\n} as const;\n\nexport const HeatmapQuantityModeCodec = {\n    inputToProto: {\n        close: HeatmapQuantityMode.CLOSE,\n        peak: HeatmapQuantityMode.PEAK,\n    } satisfies InputToProto<HeatmapQuantityModeValue, HeatmapQuantityMode>,\n    protoToOutput: {\n        [HeatmapQuantityMode.QTY_MODE_UNSPECIFIED]: \"unspecified\",\n        [HeatmapQuantityMode.CLOSE]: \"close\",\n        [HeatmapQuantityMode.PEAK]: \"peak\",\n    } satisfies ProtoToOutput<HeatmapQuantityMode, HeatmapQuantityModeValue>,\n} as const;\n"],"mappings":";;AAOA,MAAa,0BAA0B;CAAC;CAAM;CAAM;CAAM;AAAI;AAG9D,MAAa,uBAAuB;CAAC;CAAG;CAAG;CAAI;CAAI;CAAI;CAAK;CAAK;CAAK;AAAI;AAG1E,MAAa,+BAA+B,CAAC,SAAS,MAAM;AAG5D,MAAa,uBAAuB;CAChC,cAAc;EACV,MAAA;EACA,MAAA;EACA,MAAA;EACA,MAAA;CACJ;CACA,eAAe;GAC6B,IAAA;GACT,IAAA;GACA,IAAA;GACA,IAAA;GACA,IAAA;CACnC;AACJ;AAEA,MAAa,oBAAoB;CAC7B,cAAc;EACV,GAAA;EACA,GAAA;EACA,IAAA;EACA,IAAA;EACA,IAAA;EACA,KAAA;EACA,KAAA;EACA,KAAA;EACA,KAAA;CACJ;CACA,eAAe;GACuB,IAAA;GACV,IAAA;GACA,IAAA;GACC,IAAA;GACA,IAAA;GACA,IAAA;GACC,IAAA;GACA,IAAA;GACA,IAAA;GACC,IAAA;CAC/B;CACA,iBAAiB;AACrB;AAEA,MAAa,2BAA2B;CACpC,cAAc;EACV,OAAA;EACA,MAAA;CACJ;CACA,eAAe;GACiC,IAAA;GACf,IAAA;GACD,IAAA;CAChC;AACJ"}

package/dist/services/heatmap/heatmap.d.ts

@@ -0,0 +1,33 @@
+import { PolyesterRequestOptions } from "../../shared/request-options.js";
+import { PolyesterRealtime } from "../../realtime/types.js";
+import { BaseSubscribeInput } from "../../shared/types.js";
+import { SdkScales } from "../../shared/decimal-surface.js";
+import { HeatmapIntervalValue } from "./heatmap.codecs.js";
+import { GetOrderbookHeatmapInput, OrderbookHeatmapLiveBucket, OrderbookHeatmapResponse } from "./heatmap.schemas.js";
+import { Transport } from "@connectrpc/connect";
+//#region src/services/heatmap/heatmap.d.ts
+interface OrderbookHeatmapProvider {
+  getOrderbookHeatmap(input: GetOrderbookHeatmapInput, options?: PolyesterRequestOptions): Promise<OrderbookHeatmapResponse>;
+}
+interface SubscribeHeatmapLiveInput extends BaseSubscribeInput<OrderbookHeatmapLiveBucket> {
+  symbolId: number;
+  interval: HeatmapIntervalValue;
+}
+/**
+ * Reads historical order book heatmap chains and streams live heatmap buckets.
+ */
+declare class HeatmapService implements OrderbookHeatmapProvider {
+  #private;
+  constructor(transport: Transport, realtime: PolyesterRealtime, scales: SdkScales);
+  /**
+   * Fetches order book heatmap data for a symbol, interval, depth, and quantity mode using either an absolute time range or cursor pagination. The response includes a keyframe anchor, delta buckets, pagination metadata, and live-anchor fields when available.
+   */
+  getOrderbookHeatmap(input: GetOrderbookHeatmapInput, options?: PolyesterRequestOptions): Promise<OrderbookHeatmapResponse>;
+  /**
+   * Subscribes to live heatmap buckets on public:spot:market:heatmap:{interval}:{symbolId}:proto and emits parsed bid/ask delta buckets for the selected interval.
+   */
+  subscribeLive(input: SubscribeHeatmapLiveInput): () => void;
+}
+//#endregion
+export { HeatmapService, OrderbookHeatmapProvider };
+//# sourceMappingURL=heatmap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heatmap.d.ts","names":[],"sources":["../../../src/services/heatmap/heatmap.ts"],"mappings":";;;;;;;;UA0BiB;EACb,oBACI,OAAO,0BACP,UAAU,0BACX,QAAQ;;UAGL,kCAAkC,mBAAmB;EAC3D;EACA,UAAU;;;;;cAWD,0BAA0B;;EAOvB,YAAA,WAAW,WAAW,UAAU,mBAAmB,QAAQ;;;;EAWjE,oBACF,OAAO,0BACP,UAAU,0BACX,QAAQ;;;;EA4BX,cAAc,OAAO"}

package/dist/services/heatmap/heatmap.js

@@ -0,0 +1,79 @@
+import { HeatmapLiveBucketSchema, HeatmapService as HeatmapService$1, HeatmapTimeRangeSchema } from "../../gen/marketdata/v1/heatmap_pb.js";
+import { toConnectCallOptions } from "../../shared/request-options.js";
+import { publicationHandlerErrorContext } from "../../shared/subscription-errors.js";
+import { createReadyGate } from "../../shared/decimal-surface.js";
+import { HEATMAP_INTERVAL_VALUES } from "./heatmap.codecs.js";
+import { GetOrderbookHeatmapInputSchema, createOrderbookHeatmapLiveBucketSchema, createOrderbookHeatmapResponseSchema } from "./heatmap.schemas.js";
+import { create } from "@bufbuild/protobuf";
+import { createClient } from "@connectrpc/connect";
+import * as v from "valibot";
+//#region src/services/heatmap/heatmap.ts
+const SubscribeHeatmapLiveParamsSchema = v.object({
+	symbolId: v.pipe(v.number(), v.integer(), v.gtValue(0)),
+	interval: v.picklist(HEATMAP_INTERVAL_VALUES)
+});
+/**
+* Reads historical order book heatmap chains and streams live heatmap buckets.
+*/
+var HeatmapService = class {
+	#client;
+	#realtime;
+	#scales;
+	#responseSchema;
+	#liveBucketSchema;
+	constructor(transport, realtime, scales) {
+		this.#client = createClient(HeatmapService$1, transport);
+		this.#realtime = realtime;
+		this.#scales = scales;
+		this.#responseSchema = createOrderbookHeatmapResponseSchema(scales);
+		this.#liveBucketSchema = createOrderbookHeatmapLiveBucketSchema(scales);
+	}
+	/**
+	* Fetches order book heatmap data for a symbol, interval, depth, and quantity mode using either an absolute time range or cursor pagination. The response includes a keyframe anchor, delta buckets, pagination metadata, and live-anchor fields when available.
+	*/
+	async getOrderbookHeatmap(input, options) {
+		const parsed = v.parse(GetOrderbookHeatmapInputSchema, input);
+		await this.#scales.ready();
+		const res = await this.#client.getOrderbookHeatmap({
+			symbolId: parsed.symbolId,
+			interval: parsed.interval,
+			depth: parsed.depth,
+			quantityMode: parsed.quantityMode,
+			limit: parsed.limit ?? 0,
+			pageToken: parsed.pageToken,
+			timeRange: parsed.timeRange != null ? create(HeatmapTimeRangeSchema, {
+				startTime: parsed.timeRange.startTime,
+				endTime: parsed.timeRange.endTime
+			}) : void 0
+		}, toConnectCallOptions(options));
+		return v.parse(this.#responseSchema, res);
+	}
+	/**
+	* Subscribes to live heatmap buckets on public:spot:market:heatmap:{interval}:{symbolId}:proto and emits parsed bid/ask delta buckets for the selected interval.
+	*/
+	subscribeLive(input) {
+		const params = v.parse(SubscribeHeatmapLiveParamsSchema, {
+			symbolId: input.symbolId,
+			interval: input.interval
+		});
+		const channel = `public:spot:market:heatmap:${params.interval}:${params.symbolId}:proto`;
+		const gate = createReadyGate(() => this.#scales.ready(), (error) => input.onError?.(publicationHandlerErrorContext(channel, error)));
+		return this.#realtime.connectProtoChannel({
+			channel,
+			schema: HeatmapLiveBucketSchema,
+			onPublication: (data) => {
+				gate.run(() => {
+					const bucket = v.parse(this.#liveBucketSchema, data);
+					input.onEvent(bucket);
+				});
+			},
+			onConnected: input.onOpen,
+			onDisconnected: input.onClose,
+			onError: input.onError
+		});
+	}
+};
+//#endregion
+export { HeatmapService };
+
+//# sourceMappingURL=heatmap.js.map

package/dist/services/heatmap/heatmap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heatmap.js","names":["#client","HeatmapRpc","#realtime","#scales","#responseSchema","#liveBucketSchema","ProtoHeatmapLiveBucketSchema"],"sources":["../../../src/services/heatmap/heatmap.ts"],"sourcesContent":["import { createClient, type Client, type Transport } from \"@connectrpc/connect\";\nimport { create } from \"@bufbuild/protobuf\";\nimport { publicationHandlerErrorContext } from \"../../shared/subscription-errors.js\";\nimport {\n    HeatmapService as HeatmapRpc,\n    HeatmapLiveBucketSchema as ProtoHeatmapLiveBucketSchema,\n    HeatmapTimeRangeSchema,\n} from \"../../gen/marketdata/v1/heatmap_pb.js\";\nimport type { PolyesterRealtime } from \"../../realtime/types.js\";\nimport type { BaseSubscribeInput } from \"../../shared/types.js\";\nimport {\n    toConnectCallOptions,\n    type PolyesterRequestOptions,\n} from \"../../shared/request-options.js\";\nimport { createReadyGate, type SdkScales } from \"../../shared/decimal-surface.js\";\nimport { HEATMAP_INTERVAL_VALUES, type HeatmapIntervalValue } from \"./heatmap.codecs.js\";\nimport * as v from \"valibot\";\nimport {\n    GetOrderbookHeatmapInputSchema,\n    createOrderbookHeatmapLiveBucketSchema,\n    createOrderbookHeatmapResponseSchema,\n    type GetOrderbookHeatmapInput,\n    type OrderbookHeatmapLiveBucket,\n    type OrderbookHeatmapResponse,\n} from \"./heatmap.schemas.js\";\n\nexport interface OrderbookHeatmapProvider {\n    getOrderbookHeatmap(\n        input: GetOrderbookHeatmapInput,\n        options?: PolyesterRequestOptions,\n    ): Promise<OrderbookHeatmapResponse>;\n}\n\ninterface SubscribeHeatmapLiveInput extends BaseSubscribeInput<OrderbookHeatmapLiveBucket> {\n    symbolId: number;\n    interval: HeatmapIntervalValue;\n}\n\nconst SubscribeHeatmapLiveParamsSchema = v.object({\n    symbolId: v.pipe(v.number(), v.integer(), v.gtValue(0)),\n    interval: v.picklist(HEATMAP_INTERVAL_VALUES),\n});\n\n/**\n * Reads historical order book heatmap chains and streams live heatmap buckets.\n */\nexport class HeatmapService implements OrderbookHeatmapProvider {\n    #client: Client<typeof HeatmapRpc>;\n    #realtime: PolyesterRealtime;\n    #scales: SdkScales;\n    #responseSchema: ReturnType<typeof createOrderbookHeatmapResponseSchema>;\n    #liveBucketSchema: ReturnType<typeof createOrderbookHeatmapLiveBucketSchema>;\n\n    constructor(transport: Transport, realtime: PolyesterRealtime, scales: SdkScales) {\n        this.#client = createClient(HeatmapRpc, transport);\n        this.#realtime = realtime;\n        this.#scales = scales;\n        this.#responseSchema = createOrderbookHeatmapResponseSchema(scales);\n        this.#liveBucketSchema = createOrderbookHeatmapLiveBucketSchema(scales);\n    }\n\n    /**\n     * Fetches order book heatmap data for a symbol, interval, depth, and quantity mode using either an absolute time range or cursor pagination. The response includes a keyframe anchor, delta buckets, pagination metadata, and live-anchor fields when available.\n     */\n    async getOrderbookHeatmap(\n        input: GetOrderbookHeatmapInput,\n        options?: PolyesterRequestOptions,\n    ): Promise<OrderbookHeatmapResponse> {\n        const parsed = v.parse(GetOrderbookHeatmapInputSchema, input);\n        await this.#scales.ready();\n\n        const res = await this.#client.getOrderbookHeatmap(\n            {\n                symbolId: parsed.symbolId,\n                interval: parsed.interval,\n                depth: parsed.depth,\n                quantityMode: parsed.quantityMode,\n                limit: parsed.limit ?? 0,\n                pageToken: parsed.pageToken,\n                timeRange:\n                    parsed.timeRange != null\n                        ? create(HeatmapTimeRangeSchema, {\n                              startTime: parsed.timeRange.startTime,\n                              endTime: parsed.timeRange.endTime,\n                          })\n                        : undefined,\n            },\n            toConnectCallOptions(options),\n        );\n        return v.parse(this.#responseSchema, res);\n    }\n\n    /**\n     * Subscribes to live heatmap buckets on public:spot:market:heatmap:{interval}:{symbolId}:proto and emits parsed bid/ask delta buckets for the selected interval.\n     */\n    subscribeLive(input: SubscribeHeatmapLiveInput): () => void {\n        const params = v.parse(SubscribeHeatmapLiveParamsSchema, {\n            symbolId: input.symbolId,\n            interval: input.interval,\n        });\n        const channel = `public:spot:market:heatmap:${params.interval}:${params.symbolId}: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: ProtoHeatmapLiveBucketSchema,\n            onPublication: (data) => {\n                gate.run(() => {\n                    const bucket = v.parse(this.#liveBucketSchema, data);\n                    input.onEvent(bucket);\n                });\n            },\n            onConnected: input.onOpen,\n            onDisconnected: input.onClose,\n            onError: input.onError,\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;AAsCA,MAAM,mCAAmC,EAAE,OAAO;CAC9C,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,QAAQ,CAAC,CAAC;CACtD,UAAU,EAAE,SAAS,uBAAuB;AAChD,CAAC;;;;AAKD,IAAa,iBAAb,MAAgE;CAC5D;CACA;CACA;CACA;CACA;CAEA,YAAY,WAAsB,UAA6B,QAAmB;EAC9E,KAAKA,UAAU,aAAaC,kBAAY,SAAS;EACjD,KAAKC,YAAY;EACjB,KAAKC,UAAU;EACf,KAAKC,kBAAkB,qCAAqC,MAAM;EAClE,KAAKC,oBAAoB,uCAAuC,MAAM;CAC1E;;;;CAKA,MAAM,oBACF,OACA,SACiC;EACjC,MAAM,SAAS,EAAE,MAAM,gCAAgC,KAAK;EAC5D,MAAM,KAAKF,QAAQ,MAAM;EAEzB,MAAM,MAAM,MAAM,KAAKH,QAAQ,oBAC3B;GACI,UAAU,OAAO;GACjB,UAAU,OAAO;GACjB,OAAO,OAAO;GACd,cAAc,OAAO;GACrB,OAAO,OAAO,SAAS;GACvB,WAAW,OAAO;GAClB,WACI,OAAO,aAAa,OACd,OAAO,wBAAwB;IAC3B,WAAW,OAAO,UAAU;IAC5B,SAAS,OAAO,UAAU;GAC9B,CAAC,IACD,KAAA;EACd,GACA,qBAAqB,OAAO,CAChC;EACA,OAAO,EAAE,MAAM,KAAKI,iBAAiB,GAAG;CAC5C;;;;CAKA,cAAc,OAA8C;EACxD,MAAM,SAAS,EAAE,MAAM,kCAAkC;GACrD,UAAU,MAAM;GAChB,UAAU,MAAM;EACpB,CAAC;EACD,MAAM,UAAU,8BAA8B,OAAO,SAAS,GAAG,OAAO,SAAS;EACjF,MAAM,OAAO,sBACH,KAAKD,QAAQ,MAAM,IACxB,UAAU,MAAM,UAAU,+BAA+B,SAAS,KAAK,CAAC,CAC7E;EACA,OAAO,KAAKD,UAAU,oBAAoB;GACtC;GACA,QAAQI;GACR,gBAAgB,SAAS;IACrB,KAAK,UAAU;KACX,MAAM,SAAS,EAAE,MAAM,KAAKD,mBAAmB,IAAI;KACnD,MAAM,QAAQ,MAAM;IACxB,CAAC;GACL;GACA,aAAa,MAAM;GACnB,gBAAgB,MAAM;GACtB,SAAS,MAAM;EACnB,CAAC;CACL;AACJ"}