@polyester/sdk 0.0.0

package/dist/services/internal-transfers/internal-transfers.d.ts

@@ -0,0 +1,20 @@
+import { PolyesterMutationOptions } from "../../shared/request-options.js";
+import { SubaccountResolver } from "../subaccount-resolver.js";
+import { SdkScales } from "../../shared/decimal-surface.js";
+import { CreateInternalTransferInput, CreateInternalTransferResult } from "./internal-transfers.schemas.js";
+import { Transport } from "@connectrpc/connect";
+//#region src/services/internal-transfers/internal-transfers.d.ts
+/**
+ * Creates authenticated Trading-to-Trading internal transfer requests.
+ */
+declare class InternalTransfersService {
+  #private;
+  constructor(transport: Transport, resolver: SubaccountResolver | undefined, scales: SdkScales);
+  /**
+   * Creates or returns an idempotent internal transfer from the resolved source account to a destination root account, subaccount, or smart-account address. The request carries asset id, a decimal quantity, and a stable idempotency key; the response includes request/transfer ids, resolved destination, and status.
+   */
+  create(input: CreateInternalTransferInput, options?: PolyesterMutationOptions): Promise<CreateInternalTransferResult>;
+}
+//#endregion
+export { InternalTransfersService };
+//# sourceMappingURL=internal-transfers.d.ts.map

package/dist/services/internal-transfers/internal-transfers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-transfers.d.ts","names":[],"sources":["../../../src/services/internal-transfers/internal-transfers.ts"],"mappings":";;;;;;;;;cAoBa;;EAOG,YAAA,WAAW,WAAW,UAAU,gCAAgC,QAAQ;;;;EAW9E,OACF,OAAO,6BACP,UAAU,2BACX,QAAQ"}

package/dist/services/internal-transfers/internal-transfers.js

@@ -0,0 +1,39 @@
+import { InternalTransferService } from "../../gen/transfer/v1/internal_transfer_pb.js";
+import { toConnectCallOptions } from "../../shared/request-options.js";
+import { removeUndefined } from "../../utils/remove-undefined.js";
+import { resolveAccountScopedInput } from "../subaccount-resolver.js";
+import { createCreateInternalTransferInputSchema, createCreateInternalTransferResultSchema } from "./internal-transfers.schemas.js";
+import { createClient } from "@connectrpc/connect";
+import * as v from "valibot";
+//#region src/services/internal-transfers/internal-transfers.ts
+/**
+* Creates authenticated Trading-to-Trading internal transfer requests.
+*/
+var InternalTransfersService = class {
+	#client;
+	#resolver;
+	#scales;
+	#inputSchema;
+	#resultSchema;
+	constructor(transport, resolver, scales) {
+		this.#client = createClient(InternalTransferService, transport);
+		this.#resolver = resolver;
+		this.#scales = scales;
+		this.#inputSchema = createCreateInternalTransferInputSchema(scales);
+		this.#resultSchema = createCreateInternalTransferResultSchema();
+	}
+	/**
+	* Creates or returns an idempotent internal transfer from the resolved source account to a destination root account, subaccount, or smart-account address. The request carries asset id, a decimal quantity, and a stable idempotency key; the response includes request/transfer ids, resolved destination, and status.
+	*/
+	async create(input, options) {
+		await this.#scales.ready();
+		const resolvedInput = resolveAccountScopedInput(input, this.#resolver);
+		const validatedInput = v.parse(this.#inputSchema, resolvedInput);
+		const res = await this.#client.createInternalTransfer(removeUndefined(validatedInput), toConnectCallOptions(options));
+		return v.parse(this.#resultSchema, res);
+	}
+};
+//#endregion
+export { InternalTransfersService };
+
+//# sourceMappingURL=internal-transfers.js.map

package/dist/services/internal-transfers/internal-transfers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-transfers.js","names":["#client","Proto.InternalTransferService","#resolver","#scales","#inputSchema","#resultSchema"],"sources":["../../../src/services/internal-transfers/internal-transfers.ts"],"sourcesContent":["import { createClient, type Client, type Transport } from \"@connectrpc/connect\";\nimport * as Proto from \"../../gen/transfer/v1/internal_transfer_pb.js\";\nimport { removeUndefined } from \"../../utils/remove-undefined.js\";\nimport {\n    toConnectCallOptions,\n    type PolyesterMutationOptions,\n} from \"../../shared/request-options.js\";\nimport { type SubaccountResolver, resolveAccountScopedInput } from \"../subaccount-resolver.js\";\nimport type { SdkScales } from \"../../shared/decimal-surface.js\";\nimport * as v from \"valibot\";\nimport {\n    createCreateInternalTransferInputSchema,\n    createCreateInternalTransferResultSchema,\n    type CreateInternalTransferInput,\n    type CreateInternalTransferResult,\n} from \"./internal-transfers.schemas.js\";\n\n/**\n * Creates authenticated Trading-to-Trading internal transfer requests.\n */\nexport class InternalTransfersService {\n    #client: Client<typeof Proto.InternalTransferService>;\n    #resolver?: SubaccountResolver;\n    #scales: SdkScales;\n    #inputSchema: ReturnType<typeof createCreateInternalTransferInputSchema>;\n    #resultSchema: ReturnType<typeof createCreateInternalTransferResultSchema>;\n\n    constructor(transport: Transport, resolver: SubaccountResolver | undefined, scales: SdkScales) {\n        this.#client = createClient(Proto.InternalTransferService, transport);\n        this.#resolver = resolver;\n        this.#scales = scales;\n        this.#inputSchema = createCreateInternalTransferInputSchema(scales);\n        this.#resultSchema = createCreateInternalTransferResultSchema();\n    }\n\n    /**\n     * Creates or returns an idempotent internal transfer from the resolved source account to a destination root account, subaccount, or smart-account address. The request carries asset id, a decimal quantity, and a stable idempotency key; the response includes request/transfer ids, resolved destination, and status.\n     */\n    async create(\n        input: CreateInternalTransferInput,\n        options?: PolyesterMutationOptions,\n    ): Promise<CreateInternalTransferResult> {\n        await this.#scales.ready();\n        const resolvedInput = resolveAccountScopedInput(input, this.#resolver);\n        const validatedInput = v.parse(this.#inputSchema, resolvedInput);\n        const res = await this.#client.createInternalTransfer(\n            removeUndefined(validatedInput),\n            toConnectCallOptions(options),\n        );\n        return v.parse(this.#resultSchema, res);\n    }\n}\n"],"mappings":";;;;;;;;;;;AAoBA,IAAa,2BAAb,MAAsC;CAClC;CACA;CACA;CACA;CACA;CAEA,YAAY,WAAsB,UAA0C,QAAmB;EAC3F,KAAKA,UAAU,aAAaC,yBAA+B,SAAS;EACpE,KAAKC,YAAY;EACjB,KAAKC,UAAU;EACf,KAAKC,eAAe,wCAAwC,MAAM;EAClE,KAAKC,gBAAgB,yCAAyC;CAClE;;;;CAKA,MAAM,OACF,OACA,SACqC;EACrC,MAAM,KAAKF,QAAQ,MAAM;EACzB,MAAM,gBAAgB,0BAA0B,OAAO,KAAKD,SAAS;EACrE,MAAM,iBAAiB,EAAE,MAAM,KAAKE,cAAc,aAAa;EAC/D,MAAM,MAAM,MAAM,KAAKJ,QAAQ,uBAC3B,gBAAgB,cAAc,GAC9B,qBAAqB,OAAO,CAChC;EACA,OAAO,EAAE,MAAM,KAAKK,eAAe,GAAG;CAC1C;AACJ"}

package/dist/services/internal-transfers/internal-transfers.schemas.d.ts

@@ -0,0 +1,174 @@
+import { SdkScales } from "../../shared/decimal-surface.js";
+import { U128Value } from "../../utils/u128.js";
+import * as v from "valibot";
+//#region src/services/internal-transfers/internal-transfers.schemas.d.ts
+declare const InternalTransferDestinationInputSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.StrictObjectSchema<{
+  readonly type: v.LiteralSchema<"account", undefined>;
+  readonly accountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint>]>;
+}, undefined>, v.StrictObjectSchema<{
+  readonly type: v.LiteralSchema<"subaccount", undefined>;
+  readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint>]>;
+}, undefined>, v.StrictObjectSchema<{
+  readonly type: v.LiteralSchema<"smartAccountAddress", undefined>;
+  readonly address: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>], undefined>, v.TransformAction<{
+  type: "account";
+  accountId: bigint;
+} | {
+  type: "subaccount";
+  subaccountId: bigint;
+} | {
+  type: "smartAccountAddress";
+  address: string;
+}, {
+  readonly case: "destinationAccountId";
+  readonly value: bigint;
+} | {
+  readonly case: "destinationSubaccountId";
+  readonly value: bigint;
+} | {
+  readonly case: "destinationSmartAccountAddress";
+  readonly value: string;
+}>]>;
+type InternalTransferDestination = v.InferInput<typeof InternalTransferDestinationInputSchema>;
+declare function createCreateInternalTransferInputSchema(scales: SdkScales): v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly destination: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"account", undefined>;
+    readonly accountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint>]>;
+  }, undefined>, v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"subaccount", undefined>;
+    readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint>]>;
+  }, undefined>, v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"smartAccountAddress", undefined>;
+    readonly address: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  }, undefined>], undefined>, v.TransformAction<{
+    type: "account";
+    accountId: bigint;
+  } | {
+    type: "subaccount";
+    subaccountId: bigint;
+  } | {
+    type: "smartAccountAddress";
+    address: string;
+  }, {
+    readonly case: "destinationAccountId";
+    readonly value: bigint;
+  } | {
+    readonly case: "destinationSubaccountId";
+    readonly value: bigint;
+  } | {
+    readonly case: "destinationSmartAccountAddress";
+    readonly value: string;
+  }>]>;
+  readonly assetId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>]>;
+  readonly quantity: v.StringSchema<undefined>;
+  readonly idempotencyKey: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, 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<{
+  destination: {
+    readonly case: "destinationAccountId";
+    readonly value: bigint;
+  } | {
+    readonly case: "destinationSubaccountId";
+    readonly value: bigint;
+  } | {
+    readonly case: "destinationSmartAccountAddress";
+    readonly value: string;
+  };
+  assetId: number;
+  quantity: string;
+  idempotencyKey: string;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+}, {
+  amountE18: U128Value;
+  subaccountId: bigint | undefined;
+  destination: {
+    readonly case: "destinationAccountId";
+    readonly value: bigint;
+  } | {
+    readonly case: "destinationSubaccountId";
+    readonly value: bigint;
+  } | {
+    readonly case: "destinationSmartAccountAddress";
+    readonly value: string;
+  };
+  assetId: number;
+  idempotencyKey: string;
+}>]>;
+type CreateInternalTransferInput = v.InferInput<ReturnType<typeof createCreateInternalTransferInputSchema>>;
+declare const ResolvedInternalTransferDestinationSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly rootAccountPublicId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, string | undefined>]>;
+  readonly subaccountPublicId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, string | undefined>]>;
+  readonly smartAccountAddress: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, string | undefined>]>;
+}, undefined>, v.TransformAction<{
+  rootAccountPublicId?: string | undefined;
+  subaccountPublicId?: string | undefined;
+  smartAccountAddress?: string | undefined;
+}, {
+  rootAccountId: string | undefined;
+  subaccountId: string | undefined;
+  smartAccountAddress: string | undefined;
+}>]>;
+type ResolvedInternalTransferDestination = v.InferOutput<typeof ResolvedInternalTransferDestinationSchema>;
+declare function createCreateInternalTransferResultSchema(): v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly requestId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  readonly transferId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  readonly acceptedAtTsNs: v.BigintSchema<undefined>;
+  readonly assetId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>]>;
+  readonly assetCode: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  readonly uAssetId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  readonly amountE18: v.ObjectSchema<{
+    readonly hi: v.BigintSchema<undefined>;
+    readonly lo: v.BigintSchema<undefined>;
+  }, undefined>;
+  readonly destination: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly rootAccountPublicId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, string | undefined>]>;
+    readonly subaccountPublicId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, string | undefined>]>;
+    readonly smartAccountAddress: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, string | undefined>]>;
+  }, undefined>, v.TransformAction<{
+    rootAccountPublicId?: string | undefined;
+    subaccountPublicId?: string | undefined;
+    smartAccountAddress?: string | undefined;
+  }, {
+    rootAccountId: string | undefined;
+    subaccountId: string | undefined;
+    smartAccountAddress: string | undefined;
+  }>]>, undefined>;
+}, undefined>, v.TransformAction<{
+  requestId: string;
+  transferId: string;
+  acceptedAtTsNs: bigint;
+  assetId: number;
+  assetCode: string;
+  uAssetId: string;
+  amountE18: {
+    hi: bigint;
+    lo: bigint;
+  };
+  destination?: {
+    rootAccountId: string | undefined;
+    subaccountId: string | undefined;
+    smartAccountAddress: string | undefined;
+  } | undefined;
+}, {
+  acceptedAtUnixMs: number;
+  quantity: string;
+  requestId: string;
+  transferId: string;
+  assetId: number;
+  assetCode: string;
+  uAssetId: string;
+  destination?: {
+    rootAccountId: string | undefined;
+    subaccountId: string | undefined;
+    smartAccountAddress: string | undefined;
+  } | undefined;
+}>]>;
+type CreateInternalTransferResult = v.InferOutput<ReturnType<typeof createCreateInternalTransferResultSchema>>;
+//#endregion
+export { CreateInternalTransferInput, CreateInternalTransferResult, InternalTransferDestination, InternalTransferDestinationInputSchema, ResolvedInternalTransferDestination, ResolvedInternalTransferDestinationSchema, createCreateInternalTransferInputSchema, createCreateInternalTransferResultSchema };
+//# sourceMappingURL=internal-transfers.schemas.d.ts.map

package/dist/services/internal-transfers/internal-transfers.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-transfers.schemas.d.ts","names":[],"sources":["../../../src/services/internal-transfers/internal-transfers.schemas.ts"],"mappings":";;;;cAyBa,wCAAsC,EAAA,yBAAA,EAAA,uBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoCvC,8BAA8B,EAAE,kBACjC;iBAGK,wCAAwC,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAAA;;;;;;;;;;;;;;;KA0B7D,8BAA8B,EAAE,WACxC,kBAAkB;cAYT,2CAAyC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;KAa1C,sCAAsC,EAAE,mBACzC;iBAGK,4CAAwC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoB5C,+BAA+B,EAAE,YACzC,kBAAkB"}

package/dist/services/internal-transfers/internal-transfers.schemas.js

@@ -0,0 +1,90 @@
+import { tsNsToMs } from "../../utils/time.js";
+import { idInputSchema } from "../../shared/schemas.js";
+import { AccountScopeInputEntries, accountScopeToSubaccountId } from "../../shared/account-scope.js";
+import { quantityInputToE18, scaledToDecimalOutput } from "../../shared/decimal-surface.js";
+import { fromU128, toU128 } from "../../utils/u128.js";
+import { InternalTransferDestinationCodec } from "./internal-transfers.codecs.js";
+import * as v from "valibot";
+//#region src/services/internal-transfers/internal-transfers.schemas.ts
+const U128Schema = v.object({
+	hi: v.bigint(),
+	lo: v.bigint()
+});
+const IdSchema = idInputSchema;
+const InternalTransferDestinationInputSchema = v.pipe(v.variant("type", [
+	v.strictObject({
+		type: v.literal("account"),
+		accountId: IdSchema("accountId")
+	}),
+	v.strictObject({
+		type: v.literal("subaccount"),
+		subaccountId: IdSchema("subaccountId")
+	}),
+	v.strictObject({
+		type: v.literal("smartAccountAddress"),
+		address: v.pipe(v.string(), v.trim(), v.minLength(1))
+	})
+]), v.transform((destination) => {
+	switch (destination.type) {
+		case "account": return {
+			case: InternalTransferDestinationCodec.inputToProtoCase.account,
+			value: destination.accountId
+		};
+		case "subaccount": return {
+			case: InternalTransferDestinationCodec.inputToProtoCase.subaccount,
+			value: destination.subaccountId
+		};
+		case "smartAccountAddress": return {
+			case: InternalTransferDestinationCodec.inputToProtoCase.smartAccountAddress,
+			value: destination.address
+		};
+	}
+}));
+function createCreateInternalTransferInputSchema(scales) {
+	return v.pipe(v.strictObject({
+		...AccountScopeInputEntries,
+		destination: InternalTransferDestinationInputSchema,
+		assetId: v.pipe(v.number(), v.integer(), v.gtValue(0)),
+		quantity: v.string(),
+		idempotencyKey: v.pipe(v.string(), v.trim(), v.minLength(1))
+	}), v.transform(({ account, quantity, ...input }) => ({
+		...input,
+		amountE18: toU128(quantityInputToE18({
+			scales,
+			assetId: input.assetId,
+			quantity
+		})),
+		subaccountId: accountScopeToSubaccountId(account)
+	})));
+}
+const NonEmptyResponseStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
+const OptionalResponseStringSchema = v.pipe(v.optional(v.pipe(v.string(), v.trim())), v.transform((value) => value ? value : void 0));
+const ResolvedInternalTransferDestinationSchema = v.pipe(v.object({
+	rootAccountPublicId: OptionalResponseStringSchema,
+	subaccountPublicId: OptionalResponseStringSchema,
+	smartAccountAddress: OptionalResponseStringSchema
+}), v.transform(({ rootAccountPublicId, subaccountPublicId, smartAccountAddress }) => ({
+	rootAccountId: rootAccountPublicId,
+	subaccountId: subaccountPublicId,
+	smartAccountAddress
+})));
+function createCreateInternalTransferResultSchema() {
+	return v.pipe(v.object({
+		requestId: NonEmptyResponseStringSchema,
+		transferId: NonEmptyResponseStringSchema,
+		acceptedAtTsNs: v.bigint(),
+		assetId: v.pipe(v.number(), v.integer(), v.gtValue(0)),
+		assetCode: NonEmptyResponseStringSchema,
+		uAssetId: NonEmptyResponseStringSchema,
+		amountE18: U128Schema,
+		destination: v.optional(ResolvedInternalTransferDestinationSchema)
+	}), v.transform(({ acceptedAtTsNs, amountE18, ...result }) => ({
+		...result,
+		acceptedAtUnixMs: tsNsToMs(acceptedAtTsNs),
+		quantity: scaledToDecimalOutput(fromU128(amountE18), 18)
+	})));
+}
+//#endregion
+export { InternalTransferDestinationInputSchema, ResolvedInternalTransferDestinationSchema, createCreateInternalTransferInputSchema, createCreateInternalTransferResultSchema };
+
+//# sourceMappingURL=internal-transfers.schemas.js.map

package/dist/services/internal-transfers/internal-transfers.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-transfers.schemas.js","names":[],"sources":["../../../src/services/internal-transfers/internal-transfers.schemas.ts"],"sourcesContent":["import type { MessageInitShape } from \"@bufbuild/protobuf\";\nimport * as v from \"valibot\";\nimport type * as Proto from \"../../gen/transfer/v1/internal_transfer_pb.js\";\nimport { idInputSchema } from \"../../shared/schemas.js\";\nimport { tsNsToMs } from \"../../utils/time.js\";\nimport {\n    E18_SCALE,\n    quantityInputToE18,\n    scaledToDecimalOutput,\n    type SdkScales,\n} from \"../../shared/decimal-surface.js\";\nimport { InternalTransferDestinationCodec } from \"./internal-transfers.codecs.js\";\nimport {\n    AccountScopeInputEntries,\n    accountScopeToSubaccountId,\n} from \"../../shared/account-scope.js\";\nimport { fromU128, toU128 } from \"../../utils/u128.js\";\n\nconst U128Schema = v.object({\n    hi: v.bigint(),\n    lo: v.bigint(),\n});\n\nconst IdSchema = idInputSchema;\n\nexport const InternalTransferDestinationInputSchema = v.pipe(\n    v.variant(\"type\", [\n        v.strictObject({\n            type: v.literal(\"account\"),\n            accountId: IdSchema(\"accountId\"),\n        }),\n        v.strictObject({\n            type: v.literal(\"subaccount\"),\n            subaccountId: IdSchema(\"subaccountId\"),\n        }),\n        v.strictObject({\n            type: v.literal(\"smartAccountAddress\"),\n            address: v.pipe(v.string(), v.trim(), v.minLength(1)),\n        }),\n    ]),\n    v.transform((destination) => {\n        switch (destination.type) {\n            case \"account\":\n                return {\n                    case: InternalTransferDestinationCodec.inputToProtoCase.account,\n                    value: destination.accountId,\n                } as const;\n            case \"subaccount\":\n                return {\n                    case: InternalTransferDestinationCodec.inputToProtoCase.subaccount,\n                    value: destination.subaccountId,\n                } as const;\n            case \"smartAccountAddress\":\n                return {\n                    case: InternalTransferDestinationCodec.inputToProtoCase.smartAccountAddress,\n                    value: destination.address,\n                } as const;\n        }\n    }),\n);\n\nexport type InternalTransferDestination = v.InferInput<\n    typeof InternalTransferDestinationInputSchema\n>;\n\nexport function createCreateInternalTransferInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            destination: InternalTransferDestinationInputSchema,\n            assetId: v.pipe(v.number(), v.integer(), v.gtValue(0)),\n            quantity: v.string(),\n            idempotencyKey: v.pipe(v.string(), v.trim(), v.minLength(1)),\n        }),\n        v.transform(\n            ({ account, quantity, ...input }) =>\n                ({\n                    ...input,\n                    amountE18: toU128(\n                        quantityInputToE18({\n                            scales,\n                            assetId: input.assetId,\n                            quantity,\n                        }),\n                    ),\n                    subaccountId: accountScopeToSubaccountId(account),\n                }) satisfies MessageInitShape<typeof Proto.CreateInternalTransferRequestSchema>,\n        ),\n    );\n}\n\nexport type CreateInternalTransferInput = v.InferInput<\n    ReturnType<typeof createCreateInternalTransferInputSchema>\n>;\nexport type CreateInternalTransferRequest = v.InferOutput<\n    ReturnType<typeof createCreateInternalTransferInputSchema>\n>;\n\nconst NonEmptyResponseStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));\nconst OptionalResponseStringSchema = v.pipe(\n    v.optional(v.pipe(v.string(), v.trim())),\n    v.transform((value) => (value ? value : undefined)),\n);\n\nexport const ResolvedInternalTransferDestinationSchema = v.pipe(\n    v.object({\n        rootAccountPublicId: OptionalResponseStringSchema,\n        subaccountPublicId: OptionalResponseStringSchema,\n        smartAccountAddress: OptionalResponseStringSchema,\n    }),\n    v.transform(({ rootAccountPublicId, subaccountPublicId, smartAccountAddress }) => ({\n        rootAccountId: rootAccountPublicId,\n        subaccountId: subaccountPublicId,\n        smartAccountAddress,\n    })),\n);\n\nexport type ResolvedInternalTransferDestination = v.InferOutput<\n    typeof ResolvedInternalTransferDestinationSchema\n>;\n\nexport function createCreateInternalTransferResultSchema() {\n    return v.pipe(\n        v.object({\n            requestId: NonEmptyResponseStringSchema,\n            transferId: NonEmptyResponseStringSchema,\n            acceptedAtTsNs: v.bigint(),\n            assetId: v.pipe(v.number(), v.integer(), v.gtValue(0)),\n            assetCode: NonEmptyResponseStringSchema,\n            uAssetId: NonEmptyResponseStringSchema,\n            amountE18: U128Schema,\n            destination: v.optional(ResolvedInternalTransferDestinationSchema),\n        }),\n        v.transform(({ acceptedAtTsNs, amountE18, ...result }) => ({\n            ...result,\n            acceptedAtUnixMs: tsNsToMs(acceptedAtTsNs),\n            quantity: scaledToDecimalOutput(fromU128(amountE18), E18_SCALE),\n        })),\n    );\n}\n\nexport type CreateInternalTransferResult = v.InferOutput<\n    ReturnType<typeof createCreateInternalTransferResultSchema>\n>;\n"],"mappings":";;;;;;;;AAkBA,MAAM,aAAa,EAAE,OAAO;CACxB,IAAI,EAAE,OAAO;CACb,IAAI,EAAE,OAAO;AACjB,CAAC;AAED,MAAM,WAAW;AAEjB,MAAa,yCAAyC,EAAE,KACpD,EAAE,QAAQ,QAAQ;CACd,EAAE,aAAa;EACX,MAAM,EAAE,QAAQ,SAAS;EACzB,WAAW,SAAS,WAAW;CACnC,CAAC;CACD,EAAE,aAAa;EACX,MAAM,EAAE,QAAQ,YAAY;EAC5B,cAAc,SAAS,cAAc;CACzC,CAAC;CACD,EAAE,aAAa;EACX,MAAM,EAAE,QAAQ,qBAAqB;EACrC,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,KAAK,GAAG,EAAE,UAAU,CAAC,CAAC;CACxD,CAAC;AACL,CAAC,GACD,EAAE,WAAW,gBAAgB;CACzB,QAAQ,YAAY,MAApB;EACI,KAAK,WACD,OAAO;GACH,MAAM,iCAAiC,iBAAiB;GACxD,OAAO,YAAY;EACvB;EACJ,KAAK,cACD,OAAO;GACH,MAAM,iCAAiC,iBAAiB;GACxD,OAAO,YAAY;EACvB;EACJ,KAAK,uBACD,OAAO;GACH,MAAM,iCAAiC,iBAAiB;GACxD,OAAO,YAAY;EACvB;CACR;AACJ,CAAC,CACL;AAMA,SAAgB,wCAAwC,QAAmB;CACvE,OAAO,EAAE,KACL,EAAE,aAAa;EACX,GAAG;EACH,aAAa;EACb,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,QAAQ,CAAC,CAAC;EACrD,UAAU,EAAE,OAAO;EACnB,gBAAgB,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,KAAK,GAAG,EAAE,UAAU,CAAC,CAAC;CAC/D,CAAC,GACD,EAAE,WACG,EAAE,SAAS,UAAU,GAAG,aACpB;EACG,GAAG;EACH,WAAW,OACP,mBAAmB;GACf;GACA,SAAS,MAAM;GACf;EACJ,CAAC,CACL;EACA,cAAc,2BAA2B,OAAO;CACpD,EACR,CACJ;AACJ;AASA,MAAM,+BAA+B,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,KAAK,GAAG,EAAE,UAAU,CAAC,CAAC;AAChF,MAAM,+BAA+B,EAAE,KACnC,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,KAAK,CAAC,CAAC,GACvC,EAAE,WAAW,UAAW,QAAQ,QAAQ,KAAA,CAAU,CACtD;AAEA,MAAa,4CAA4C,EAAE,KACvD,EAAE,OAAO;CACL,qBAAqB;CACrB,oBAAoB;CACpB,qBAAqB;AACzB,CAAC,GACD,EAAE,WAAW,EAAE,qBAAqB,oBAAoB,2BAA2B;CAC/E,eAAe;CACf,cAAc;CACd;AACJ,EAAE,CACN;AAMA,SAAgB,2CAA2C;CACvD,OAAO,EAAE,KACL,EAAE,OAAO;EACL,WAAW;EACX,YAAY;EACZ,gBAAgB,EAAE,OAAO;EACzB,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,QAAQ,CAAC,CAAC;EACrD,WAAW;EACX,UAAU;EACV,WAAW;EACX,aAAa,EAAE,SAAS,yCAAyC;CACrE,CAAC,GACD,EAAE,WAAW,EAAE,gBAAgB,WAAW,GAAG,cAAc;EACvD,GAAG;EACH,kBAAkB,SAAS,cAAc;EACzC,UAAU,sBAAsB,SAAS,SAAS,GAAA,EAAY;CAClE,EAAE,CACN;AACJ"}

package/dist/services/internal-transfers/internal-transfers.types.d.ts

@@ -0,0 +1,2 @@
+import { CreateInternalTransferInput, CreateInternalTransferResult, InternalTransferDestination, ResolvedInternalTransferDestination } from "./internal-transfers.schemas.js";
+export type { CreateInternalTransferInput, CreateInternalTransferResult, InternalTransferDestination, ResolvedInternalTransferDestination };

package/dist/services/lifecycle/index.d.ts

@@ -0,0 +1,4 @@
+import { LIFECYCLE_LIST_ORDER_BY_VALUES, LIFECYCLE_LIST_SCOPE_VALUES, LIFECYCLE_REASON_VALUES, LIFECYCLE_REQUEST_FEE_STATUS_VALUES, LIFECYCLE_SORT_VALUES, LIFECYCLE_TX_LOOKUP_KIND_VALUES, LifecycleListOrderByValue, LifecycleListScopeValue, LifecycleReasonValue, LifecycleRequestFeeStatusValue, LifecycleSortValue, LifecycleTxLookupKindValue } from "./lifecycle.codecs.js";
+import { GetLifecycleFlowInput, GetLifecycleFlowInputSchema, GetLifecycleFlowOutput, GetLifecycleFlowOutputSchema, LifecycleAssetIds, LifecycleFlowDetail, LifecycleFlowDetailSchema, LifecycleFlowState, LifecycleFlowStep, LifecycleFlowStepActivity, LifecycleFlowStepActivitySchema, LifecycleFlowStepSchema, LifecycleFlowSummary, LifecycleFlowSummaryProgress, LifecycleFlowSummaryProgressSchema, LifecycleFlowSummarySchema, LifecycleFlowTimelineItem, LifecycleFlowTimelineItemSchema, LifecycleFlowTxMatch, LifecycleFlowTxMatchSchema, LifecycleListOrderBy, LifecycleListScope, LifecycleReason, LifecycleRequestFee, LifecycleRequestFeeSchema, LifecycleRequestFeeStatus, LifecycleSort, LifecycleTxLookupKind, LifecycleZipperReason, ListLifecycleFlowsByTxInput, ListLifecycleFlowsByTxInputSchema, ListLifecycleFlowsByTxOutput, ListLifecycleFlowsByTxOutputSchema, ListLifecycleFlowsInput, ListLifecycleFlowsInputSchema, ListLifecycleFlowsOutput, ListLifecycleFlowsOutputSchema } from "./lifecycle.schemas.js";
+import { LifecycleService } from "./lifecycle.js";
+export { GetLifecycleFlowInput, GetLifecycleFlowInputSchema, GetLifecycleFlowOutput, GetLifecycleFlowOutputSchema, LIFECYCLE_LIST_ORDER_BY_VALUES, LIFECYCLE_LIST_SCOPE_VALUES, LIFECYCLE_REASON_VALUES, LIFECYCLE_REQUEST_FEE_STATUS_VALUES, LIFECYCLE_SORT_VALUES, LIFECYCLE_TX_LOOKUP_KIND_VALUES, LifecycleAssetIds, LifecycleFlowDetail, LifecycleFlowDetailSchema, LifecycleFlowState, LifecycleFlowStep, LifecycleFlowStepActivity, LifecycleFlowStepActivitySchema, LifecycleFlowStepSchema, LifecycleFlowSummary, LifecycleFlowSummaryProgress, LifecycleFlowSummaryProgressSchema, LifecycleFlowSummarySchema, LifecycleFlowTimelineItem, LifecycleFlowTimelineItemSchema, LifecycleFlowTxMatch, LifecycleFlowTxMatchSchema, LifecycleListOrderBy, LifecycleListOrderByValue, LifecycleListScope, LifecycleListScopeValue, LifecycleReason, LifecycleReasonValue, LifecycleRequestFee, LifecycleRequestFeeSchema, LifecycleRequestFeeStatus, LifecycleRequestFeeStatusValue, LifecycleService, LifecycleSort, LifecycleSortValue, LifecycleTxLookupKind, LifecycleTxLookupKindValue, LifecycleZipperReason, ListLifecycleFlowsByTxInput, ListLifecycleFlowsByTxInputSchema, ListLifecycleFlowsByTxOutput, ListLifecycleFlowsByTxOutputSchema, ListLifecycleFlowsInput, ListLifecycleFlowsInputSchema, ListLifecycleFlowsOutput, ListLifecycleFlowsOutputSchema };

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

@@ -0,0 +1,23 @@
+import "../../gen/chain/lifecycle/v1/types_pb.js";
+import "../../gen/chain/lifecycle/v1/lifecycle_read_pb.js";
+//#region src/services/lifecycle/lifecycle.codecs.d.ts
+declare const LIFECYCLE_LIST_SCOPE_VALUES: readonly ["all", "open", "terminal"];
+type LifecycleListScopeValue = (typeof LIFECYCLE_LIST_SCOPE_VALUES)[number];
+declare const LIFECYCLE_TX_LOOKUP_KIND_VALUES: readonly ["source", "any"];
+type LifecycleTxLookupKindValue = (typeof LIFECYCLE_TX_LOOKUP_KIND_VALUES)[number];
+declare const LIFECYCLE_SORT_VALUES: readonly ["newest", "oldest"];
+type LifecycleSortValue = (typeof LIFECYCLE_SORT_VALUES)[number];
+declare const LIFECYCLE_LIST_ORDER_BY_VALUES: readonly ["last_activity", "started_at"];
+type LifecycleListOrderByValue = (typeof LIFECYCLE_LIST_ORDER_BY_VALUES)[number];
+declare const LIFECYCLE_REASON_VALUES: readonly ["unspecified", "zipper_validation_rejected", "zipper_execution_rejected", "zipper_withdraw_execution_failed", "zipper_deposit_refund_failed", "ledger_mirror_rejected", "ledger_mirror_transfer_exceeds_credits", "ledger_mirror_transfer_exists", "ledger_mirror_pending_transfer_not_found", "ledger_mirror_transfer_id_already_failed"];
+/**
+ * Catalog labels plus a code-preserving fallback for wire values the generated
+ * enum does not know. Proto3 enums are open — the backend can emit codes ahead
+ * of a contract update — and rejecting them froze flows out of the UI.
+ */
+type LifecycleReasonValue = (typeof LIFECYCLE_REASON_VALUES)[number] | `unknown_reason_${number}`;
+declare const LIFECYCLE_REQUEST_FEE_STATUS_VALUES: readonly ["locked", "settled"];
+type LifecycleRequestFeeStatusValue = (typeof LIFECYCLE_REQUEST_FEE_STATUS_VALUES)[number];
+//#endregion
+export { LIFECYCLE_LIST_ORDER_BY_VALUES, LIFECYCLE_LIST_SCOPE_VALUES, LIFECYCLE_REASON_VALUES, LIFECYCLE_REQUEST_FEE_STATUS_VALUES, LIFECYCLE_SORT_VALUES, LIFECYCLE_TX_LOOKUP_KIND_VALUES, LifecycleListOrderByValue, LifecycleListScopeValue, LifecycleReasonValue, LifecycleRequestFeeStatusValue, LifecycleSortValue, LifecycleTxLookupKindValue };
+//# sourceMappingURL=lifecycle.codecs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.codecs.d.ts","names":[],"sources":["../../../src/services/lifecycle/lifecycle.codecs.ts"],"mappings":";;;cAiCa;KACD,kCAAkC;cAEjC;KACD,qCAAqC;cAEpC;KACD,6BAA6B;cAE5B;KACD,oCAAoC;cAEnC;;;;;;KAiBD,+BACE;cAwCD;KACD,yCAAyC"}

package/dist/services/lifecycle/lifecycle.codecs.js

@@ -0,0 +1,171 @@
+import "../../gen/chain/lifecycle/v1/types_pb.js";
+import "../../gen/chain/lifecycle/v1/lifecycle_read_pb.js";
+//#region src/services/lifecycle/lifecycle.codecs.ts
+const LIFECYCLE_FLOW_KIND_VALUES = [
+	"deposit",
+	"withdraw",
+	"transfer"
+];
+const LIFECYCLE_FLOW_STATE_VALUES = [
+	"pending_source",
+	"pending_polyester_chain",
+	"pending_ledger",
+	"completed",
+	"failed",
+	"dropped",
+	"refunded"
+];
+const LIFECYCLE_LIST_SCOPE_VALUES = [
+	"all",
+	"open",
+	"terminal"
+];
+const LIFECYCLE_TX_LOOKUP_KIND_VALUES = ["source", "any"];
+const LIFECYCLE_SORT_VALUES = ["newest", "oldest"];
+const LIFECYCLE_LIST_ORDER_BY_VALUES = ["last_activity", "started_at"];
+const LifecycleFlowDomainCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "external_chain",
+	[2]: "zipper",
+	[3]: "funding",
+	[4]: "trading",
+	[5]: "lending"
+} };
+const LifecycleFlowKindCodec = {
+	inputToProto: {
+		deposit: 1,
+		withdraw: 2,
+		transfer: 3
+	},
+	protoToOutput: {
+		[0]: "unspecified",
+		[1]: "deposit",
+		[2]: "withdraw",
+		[3]: "transfer"
+	}
+};
+const LifecycleFlowStateCodec = {
+	inputToProto: {
+		pending_source: 1,
+		pending_polyester_chain: 2,
+		pending_ledger: 3,
+		completed: 4,
+		failed: 5,
+		dropped: 6,
+		refunded: 7
+	},
+	protoToOutput: {
+		[0]: "unspecified",
+		[1]: "pending_source",
+		[2]: "pending_polyester_chain",
+		[3]: "pending_ledger",
+		[4]: "completed",
+		[5]: "failed",
+		[6]: "dropped",
+		[7]: "refunded"
+	}
+};
+const LifecycleListScopeCodec = {
+	inputToProto: {
+		all: 1,
+		open: 2,
+		terminal: 3
+	},
+	protoToOutput: {
+		[0]: "unspecified",
+		[1]: "all",
+		[2]: "open",
+		[3]: "terminal"
+	}
+};
+const LifecycleSortCodec = { inputToProto: {
+	newest: 1,
+	oldest: 2
+} };
+const LifecycleListOrderByCodec = { inputToProto: {
+	last_activity: 1,
+	started_at: 2
+} };
+/**
+* LifecycleReason is a stable product-facing reason catalog. Unlike the other
+* lifecycle enums, `REASON_UNSPECIFIED` (0) is a valid wire value — it is
+* the normal state for flows without a notable reason — so the codec maps the
+* full enum including zero.
+*/
+const LifecycleReasonCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[101]: "zipper_validation_rejected",
+	[102]: "zipper_execution_rejected",
+	[103]: "zipper_withdraw_execution_failed",
+	[104]: "zipper_deposit_refund_failed",
+	[200]: "ledger_mirror_rejected",
+	[201]: "ledger_mirror_transfer_exceeds_credits",
+	[202]: "ledger_mirror_transfer_exists",
+	[203]: "ledger_mirror_pending_transfer_not_found",
+	[204]: "ledger_mirror_transfer_id_already_failed"
+} };
+/**
+* Maps a wire reason code to its catalog label, preserving uncataloged codes
+* as `unknown_reason_${code}` instead of failing the whole flow payload.
+*/
+function lifecycleReasonFromCode(code) {
+	return LifecycleReasonCodec.protoToOutput[code] ?? `unknown_reason_${code}`;
+}
+const LifecycleTxLookupKindCodec = {
+	inputToProto: {
+		source: 1,
+		any: 2
+	},
+	protoToOutput: {
+		[0]: "unspecified",
+		[1]: "source",
+		[2]: "any"
+	}
+};
+const LifecycleFlowStepCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "source",
+	[2]: "transfer",
+	[3]: "request",
+	[4]: "validation",
+	[5]: "execution",
+	[6]: "bridge_fulfillment",
+	[7]: "dropped",
+	[8]: "failed",
+	[9]: "refunded",
+	[10]: "fulfilling",
+	[11]: "settlement"
+} };
+const LifecycleSourceCodec = { 
+/**
+* In-progress flows may emit SOURCE_UNSPECIFIED (0) before a subsystem is
+* attributed, so zero must decode like other lifecycle "unspecified" enums.
+*/
+protoToOutput: {
+	[0]: "unspecified",
+	[1]: "relayer",
+	[2]: "polyester_chain",
+	[3]: "executor",
+	[4]: "ledger"
+} };
+const LifecycleFlowStepActivityKindCodec = { protoToOutput: {
+	[1]: "minted",
+	[2]: "funding",
+	[3]: "trading",
+	[0]: "unspecified"
+} };
+const LifecycleFlowTimelineStatusCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "completed",
+	[2]: "current",
+	[3]: "planned"
+} };
+const LifecycleRequestFeeStatusCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "locked",
+	[2]: "settled"
+} };
+//#endregion
+export { LIFECYCLE_FLOW_KIND_VALUES, LIFECYCLE_FLOW_STATE_VALUES, LIFECYCLE_LIST_ORDER_BY_VALUES, LIFECYCLE_LIST_SCOPE_VALUES, LIFECYCLE_SORT_VALUES, LIFECYCLE_TX_LOOKUP_KIND_VALUES, LifecycleFlowDomainCodec, LifecycleFlowKindCodec, LifecycleFlowStateCodec, LifecycleFlowStepActivityKindCodec, LifecycleFlowStepCodec, LifecycleFlowTimelineStatusCodec, LifecycleListOrderByCodec, LifecycleListScopeCodec, LifecycleReasonCodec, LifecycleRequestFeeStatusCodec, LifecycleSortCodec, LifecycleSourceCodec, LifecycleTxLookupKindCodec, lifecycleReasonFromCode };
+
+//# sourceMappingURL=lifecycle.codecs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.codecs.js","names":[],"sources":["../../../src/services/lifecycle/lifecycle.codecs.ts"],"sourcesContent":["import {\n    FlowDomain,\n    FlowKind,\n    FlowState,\n    LifecycleReason,\n    LifecycleSource,\n    RequestFeeStatus,\n} from \"../../gen/chain/lifecycle/v1/types_pb.js\";\nimport {\n    FlowStep,\n    FlowStepActivityKind,\n    FlowTimelineStatus,\n    ListOrderBy,\n    ListScope,\n    Sort,\n    TxLookupKind,\n} from \"../../gen/chain/lifecycle/v1/lifecycle_read_pb.js\";\nimport type { InputToProto, ProtoToOutput } from \"../../utils/types.js\";\n\nexport const LIFECYCLE_FLOW_KIND_VALUES = [\"deposit\", \"withdraw\", \"transfer\"] as const;\nexport type LifecycleFlowKindValue = (typeof LIFECYCLE_FLOW_KIND_VALUES)[number];\n\nexport const LIFECYCLE_FLOW_STATE_VALUES = [\n    \"pending_source\",\n    \"pending_polyester_chain\",\n    \"pending_ledger\",\n    \"completed\",\n    \"failed\",\n    \"dropped\",\n    \"refunded\",\n] as const;\nexport type LifecycleFlowStateValue = (typeof LIFECYCLE_FLOW_STATE_VALUES)[number];\n\nexport const LIFECYCLE_LIST_SCOPE_VALUES = [\"all\", \"open\", \"terminal\"] as const;\nexport type LifecycleListScopeValue = (typeof LIFECYCLE_LIST_SCOPE_VALUES)[number];\n\nexport const LIFECYCLE_TX_LOOKUP_KIND_VALUES = [\"source\", \"any\"] as const;\nexport type LifecycleTxLookupKindValue = (typeof LIFECYCLE_TX_LOOKUP_KIND_VALUES)[number];\n\nexport const LIFECYCLE_SORT_VALUES = [\"newest\", \"oldest\"] as const;\nexport type LifecycleSortValue = (typeof LIFECYCLE_SORT_VALUES)[number];\n\nexport const LIFECYCLE_LIST_ORDER_BY_VALUES = [\"last_activity\", \"started_at\"] as const;\nexport type LifecycleListOrderByValue = (typeof LIFECYCLE_LIST_ORDER_BY_VALUES)[number];\n\nexport const LIFECYCLE_REASON_VALUES = [\n    \"unspecified\",\n    \"zipper_validation_rejected\",\n    \"zipper_execution_rejected\",\n    \"zipper_withdraw_execution_failed\",\n    \"zipper_deposit_refund_failed\",\n    \"ledger_mirror_rejected\",\n    \"ledger_mirror_transfer_exceeds_credits\",\n    \"ledger_mirror_transfer_exists\",\n    \"ledger_mirror_pending_transfer_not_found\",\n    \"ledger_mirror_transfer_id_already_failed\",\n] as const;\n/**\n * Catalog labels plus a code-preserving fallback for wire values the generated\n * enum does not know. Proto3 enums are open — the backend can emit codes ahead\n * of a contract update — and rejecting them froze flows out of the UI.\n */\nexport type LifecycleReasonValue =\n    | (typeof LIFECYCLE_REASON_VALUES)[number]\n    | `unknown_reason_${number}`;\n\nexport const LIFECYCLE_FLOW_STEP_VALUES = [\n    \"source\",\n    \"transfer\",\n    \"request\",\n    \"validation\",\n    \"execution\",\n    \"bridge_fulfillment\",\n    \"dropped\",\n    \"failed\",\n    \"refunded\",\n    \"fulfilling\",\n    \"settlement\",\n] as const;\nexport type LifecycleFlowStepValue = (typeof LIFECYCLE_FLOW_STEP_VALUES)[number];\n\nexport const LIFECYCLE_SOURCE_VALUES = [\n    \"unspecified\",\n    \"relayer\",\n    \"polyester_chain\",\n    \"executor\",\n    \"ledger\",\n] as const;\nexport type LifecycleSourceValue = (typeof LIFECYCLE_SOURCE_VALUES)[number];\n\nexport const LIFECYCLE_FLOW_STEP_ACTIVITY_KIND_VALUES = [\n    \"minted\",\n    \"funding\",\n    \"trading\",\n    \"unspecified\",\n] as const;\nexport type LifecycleFlowStepActivityKindValue =\n    (typeof LIFECYCLE_FLOW_STEP_ACTIVITY_KIND_VALUES)[number];\n\nexport const LIFECYCLE_FLOW_TIMELINE_STATUS_VALUES = [\"completed\", \"current\", \"planned\"] as const;\nexport type LifecycleFlowTimelineStatusValue =\n    (typeof LIFECYCLE_FLOW_TIMELINE_STATUS_VALUES)[number];\n\nexport const LIFECYCLE_REQUEST_FEE_STATUS_VALUES = [\"locked\", \"settled\"] as const;\nexport type LifecycleRequestFeeStatusValue = (typeof LIFECYCLE_REQUEST_FEE_STATUS_VALUES)[number];\n\nexport const LIFECYCLE_FLOW_DOMAIN_VALUES = [\n    \"external_chain\",\n    \"zipper\",\n    \"funding\",\n    \"trading\",\n    \"lending\",\n] as const;\nexport type LifecycleFlowDomainValue = (typeof LIFECYCLE_FLOW_DOMAIN_VALUES)[number];\n\nexport const LifecycleFlowDomainCodec = {\n    protoToOutput: {\n        [FlowDomain.DOMAIN_UNSPECIFIED]: \"unspecified\",\n        [FlowDomain.DOMAIN_EXTERNAL_CHAIN]: \"external_chain\",\n        [FlowDomain.DOMAIN_ZIPPER]: \"zipper\",\n        [FlowDomain.DOMAIN_FUNDING]: \"funding\",\n        [FlowDomain.DOMAIN_TRADING]: \"trading\",\n        [FlowDomain.DOMAIN_LENDING]: \"lending\",\n    } satisfies ProtoToOutput<FlowDomain, LifecycleFlowDomainValue>,\n} as const;\n\nexport const LifecycleFlowKindCodec = {\n    inputToProto: {\n        deposit: FlowKind.KIND_DEPOSIT,\n        withdraw: FlowKind.KIND_WITHDRAW,\n        transfer: FlowKind.KIND_TRANSFER,\n    } satisfies InputToProto<LifecycleFlowKindValue, FlowKind>,\n    protoToOutput: {\n        [FlowKind.KIND_UNSPECIFIED]: \"unspecified\",\n        [FlowKind.KIND_DEPOSIT]: \"deposit\",\n        [FlowKind.KIND_WITHDRAW]: \"withdraw\",\n        [FlowKind.KIND_TRANSFER]: \"transfer\",\n    } satisfies ProtoToOutput<FlowKind, LifecycleFlowKindValue>,\n} as const;\n\nexport const LifecycleFlowStateCodec = {\n    inputToProto: {\n        pending_source: FlowState.STATE_PENDING_SOURCE,\n        pending_polyester_chain: FlowState.STATE_PENDING_POLYESTER_CHAIN,\n        pending_ledger: FlowState.STATE_PENDING_LEDGER,\n        completed: FlowState.STATE_COMPLETED,\n        failed: FlowState.STATE_FAILED,\n        dropped: FlowState.STATE_DROPPED,\n        refunded: FlowState.STATE_REFUNDED,\n    } satisfies InputToProto<LifecycleFlowStateValue, FlowState>,\n    protoToOutput: {\n        [FlowState.STATE_UNSPECIFIED]: \"unspecified\",\n        [FlowState.STATE_PENDING_SOURCE]: \"pending_source\",\n        [FlowState.STATE_PENDING_POLYESTER_CHAIN]: \"pending_polyester_chain\",\n        [FlowState.STATE_PENDING_LEDGER]: \"pending_ledger\",\n        [FlowState.STATE_COMPLETED]: \"completed\",\n        [FlowState.STATE_FAILED]: \"failed\",\n        [FlowState.STATE_DROPPED]: \"dropped\",\n        [FlowState.STATE_REFUNDED]: \"refunded\",\n    } satisfies ProtoToOutput<FlowState, LifecycleFlowStateValue>,\n} as const;\n\nexport const LifecycleListScopeCodec = {\n    inputToProto: {\n        all: ListScope.LIST_ALL,\n        open: ListScope.LIST_OPEN_ONLY,\n        terminal: ListScope.LIST_TERMINAL_ONLY,\n    } satisfies InputToProto<LifecycleListScopeValue, ListScope>,\n    protoToOutput: {\n        [ListScope.LIST_UNSPECIFIED]: \"unspecified\",\n        [ListScope.LIST_ALL]: \"all\",\n        [ListScope.LIST_OPEN_ONLY]: \"open\",\n        [ListScope.LIST_TERMINAL_ONLY]: \"terminal\",\n    } satisfies ProtoToOutput<ListScope, LifecycleListScopeValue>,\n} as const;\n\nexport const LifecycleSortCodec = {\n    inputToProto: {\n        newest: Sort.NEWEST,\n        oldest: Sort.OLDEST,\n    } satisfies InputToProto<LifecycleSortValue, Sort>,\n} as const;\n\nexport const LifecycleListOrderByCodec = {\n    inputToProto: {\n        last_activity: ListOrderBy.ORDER_BY_LAST_ACTIVITY,\n        started_at: ListOrderBy.ORDER_BY_STARTED_AT,\n    } satisfies InputToProto<LifecycleListOrderByValue, ListOrderBy>,\n} as const;\n\n/**\n * LifecycleReason is a stable product-facing reason catalog. Unlike the other\n * lifecycle enums, `REASON_UNSPECIFIED` (0) is a valid wire value — it is\n * the normal state for flows without a notable reason — so the codec maps the\n * full enum including zero.\n */\nexport const LifecycleReasonCodec = {\n    protoToOutput: {\n        [LifecycleReason.REASON_UNSPECIFIED]: \"unspecified\",\n        [LifecycleReason.ZIPPER_VALIDATION_REJECTED]: \"zipper_validation_rejected\",\n        [LifecycleReason.ZIPPER_EXECUTION_REJECTED]: \"zipper_execution_rejected\",\n        [LifecycleReason.ZIPPER_WITHDRAW_EXECUTION_FAILED]: \"zipper_withdraw_execution_failed\",\n        [LifecycleReason.ZIPPER_DEPOSIT_REFUND_FAILED]: \"zipper_deposit_refund_failed\",\n        [LifecycleReason.LEDGER_MIRROR_REJECTED]: \"ledger_mirror_rejected\",\n        [LifecycleReason.LEDGER_MIRROR_TRANSFER_EXCEEDS_CREDITS]:\n            \"ledger_mirror_transfer_exceeds_credits\",\n        [LifecycleReason.LEDGER_MIRROR_TRANSFER_EXISTS]: \"ledger_mirror_transfer_exists\",\n        [LifecycleReason.LEDGER_MIRROR_PENDING_TRANSFER_NOT_FOUND]:\n            \"ledger_mirror_pending_transfer_not_found\",\n        [LifecycleReason.LEDGER_MIRROR_TRANSFER_ID_ALREADY_FAILED]:\n            \"ledger_mirror_transfer_id_already_failed\",\n    } satisfies Record<LifecycleReason, LifecycleReasonValue>,\n} as const;\n\n/**\n * Maps a wire reason code to its catalog label, preserving uncataloged codes\n * as `unknown_reason_${code}` instead of failing the whole flow payload.\n */\nexport function lifecycleReasonFromCode(code: number): LifecycleReasonValue {\n    const known = LifecycleReasonCodec.protoToOutput as Partial<\n        Record<number, LifecycleReasonValue>\n    >;\n    return known[code] ?? `unknown_reason_${code}`;\n}\n\nexport const LifecycleTxLookupKindCodec = {\n    inputToProto: {\n        source: TxLookupKind.TX_SOURCE,\n        any: TxLookupKind.TX_ANY,\n    } satisfies InputToProto<LifecycleTxLookupKindValue, TxLookupKind>,\n    protoToOutput: {\n        [TxLookupKind.TX_UNSPECIFIED]: \"unspecified\",\n        [TxLookupKind.TX_SOURCE]: \"source\",\n        [TxLookupKind.TX_ANY]: \"any\",\n    } satisfies ProtoToOutput<TxLookupKind, LifecycleTxLookupKindValue>,\n} as const;\n\nexport const LifecycleFlowStepCodec = {\n    protoToOutput: {\n        [FlowStep.UNSPECIFIED]: \"unspecified\",\n        [FlowStep.SOURCE]: \"source\",\n        [FlowStep.TRANSFER]: \"transfer\",\n        [FlowStep.REQUEST]: \"request\",\n        [FlowStep.VALIDATION]: \"validation\",\n        [FlowStep.EXECUTION]: \"execution\",\n        [FlowStep.BRIDGE_FULFILLMENT]: \"bridge_fulfillment\",\n        [FlowStep.DROPPED]: \"dropped\",\n        [FlowStep.FAILED]: \"failed\",\n        [FlowStep.REFUNDED]: \"refunded\",\n        [FlowStep.FULFILLING]: \"fulfilling\",\n        [FlowStep.SETTLEMENT]: \"settlement\",\n    } satisfies ProtoToOutput<FlowStep, LifecycleFlowStepValue>,\n} as const;\n\nexport const LifecycleSourceCodec = {\n    /**\n     * In-progress flows may emit SOURCE_UNSPECIFIED (0) before a subsystem is\n     * attributed, so zero must decode like other lifecycle \"unspecified\" enums.\n     */\n    protoToOutput: {\n        [LifecycleSource.SOURCE_UNSPECIFIED]: \"unspecified\",\n        [LifecycleSource.SOURCE_RELAYER]: \"relayer\",\n        [LifecycleSource.SOURCE_POLYESTER_CHAIN]: \"polyester_chain\",\n        [LifecycleSource.SOURCE_EXECUTOR]: \"executor\",\n        [LifecycleSource.SOURCE_LEDGER]: \"ledger\",\n    } satisfies Record<LifecycleSource, LifecycleSourceValue>,\n} as const;\n\nexport const LifecycleFlowStepActivityKindCodec = {\n    protoToOutput: {\n        [FlowStepActivityKind.ACTIVITY_MINTED]: \"minted\",\n        [FlowStepActivityKind.ACTIVITY_FUNDING]: \"funding\",\n        [FlowStepActivityKind.ACTIVITY_TRADING]: \"trading\",\n        [FlowStepActivityKind.ACTIVITY_UNSPECIFIED]: \"unspecified\",\n    } satisfies Record<FlowStepActivityKind, LifecycleFlowStepActivityKindValue>,\n} as const;\n\nexport const LifecycleFlowTimelineStatusCodec = {\n    protoToOutput: {\n        [FlowTimelineStatus.TIMELINE_STATUS_UNSPECIFIED]: \"unspecified\",\n        [FlowTimelineStatus.TIMELINE_STATUS_COMPLETED]: \"completed\",\n        [FlowTimelineStatus.TIMELINE_STATUS_CURRENT]: \"current\",\n        [FlowTimelineStatus.TIMELINE_STATUS_PLANNED]: \"planned\",\n    } satisfies ProtoToOutput<FlowTimelineStatus, LifecycleFlowTimelineStatusValue>,\n} as const;\n\nexport const LifecycleRequestFeeStatusCodec = {\n    protoToOutput: {\n        [RequestFeeStatus.UNSPECIFIED]: \"unspecified\",\n        [RequestFeeStatus.LOCKED]: \"locked\",\n        [RequestFeeStatus.SETTLED]: \"settled\",\n    } satisfies ProtoToOutput<RequestFeeStatus, LifecycleRequestFeeStatusValue>,\n} as const;\n"],"mappings":";;;AAmBA,MAAa,6BAA6B;CAAC;CAAW;CAAY;AAAU;AAG5E,MAAa,8BAA8B;CACvC;CACA;CACA;CACA;CACA;CACA;CACA;AACJ;AAGA,MAAa,8BAA8B;CAAC;CAAO;CAAQ;AAAU;AAGrE,MAAa,kCAAkC,CAAC,UAAU,KAAK;AAG/D,MAAa,wBAAwB,CAAC,UAAU,QAAQ;AAGxD,MAAa,iCAAiC,CAAC,iBAAiB,YAAY;AAyE5E,MAAa,2BAA2B,EACpC,eAAe;EACsB,IAAA;EACG,IAAA;EACR,IAAA;EACC,IAAA;EACA,IAAA;EACA,IAAA;AACjC,EACJ;AAEA,MAAa,yBAAyB;CAClC,cAAc;EACV,SAAA;EACA,UAAA;EACA,UAAA;CACJ;CACA,eAAe;GACkB,IAAA;GACJ,IAAA;GACC,IAAA;GACA,IAAA;CAC9B;AACJ;AAEA,MAAa,0BAA0B;CACnC,cAAc;EACV,gBAAA;EACA,yBAAA;EACA,gBAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,UAAA;CACJ;CACA,eAAe;GACoB,IAAA;GACG,IAAA;GACS,IAAA;GACT,IAAA;GACL,IAAA;GACH,IAAA;GACC,IAAA;GACC,IAAA;CAChC;AACJ;AAEA,MAAa,0BAA0B;CACnC,cAAc;EACV,KAAA;EACA,MAAA;EACA,UAAA;CACJ;CACA,eAAe;GACmB,IAAA;GACR,IAAA;GACM,IAAA;GACI,IAAA;CACpC;AACJ;AAEA,MAAa,qBAAqB,EAC9B,cAAc;CACV,QAAA;CACA,QAAA;AACJ,EACJ;AAEA,MAAa,4BAA4B,EACrC,cAAc;CACV,eAAA;CACA,YAAA;AACJ,EACJ;;;;;;;AAQA,MAAa,uBAAuB,EAChC,eAAe;EAC2B,IAAA;EACQ,MAAA;EACD,MAAA;EACO,MAAA;EACJ,MAAA;EACN,MAAA;EAEtC,MAAA;EAC6C,MAAA;EAE7C,MAAA;EAEA,MAAA;AACR,EACJ;;;;;AAMA,SAAgB,wBAAwB,MAAoC;CAIxE,OAHc,qBAAqB,cAGtB,SAAS,kBAAkB;AAC5C;AAEA,MAAa,6BAA6B;CACtC,cAAc;EACV,QAAA;EACA,KAAA;CACJ;CACA,eAAe;GACoB,IAAA;GACL,IAAA;GACH,IAAA;CAC3B;AACJ;AAEA,MAAa,yBAAyB,EAClC,eAAe;EACa,IAAA;EACL,IAAA;EACE,IAAA;EACD,IAAA;EACG,IAAA;EACD,IAAA;EACS,IAAA;EACX,IAAA;EACD,IAAA;EACE,IAAA;EACE,KAAA;EACA,KAAA;AAC3B,EACJ;AAEA,MAAa,uBAAuB;;;;;AAKhC,eAAe;EAC2B,IAAA;EACJ,IAAA;EACQ,IAAA;EACP,IAAA;EACF,IAAA;AACrC,EACJ;AAEA,MAAa,qCAAqC,EAC9C,eAAe;EAC6B,IAAA;EACC,IAAA;EACA,IAAA;EACI,IAAA;AACjD,EACJ;AAEA,MAAa,mCAAmC,EAC5C,eAAe;EACuC,IAAA;EACF,IAAA;EACF,IAAA;EACA,IAAA;AAClD,EACJ;AAEA,MAAa,iCAAiC,EAC1C,eAAe;EACqB,IAAA;EACL,IAAA;EACC,IAAA;AAChC,EACJ"}