@paimaexample/wallets 0.3.117

package/esm/config/src/schema/sync-protocols/all.js

@@ -0,0 +1,55 @@
+import { Type, } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "./types.js";
+import { CommonResponseEvmRpcParallel, ConfigSyncProtocolSchemaEvmParallel, } from "./evm/rpc.js";
+import { CommonResponseCardanoCarpParallel, ConfigSyncProtocolSchemaCardanoCarpParallel, } from "./cardano/carp.js";
+import { CommonResponseCardanoUtxoRpcParallel, ConfigSyncProtocolSchemaCardanoUtxoRpcParallel, } from "./cardano/utxorpc.js";
+import { CommonResponseMinaDbParallel, ConfigSyncProtocolSchemaMinaParallel, } from "./mina/graphql.js";
+import { CommonResponseAvailRpcParallel, ConfigSyncProtocolSchemaAvailParallel, } from "./avail/rpc.js";
+import { CommonResponseMidnightGraphqlParallel, ConfigSyncProtocolSchemaMidnightParallel, } from "./midnight/graphql.js";
+import { CommonResponseBitcoinRpcParallel, ConfigSyncProtocolSchemaBitcoinParallel, } from "./bitcoin/rpc.js";
+import { ConfigSyncProtocolDecorator } from "./decorators/all.js";
+import { CommonResponseNtpMain, ConfigSyncProtocolSchemaNtpMain, } from "./ntp/rpc.js";
+export const mainSyncProtocolTypes = {
+    [ConfigSyncProtocolType.NTP_MAIN]: ConfigSyncProtocolSchemaNtpMain,
+};
+export const parallelSyncProtocolTypes = {
+    [ConfigSyncProtocolType.EVM_RPC_PARALLEL]: ConfigSyncProtocolSchemaEvmParallel,
+    [ConfigSyncProtocolType.CARDANO_CARP_PARALLEL]: ConfigSyncProtocolSchemaCardanoCarpParallel,
+    [ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL]: ConfigSyncProtocolSchemaCardanoUtxoRpcParallel,
+    [ConfigSyncProtocolType.MINA_PARALLEL]: ConfigSyncProtocolSchemaMinaParallel,
+    [ConfigSyncProtocolType.AVAIL_PARALLEL]: ConfigSyncProtocolSchemaAvailParallel,
+    [ConfigSyncProtocolType.MIDNIGHT_PARALLEL]: ConfigSyncProtocolSchemaMidnightParallel,
+    [ConfigSyncProtocolType.BITCOIN_RPC_PARALLEL]: ConfigSyncProtocolSchemaBitcoinParallel,
+};
+export const syncProtocolCommonResponse = {
+    [ConfigSyncProtocolType.NTP_MAIN]: CommonResponseNtpMain,
+    [ConfigSyncProtocolType.EVM_RPC_PARALLEL]: CommonResponseEvmRpcParallel,
+    [ConfigSyncProtocolType.CARDANO_CARP_PARALLEL]: CommonResponseCardanoCarpParallel,
+    [ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL]: CommonResponseCardanoUtxoRpcParallel,
+    [ConfigSyncProtocolType.MINA_PARALLEL]: CommonResponseMinaDbParallel,
+    [ConfigSyncProtocolType.AVAIL_PARALLEL]: CommonResponseAvailRpcParallel,
+    [ConfigSyncProtocolType.MIDNIGHT_PARALLEL]: CommonResponseMidnightGraphqlParallel,
+    [ConfigSyncProtocolType.BITCOIN_RPC_PARALLEL]: CommonResponseBitcoinRpcParallel,
+};
+function genConfigSyncProtocolCommon(type, base) {
+    return Type.Intersect([
+        base,
+        Type.Object({ name: Type.String(), type: Type.Literal(type) }),
+    ]);
+}
+export const ConfigSyncProtocolCommonResponseAll = Object.entries(syncProtocolCommonResponse).map(([key, schema]) => genConfigSyncProtocolCommon(key, schema));
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const ConfigSyncProtocolMain = (requireOptional) => Type.Union(Object.values(mainSyncProtocolTypes).map((schema) => schema.allProperties(requireOptional)));
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const ConfigSyncProtocolParallel = (requireOptional) => Type.Union(Object.values(parallelSyncProtocolTypes).map((schema) => schema.allProperties(requireOptional)));
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const ConfigSyncProtocolAll = (requireOptional) => Type.Union([
+    ConfigSyncProtocolMain(requireOptional),
+    ConfigSyncProtocolParallel(requireOptional),
+    ConfigSyncProtocolDecorator(requireOptional),
+]);
+export function getMainchainInfo(payload) {
+    return "mainchain" in payload.payload
+        ? payload.payload.mainchain
+        : payload.payload.ownChain;
+}

package/esm/config/src/schema/sync-protocols/avail/rpc.d.ts

@@ -0,0 +1,76 @@
+import type { Static } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "../types.js";
+import { type IntervalMs, type MergeIntersects } from "../../../../../utils/src/mod.js";
+export declare const ConfigSyncProtocolSchemaAvailBase: import("../../utils.js").ConfigSchema<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+} & {
+    pollingInterval: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+} & {
+    startBlockHeight: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>;
+} & {
+    name: import("@sinclair/typebox").TString;
+    rpc: import("@sinclair/typebox").TString;
+    lightClient: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    stopBlockHeight: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>, import("@sinclair/typebox").TNull]>;
+} & {
+    blockGroupSize: import("@sinclair/typebox").TNumber;
+    stepSize: import("@sinclair/typebox").TNumber;
+}>>;
+export declare const CommonResponseAvailRpcBase: {
+    readonly internal: {
+        readonly transactionHash: import("@sinclair/typebox").TString;
+    };
+    readonly payload: {
+        readonly primitiveName: import("@sinclair/typebox").TString;
+        readonly caip2: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").Caip2>;
+        readonly ownChain: import("@sinclair/typebox").TObject<{
+            blockNumber: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>;
+        }>;
+        /**
+         * Recall: in Substrate, tx hashes are not unique
+         *         rather, you have to use blockNumber + extrinsicIndex
+         */
+        readonly extrinsicIndex: import("@sinclair/typebox").TNumber;
+    };
+};
+export declare const ConfigSyncProtocolSchemaAvailParallel: import("../../utils.js").ConfigSchema<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+} & {
+    pollingInterval: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+} & {
+    startBlockHeight: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>;
+} & {
+    name: import("@sinclair/typebox").TString;
+    rpc: import("@sinclair/typebox").TString;
+    lightClient: import("@sinclair/typebox").TString;
+} & {
+    type: import("@sinclair/typebox").TLiteral<ConfigSyncProtocolType.AVAIL_PARALLEL>;
+}>, import("@sinclair/typebox").TObject<{
+    stopBlockHeight: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>, import("@sinclair/typebox").TNull]>;
+} & {
+    blockGroupSize: import("@sinclair/typebox").TNumber;
+    stepSize: import("@sinclair/typebox").TNumber;
+} & {
+    confirmationDepth: import("@sinclair/typebox").TNumber;
+    delayMs: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+}>>;
+export type ConfigSyncProtocolAvailParallel = MergeIntersects<Static<ReturnType<typeof ConfigSyncProtocolSchemaAvailParallel.allProperties<true>>>>;
+export declare const CommonResponseAvailRpcParallel: import("@sinclair/typebox").TObject<{
+    internal: import("@sinclair/typebox").TObject<{
+        readonly transactionHash: import("@sinclair/typebox").TString;
+    }>;
+    payload: import("@sinclair/typebox").TObject<{
+        readonly mainchain: import("@sinclair/typebox").TObject<{
+            blockNumber: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>, import("@sinclair/typebox").TNull]>;
+            timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").TimestampMs>, import("@sinclair/typebox").TNull]>;
+        }>;
+        readonly primitiveName: import("@sinclair/typebox").TString;
+        readonly caip2: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").Caip2>;
+        readonly ownChain: import("@sinclair/typebox").TObject<{
+            blockNumber: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>;
+        }>;
+        readonly extrinsicIndex: import("@sinclair/typebox").TNumber;
+    }>;
+}>;
+//# sourceMappingURL=rpc.d.ts.map

package/esm/config/src/schema/sync-protocols/avail/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../../../../src/config/src/schema/sync-protocols/avail/rpc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAYrD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,eAAe,EAErB,MAAM,iCAAiC,CAAC;AAMzC,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;GAc5C,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;QAUnC;;;WAGG;;;CAG8C,CAAC;AAYtD,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;GAW5C,CAAC;AACP,MAAM,MAAM,+BAA+B,GAAG,eAAe,CAC3D,MAAM,CACJ,UAAU,CAAC,OAAO,qCAAqC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAC7E,CACF,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;EAG1C,CAAC"}

package/esm/config/src/schema/sync-protocols/avail/rpc.js

@@ -0,0 +1,56 @@
+import { Type } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "../types.js";
+import { NameField, PollingSyncProtocol, StartStopBlockheight, } from "../../common.js";
+import { CommonResponseParallelSyncProtocol, genCommonResponse, waitingPeriodFromDepth, } from "../common.js";
+import { TypeboxHelpers, } from "../../../../../utils/src/mod.js";
+// ===========
+// Base schema
+// ===========
+export const ConfigSyncProtocolSchemaAvailBase = NameField.cloneMerge(PollingSyncProtocol).cloneMerge(StartStopBlockheight).cloneMerge({
+    required: Type.Object({
+        name: Type.String(),
+        rpc: Type.String(),
+        lightClient: Type.String(),
+    }),
+    optional: Type.Object({
+        blockGroupSize: Type.Number({ default: 100 }),
+        stepSize: Type.Number({ default: 1000 }),
+    }),
+});
+export const CommonResponseAvailRpcBase = {
+    internal: {
+        transactionHash: Type.String(),
+    },
+    payload: {
+        primitiveName: Type.String(),
+        caip2: TypeboxHelpers.Caip2,
+        ownChain: Type.Object({
+            blockNumber: TypeboxHelpers.BlockNumber(),
+        }),
+        /**
+         * Recall: in Substrate, tx hashes are not unique
+         *         rather, you have to use blockNumber + extrinsicIndex
+         */
+        extrinsicIndex: Type.Number(),
+    },
+};
+// ==========================
+// Variant 2: parallel config
+// ==========================
+const blockTimeMs = 20 * 1000; // 20 seconds
+/**
+ * Finality is probabilistic, but it's ~3 blocks (60s)
+ */
+const finalityDepth = 3; // 3 blocks
+export const ConfigSyncProtocolSchemaAvailParallel = ConfigSyncProtocolSchemaAvailBase
+    .cloneMerge({
+    required: Type.Object({
+        type: Type.Literal(ConfigSyncProtocolType.AVAIL_PARALLEL),
+    }),
+    optional: Type.Object({
+        ...waitingPeriodFromDepth(finalityDepth, blockTimeMs, {
+            absolute: blockTimeMs,
+        }),
+    }),
+});
+export const CommonResponseAvailRpcParallel = genCommonResponse(CommonResponseParallelSyncProtocol, CommonResponseAvailRpcBase);

package/esm/config/src/schema/sync-protocols/bitcoin/rpc.d.ts

@@ -0,0 +1,76 @@
+import type { Static } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "../types.js";
+import { type IntervalMs, type MergeIntersects } from "../../../../../utils/src/mod.js";
+export declare const ConfigSyncProtocolSchemaBitcoinBase: import("../../utils.js").ConfigSchema<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+} & {
+    pollingInterval: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+} & {
+    startBlockHeight: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>;
+}>, import("@sinclair/typebox").TObject<{
+    stopBlockHeight: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>, import("@sinclair/typebox").TNull]>;
+} & {
+    stepSize: import("@sinclair/typebox").TNumber;
+}>>;
+export declare const CommonResponseBitcoinRpcBase: {
+    readonly internal: {
+        readonly transactionId: import("@sinclair/typebox").TString;
+    };
+    readonly payload: {
+        readonly primitiveName: import("@sinclair/typebox").TString;
+        readonly ownChain: import("@sinclair/typebox").TObject<{
+            blockNumber: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>;
+        }>;
+        readonly direction: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"input">, import("@sinclair/typebox").TLiteral<"output">]>;
+        readonly address: import("@sinclair/typebox").TString;
+        readonly transactionId: import("@sinclair/typebox").TString;
+        readonly index: import("@sinclair/typebox").TNumber;
+        readonly valueSats: import("@sinclair/typebox").TNumber;
+        readonly utxo: import("@sinclair/typebox").TObject<{
+            txid: import("@sinclair/typebox").TString;
+            vout: import("@sinclair/typebox").TNumber;
+        }>;
+    };
+};
+export declare const ConfigSyncProtocolSchemaBitcoinParallel: import("../../utils.js").ConfigSchema<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+} & {
+    pollingInterval: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+} & {
+    startBlockHeight: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>;
+} & {
+    type: import("@sinclair/typebox").TLiteral<ConfigSyncProtocolType.BITCOIN_RPC_PARALLEL>;
+    confirmationDepth: import("@sinclair/typebox").TNumber;
+}>, import("@sinclair/typebox").TObject<{
+    stopBlockHeight: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>, import("@sinclair/typebox").TNull]>;
+} & {
+    stepSize: import("@sinclair/typebox").TNumber;
+} & {
+    delayMs: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+}>>;
+export type ConfigSyncProtocolBitcoinParallel = MergeIntersects<Static<ReturnType<typeof ConfigSyncProtocolSchemaBitcoinParallel.allProperties<true>>>>;
+export declare const CommonResponseBitcoinRpcParallel: import("@sinclair/typebox").TObject<{
+    internal: import("@sinclair/typebox").TObject<{
+        readonly transactionId: import("@sinclair/typebox").TString;
+    }>;
+    payload: import("@sinclair/typebox").TObject<{
+        readonly mainchain: import("@sinclair/typebox").TObject<{
+            blockNumber: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>, import("@sinclair/typebox").TNull]>;
+            timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").TimestampMs>, import("@sinclair/typebox").TNull]>;
+        }>;
+        readonly primitiveName: import("@sinclair/typebox").TString;
+        readonly ownChain: import("@sinclair/typebox").TObject<{
+            blockNumber: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>;
+        }>;
+        readonly direction: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"input">, import("@sinclair/typebox").TLiteral<"output">]>;
+        readonly address: import("@sinclair/typebox").TString;
+        readonly transactionId: import("@sinclair/typebox").TString;
+        readonly index: import("@sinclair/typebox").TNumber;
+        readonly valueSats: import("@sinclair/typebox").TNumber;
+        readonly utxo: import("@sinclair/typebox").TObject<{
+            txid: import("@sinclair/typebox").TString;
+            vout: import("@sinclair/typebox").TNumber;
+        }>;
+    }>;
+}>;
+//# sourceMappingURL=rpc.d.ts.map

package/esm/config/src/schema/sync-protocols/bitcoin/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../../../../src/config/src/schema/sync-protocols/bitcoin/rpc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAWrD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,eAAe,EAErB,MAAM,iCAAiC,CAAC;AAEzC,eAAO,MAAM,mCAAmC;;;;;;;;;;GAO9C,CAAC;AAOH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;CAmBY,CAAC;AAItD,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;GAU9C,CAAC;AAEP,MAAM,MAAM,iCAAiC,GAAG,eAAe,CAC7D,MAAM,CACJ,UAAU,CACR,OAAO,uCAAuC,CAAC,aAAa,CAAC,IAAI,CAAC,CACnE,CACF,CACF,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;EAG5C,CAAC"}

package/esm/config/src/schema/sync-protocols/bitcoin/rpc.js

@@ -0,0 +1,47 @@
+import { Type } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "../types.js";
+import { NameField, PollingSyncProtocol, StartStopBlockheight, } from "../../common.js";
+import { CommonResponseParallelSyncProtocol, genCommonResponse, } from "../common.js";
+import { TypeboxHelpers, } from "../../../../../utils/src/mod.js";
+export const ConfigSyncProtocolSchemaBitcoinBase = NameField.cloneMerge(PollingSyncProtocol).cloneMerge(StartStopBlockheight).cloneMerge({
+    required: Type.Object({}),
+    optional: Type.Object({
+        stepSize: Type.Number({ default: 25 }),
+    }),
+});
+const BitcoinDirection = Type.Union([
+    Type.Literal("input"),
+    Type.Literal("output"),
+]);
+export const CommonResponseBitcoinRpcBase = {
+    internal: {
+        transactionId: Type.String(),
+    },
+    payload: {
+        primitiveName: Type.String(),
+        ownChain: Type.Object({
+            blockNumber: TypeboxHelpers.BlockNumber(),
+        }),
+        direction: BitcoinDirection,
+        address: Type.String(),
+        transactionId: Type.String(),
+        index: Type.Number(),
+        valueSats: Type.Number(),
+        utxo: Type.Object({
+            txid: Type.String(),
+            vout: Type.Number(),
+        }),
+    },
+};
+const blockTimeMs = 10 * 60 * 1000;
+export const ConfigSyncProtocolSchemaBitcoinParallel = ConfigSyncProtocolSchemaBitcoinBase
+    .cloneMerge({
+    required: Type.Object({
+        type: Type.Literal(ConfigSyncProtocolType.BITCOIN_RPC_PARALLEL),
+        confirmationDepth: Type.Number({ default: 6 }),
+    }),
+    optional: Type.Object({
+        delayMs: TypeboxHelpers.IntervalMs({ default: blockTimeMs }),
+    }),
+});
+export const CommonResponseBitcoinRpcParallel = genCommonResponse(CommonResponseParallelSyncProtocol, CommonResponseBitcoinRpcBase);

package/esm/config/src/schema/sync-protocols/cardano/carp.d.ts

@@ -0,0 +1,80 @@
+import type { Static } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "../types.js";
+import { type CardanoBlockHash, type CardanoTxHash, type CarpCursorJson, type IntervalMs, type MergeIntersects } from "../../../../../utils/src/mod.js";
+export declare const CarpCursor: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnsafe<{
+    block: CardanoBlockHash;
+    tx: CardanoTxHash;
+}>, CarpCursorJson>;
+export declare const ConfigSyncProtocolSchemaCardanoCarpBase: import("../../utils.js").ConfigSchema<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+} & {
+    pollingInterval: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+} & {
+    startSlot: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>;
+} & {
+    name: import("@sinclair/typebox").TString;
+    carpUrl: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    stopSlot: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>, import("@sinclair/typebox").TNull]>;
+} & {
+    stepSize: import("@sinclair/typebox").TNumber;
+    paginationLimit: import("@sinclair/typebox").TNumber;
+}>>;
+export declare const CommonResponseCardanoCarpBase: {
+    readonly internal: {
+        readonly cursor: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnsafe<{
+            block: CardanoBlockHash;
+            tx: CardanoTxHash;
+        }>, CarpCursorJson>;
+    };
+    readonly payload: {
+        readonly primitiveName: import("@sinclair/typebox").TString;
+        readonly caip2: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").Caip2>;
+        readonly ownChain: import("@sinclair/typebox").TObject<{
+            absoluteSlotNumber: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>;
+        }>;
+        readonly transactionHash: import("@sinclair/typebox").TUnsafe<CardanoTxHash>;
+    };
+};
+export declare const ConfigSyncProtocolSchemaCardanoCarpParallel: import("../../utils.js").ConfigSchema<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+} & {
+    pollingInterval: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+} & {
+    startSlot: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>;
+} & {
+    name: import("@sinclair/typebox").TString;
+    carpUrl: import("@sinclair/typebox").TString;
+} & {
+    type: import("@sinclair/typebox").TLiteral<ConfigSyncProtocolType.CARDANO_CARP_PARALLEL>;
+}>, import("@sinclair/typebox").TObject<{
+    stopSlot: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>, import("@sinclair/typebox").TNull]>;
+} & {
+    stepSize: import("@sinclair/typebox").TNumber;
+    paginationLimit: import("@sinclair/typebox").TNumber;
+} & {
+    confirmationDepth: import("@sinclair/typebox").TNumber;
+    delayMs: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+}>>;
+export type ConfigSyncProtocolCardanoParallel = MergeIntersects<Static<ReturnType<typeof ConfigSyncProtocolSchemaCardanoCarpParallel.allProperties<true>>>>;
+export declare const CommonResponseCardanoCarpParallel: import("@sinclair/typebox").TObject<{
+    internal: import("@sinclair/typebox").TObject<{
+        readonly cursor: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnsafe<{
+            block: CardanoBlockHash;
+            tx: CardanoTxHash;
+        }>, CarpCursorJson>;
+    }>;
+    payload: import("@sinclair/typebox").TObject<{
+        readonly mainchain: import("@sinclair/typebox").TObject<{
+            blockNumber: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>, import("@sinclair/typebox").TNull]>;
+            timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").TimestampMs>, import("@sinclair/typebox").TNull]>;
+        }>;
+        readonly primitiveName: import("@sinclair/typebox").TString;
+        readonly caip2: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").Caip2>;
+        readonly ownChain: import("@sinclair/typebox").TObject<{
+            absoluteSlotNumber: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>;
+        }>;
+        readonly transactionHash: import("@sinclair/typebox").TUnsafe<CardanoTxHash>;
+    }>;
+}>;
+//# sourceMappingURL=carp.d.ts.map

package/esm/config/src/schema/sync-protocols/cardano/carp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"carp.d.ts","sourceRoot":"","sources":["../../../../../../src/config/src/schema/sync-protocols/cardano/carp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAQrD,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,eAAe,EAErB,MAAM,iCAAiC,CAAC;AAOzC,eAAO,MAAM,UAAU;WACd,gBAAgB;QACnB,aAAa;mBACc,CAAC;AAMlC,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;GAalD,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;mBAvBjC,gBAAgB;gBACnB,aAAa;;;;;;;;;;;CAkCkC,CAAC;AAgBtD,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;GAalD,CAAC;AACP,MAAM,MAAM,iCAAiC,GAAG,eAAe,CAC7D,MAAM,CACJ,UAAU,CACR,OAAO,2CAA2C,CAAC,aAAa,CAAC,IAAI,CAAC,CACvE,CACF,CACF,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;mBAzErC,gBAAgB;gBACnB,aAAa;;;;;;;;;;;;;;;EA2ElB,CAAC"}

package/esm/config/src/schema/sync-protocols/cardano/carp.js

@@ -0,0 +1,62 @@
+import { Type } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "../types.js";
+import { NameField, PollingSyncProtocol, StartStopSlot } from "../../common.js";
+import { CommonResponseParallelSyncProtocol, genCommonResponse, waitingPeriodFromDepth, } from "../common.js";
+import { TypeboxHelpers, } from "../../../../../utils/src/mod.js";
+// =====
+// Utils
+// =====
+const CarpCursorJsonSchema = Type.Unsafe(Type.String());
+export const CarpCursor = TypeboxHelpers.SerializeObjAsJson();
+// ===========
+// Base schema
+// ===========
+export const ConfigSyncProtocolSchemaCardanoCarpBase = NameField.cloneMerge(PollingSyncProtocol).cloneMerge(StartStopSlot).cloneMerge({
+    required: Type.Object({
+        name: Type.String(),
+        carpUrl: Type.String(),
+    }),
+    optional: Type.Object({
+        stepSize: Type.Number({ default: 1000 }),
+        paginationLimit: Type.Number({ default: 50 }),
+    }),
+});
+export const CommonResponseCardanoCarpBase = {
+    internal: {
+        cursor: CarpCursor,
+    },
+    payload: {
+        primitiveName: Type.String(),
+        caip2: TypeboxHelpers.Caip2,
+        ownChain: Type.Object({
+            absoluteSlotNumber: TypeboxHelpers.AbsoluteSlotNumber(),
+        }),
+        transactionHash: TypeboxHelpers.Cardano.TxHash,
+    },
+};
+// ==========================
+// Variant2: parallel config
+// ==========================
+/**
+ * Cardano block times are not deterministic, but it's approximately 20 seconds
+ */
+const blockTimeMs = 20 * 1000;
+/**
+ * Cardano has probabilistic finality, and rollbacks take "k" (1 day) to avoid
+ * since that's not realistic, we just arbitrarily pick 5 blocks
+ */
+const finalityDepth = 5;
+export const ConfigSyncProtocolSchemaCardanoCarpParallel = ConfigSyncProtocolSchemaCardanoCarpBase
+    .cloneMerge({
+    required: Type.Object({
+        type: Type.Literal(ConfigSyncProtocolType.CARDANO_CARP_PARALLEL),
+    }),
+    optional: Type.Object({
+        // blocks are only approximately, but could be much longer so we add an extra delay
+        ...waitingPeriodFromDepth(finalityDepth, blockTimeMs, {
+            factor: 2,
+            absolute: 0,
+        }),
+    }),
+});
+export const CommonResponseCardanoCarpParallel = genCommonResponse(CommonResponseParallelSyncProtocol, CommonResponseCardanoCarpBase);

package/esm/config/src/schema/sync-protocols/cardano/mod.d.ts

@@ -0,0 +1,2 @@
+export * from './carp.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/config/src/schema/sync-protocols/cardano/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/config/src/schema/sync-protocols/cardano/mod.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/esm/config/src/schema/sync-protocols/cardano/mod.js

@@ -0,0 +1 @@
+export * from './carp.js';

package/esm/config/src/schema/sync-protocols/cardano/utxorpc.d.ts

@@ -0,0 +1,56 @@
+import type { Static } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "../types.js";
+import { type CardanoTxHash, type IntervalMs, type MergeIntersects } from "../../../../../utils/src/mod.js";
+export declare const ConfigSyncProtocolSchemaCardanoUtxoRpcBase: import("../../utils.js").ConfigSchema<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+} & {
+    startSlot: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>;
+} & {
+    name: import("@sinclair/typebox").TString;
+    rpcUrl: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    stopSlot: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>, import("@sinclair/typebox").TNull]>;
+}>>;
+export declare const CommonResponseCardanoUtxoRpcBase: {
+    readonly internal: {};
+    readonly payload: {
+        readonly primitiveName: import("@sinclair/typebox").TString;
+        readonly caip2: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").Caip2>;
+        readonly ownChain: import("@sinclair/typebox").TObject<{
+            absoluteSlotNumber: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>;
+        }>;
+        readonly transactionHash: import("@sinclair/typebox").TUnsafe<CardanoTxHash>;
+    };
+};
+export declare const ConfigSyncProtocolSchemaCardanoUtxoRpcParallel: import("../../utils.js").ConfigSchema<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+} & {
+    startSlot: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>;
+} & {
+    name: import("@sinclair/typebox").TString;
+    rpcUrl: import("@sinclair/typebox").TString;
+} & {
+    type: import("@sinclair/typebox").TLiteral<ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL>;
+}>, import("@sinclair/typebox").TObject<{
+    stopSlot: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>, import("@sinclair/typebox").TNull]>;
+} & {
+    confirmationDepth: import("@sinclair/typebox").TNumber;
+    delayMs: import("@sinclair/typebox").TUnsafe<IntervalMs>;
+}>>;
+export type ConfigSyncProtocolCardanoParallel = MergeIntersects<Static<ReturnType<typeof ConfigSyncProtocolSchemaCardanoUtxoRpcParallel.allProperties<true>>>>;
+export declare const CommonResponseCardanoUtxoRpcParallel: import("@sinclair/typebox").TObject<{
+    internal: import("@sinclair/typebox").TObject<{}>;
+    payload: import("@sinclair/typebox").TObject<{
+        readonly mainchain: import("@sinclair/typebox").TObject<{
+            blockNumber: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").BlockNumber>, import("@sinclair/typebox").TNull]>;
+            timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").TimestampMs>, import("@sinclair/typebox").TNull]>;
+        }>;
+        readonly primitiveName: import("@sinclair/typebox").TString;
+        readonly caip2: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").Caip2>;
+        readonly ownChain: import("@sinclair/typebox").TObject<{
+            absoluteSlotNumber: import("@sinclair/typebox").TUnsafe<import("../../../../../utils/src/mod.js").AbsoluteSlotNumber>;
+        }>;
+        readonly transactionHash: import("@sinclair/typebox").TUnsafe<CardanoTxHash>;
+    }>;
+}>;
+//# sourceMappingURL=utxorpc.d.ts.map

package/esm/config/src/schema/sync-protocols/cardano/utxorpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utxorpc.d.ts","sourceRoot":"","sources":["../../../../../../src/config/src/schema/sync-protocols/cardano/utxorpc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAQrD,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,eAAe,EAErB,MAAM,iCAAiC,CAAC;AAUzC,eAAO,MAAM,0CAA0C;;;;;;;;;GASnD,CAAC;AAEL,eAAO,MAAM,gCAAgC;;;;;;;;;;CAUQ,CAAC;AAgBtD,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;GAarD,CAAC;AACP,MAAM,MAAM,iCAAiC,GAAG,eAAe,CAC7D,MAAM,CACJ,UAAU,CACR,OAAO,8CAA8C,CAAC,aAAa,CAAC,IAAI,CAAC,CAC1E,CACF,CACF,CAAC;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;EAGhD,CAAC"}

package/esm/config/src/schema/sync-protocols/cardano/utxorpc.js

@@ -0,0 +1,56 @@
+import { Type } from "@sinclair/typebox";
+import { ConfigSyncProtocolType } from "../types.js";
+import { NameField, StartStopSlot } from "../../common.js";
+import { CommonResponseParallelSyncProtocol, genCommonResponse, waitingPeriodFromDepth, } from "../common.js";
+import { TypeboxHelpers, } from "../../../../../utils/src/mod.js";
+// =====
+// Utils
+// =====
+// ===========
+// Base schema
+// ===========
+export const ConfigSyncProtocolSchemaCardanoUtxoRpcBase = NameField
+    .cloneMerge(StartStopSlot).cloneMerge({
+    required: Type.Object({
+        name: Type.String(),
+        rpcUrl: Type.String(),
+    }),
+    optional: Type.Object({}),
+});
+export const CommonResponseCardanoUtxoRpcBase = {
+    internal: {},
+    payload: {
+        primitiveName: Type.String(),
+        caip2: TypeboxHelpers.Caip2,
+        ownChain: Type.Object({
+            absoluteSlotNumber: TypeboxHelpers.AbsoluteSlotNumber(),
+        }),
+        transactionHash: TypeboxHelpers.Cardano.TxHash,
+    },
+};
+// ==========================
+// Variant2: parallel config
+// ==========================
+/**
+ * Cardano block times are not deterministic, but it's approximately 20 seconds
+ */
+const blockTimeMs = 20 * 1000;
+/**
+ * Cardano has probabilistic finality, and rollbacks take "k" (1 day) to avoid
+ * since that's not realistic, we just arbitrarily pick 5 blocks
+ */
+const finalityDepth = 5;
+export const ConfigSyncProtocolSchemaCardanoUtxoRpcParallel = ConfigSyncProtocolSchemaCardanoUtxoRpcBase
+    .cloneMerge({
+    required: Type.Object({
+        type: Type.Literal(ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL),
+    }),
+    optional: Type.Object({
+        // blocks are only approximately, but could be much longer so we add an extra delay
+        ...waitingPeriodFromDepth(finalityDepth, blockTimeMs, {
+            factor: 2,
+            absolute: 0,
+        }),
+    }),
+});
+export const CommonResponseCardanoUtxoRpcParallel = genCommonResponse(CommonResponseParallelSyncProtocol, CommonResponseCardanoUtxoRpcBase);