@paimaexample/wallets 0.3.117

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

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

package/script/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/script/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/script/config/src/schema/sync-protocols/avail/rpc.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonResponseAvailRpcParallel = exports.ConfigSyncProtocolSchemaAvailParallel = exports.CommonResponseAvailRpcBase = exports.ConfigSyncProtocolSchemaAvailBase = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const types_js_1 = require("../types.js");
+const common_js_1 = require("../../common.js");
+const common_js_2 = require("../common.js");
+const mod_js_1 = require("../../../../../utils/src/mod.js");
+// ===========
+// Base schema
+// ===========
+exports.ConfigSyncProtocolSchemaAvailBase = common_js_1.NameField.cloneMerge(common_js_1.PollingSyncProtocol).cloneMerge(common_js_1.StartStopBlockheight).cloneMerge({
+    required: typebox_1.Type.Object({
+        name: typebox_1.Type.String(),
+        rpc: typebox_1.Type.String(),
+        lightClient: typebox_1.Type.String(),
+    }),
+    optional: typebox_1.Type.Object({
+        blockGroupSize: typebox_1.Type.Number({ default: 100 }),
+        stepSize: typebox_1.Type.Number({ default: 1000 }),
+    }),
+});
+exports.CommonResponseAvailRpcBase = {
+    internal: {
+        transactionHash: typebox_1.Type.String(),
+    },
+    payload: {
+        primitiveName: typebox_1.Type.String(),
+        caip2: mod_js_1.TypeboxHelpers.Caip2,
+        ownChain: typebox_1.Type.Object({
+            blockNumber: mod_js_1.TypeboxHelpers.BlockNumber(),
+        }),
+        /**
+         * Recall: in Substrate, tx hashes are not unique
+         *         rather, you have to use blockNumber + extrinsicIndex
+         */
+        extrinsicIndex: typebox_1.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
+exports.ConfigSyncProtocolSchemaAvailParallel = exports.ConfigSyncProtocolSchemaAvailBase
+    .cloneMerge({
+    required: typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(types_js_1.ConfigSyncProtocolType.AVAIL_PARALLEL),
+    }),
+    optional: typebox_1.Type.Object({
+        ...(0, common_js_2.waitingPeriodFromDepth)(finalityDepth, blockTimeMs, {
+            absolute: blockTimeMs,
+        }),
+    }),
+});
+exports.CommonResponseAvailRpcParallel = (0, common_js_2.genCommonResponse)(common_js_2.CommonResponseParallelSyncProtocol, exports.CommonResponseAvailRpcBase);

package/script/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/script/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/script/config/src/schema/sync-protocols/bitcoin/rpc.js

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

package/script/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/script/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/script/config/src/schema/sync-protocols/cardano/carp.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonResponseCardanoCarpParallel = exports.ConfigSyncProtocolSchemaCardanoCarpParallel = exports.CommonResponseCardanoCarpBase = exports.ConfigSyncProtocolSchemaCardanoCarpBase = exports.CarpCursor = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const types_js_1 = require("../types.js");
+const common_js_1 = require("../../common.js");
+const common_js_2 = require("../common.js");
+const mod_js_1 = require("../../../../../utils/src/mod.js");
+// =====
+// Utils
+// =====
+const CarpCursorJsonSchema = typebox_1.Type.Unsafe(typebox_1.Type.String());
+exports.CarpCursor = mod_js_1.TypeboxHelpers.SerializeObjAsJson();
+// ===========
+// Base schema
+// ===========
+exports.ConfigSyncProtocolSchemaCardanoCarpBase = common_js_1.NameField.cloneMerge(common_js_1.PollingSyncProtocol).cloneMerge(common_js_1.StartStopSlot).cloneMerge({
+    required: typebox_1.Type.Object({
+        name: typebox_1.Type.String(),
+        carpUrl: typebox_1.Type.String(),
+    }),
+    optional: typebox_1.Type.Object({
+        stepSize: typebox_1.Type.Number({ default: 1000 }),
+        paginationLimit: typebox_1.Type.Number({ default: 50 }),
+    }),
+});
+exports.CommonResponseCardanoCarpBase = {
+    internal: {
+        cursor: exports.CarpCursor,
+    },
+    payload: {
+        primitiveName: typebox_1.Type.String(),
+        caip2: mod_js_1.TypeboxHelpers.Caip2,
+        ownChain: typebox_1.Type.Object({
+            absoluteSlotNumber: mod_js_1.TypeboxHelpers.AbsoluteSlotNumber(),
+        }),
+        transactionHash: mod_js_1.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;
+exports.ConfigSyncProtocolSchemaCardanoCarpParallel = exports.ConfigSyncProtocolSchemaCardanoCarpBase
+    .cloneMerge({
+    required: typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(types_js_1.ConfigSyncProtocolType.CARDANO_CARP_PARALLEL),
+    }),
+    optional: typebox_1.Type.Object({
+        // blocks are only approximately, but could be much longer so we add an extra delay
+        ...(0, common_js_2.waitingPeriodFromDepth)(finalityDepth, blockTimeMs, {
+            factor: 2,
+            absolute: 0,
+        }),
+    }),
+});
+exports.CommonResponseCardanoCarpParallel = (0, common_js_2.genCommonResponse)(common_js_2.CommonResponseParallelSyncProtocol, exports.CommonResponseCardanoCarpBase);

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

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

package/script/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/script/config/src/schema/sync-protocols/cardano/mod.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./carp.js"), exports);

package/script/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/script/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/script/config/src/schema/sync-protocols/cardano/utxorpc.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonResponseCardanoUtxoRpcParallel = exports.ConfigSyncProtocolSchemaCardanoUtxoRpcParallel = exports.CommonResponseCardanoUtxoRpcBase = exports.ConfigSyncProtocolSchemaCardanoUtxoRpcBase = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const types_js_1 = require("../types.js");
+const common_js_1 = require("../../common.js");
+const common_js_2 = require("../common.js");
+const mod_js_1 = require("../../../../../utils/src/mod.js");
+// =====
+// Utils
+// =====
+// ===========
+// Base schema
+// ===========
+exports.ConfigSyncProtocolSchemaCardanoUtxoRpcBase = common_js_1.NameField
+    .cloneMerge(common_js_1.StartStopSlot).cloneMerge({
+    required: typebox_1.Type.Object({
+        name: typebox_1.Type.String(),
+        rpcUrl: typebox_1.Type.String(),
+    }),
+    optional: typebox_1.Type.Object({}),
+});
+exports.CommonResponseCardanoUtxoRpcBase = {
+    internal: {},
+    payload: {
+        primitiveName: typebox_1.Type.String(),
+        caip2: mod_js_1.TypeboxHelpers.Caip2,
+        ownChain: typebox_1.Type.Object({
+            absoluteSlotNumber: mod_js_1.TypeboxHelpers.AbsoluteSlotNumber(),
+        }),
+        transactionHash: mod_js_1.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;
+exports.ConfigSyncProtocolSchemaCardanoUtxoRpcParallel = exports.ConfigSyncProtocolSchemaCardanoUtxoRpcBase
+    .cloneMerge({
+    required: typebox_1.Type.Object({
+        type: typebox_1.Type.Literal(types_js_1.ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL),
+    }),
+    optional: typebox_1.Type.Object({
+        // blocks are only approximately, but could be much longer so we add an extra delay
+        ...(0, common_js_2.waitingPeriodFromDepth)(finalityDepth, blockTimeMs, {
+            factor: 2,
+            absolute: 0,
+        }),
+    }),
+});
+exports.CommonResponseCardanoUtxoRpcParallel = (0, common_js_2.genCommonResponse)(common_js_2.CommonResponseParallelSyncProtocol, exports.CommonResponseCardanoUtxoRpcBase);