@xyo-network/xl1-protocol-sdk 1.23.21 → 1.24.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol-sdk",
-  "version": "1.23.21",
+  "version": "1.24.0",
   "description": "XYO Layer One SDK Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -57,8 +57,8 @@
     "@xyo-network/payload-builder": "~5.3.2",
     "@xyo-network/payload-model": "~5.3.2",
     "@xyo-network/wallet": "~5.3.2",
-    "@xyo-network/xl1-protocol": "~1.23.21",
-    "@xyo-network/xl1-schema": "~1.23.21",
+    "@xyo-network/xl1-protocol": "~1.24.0",
+    "@xyo-network/xl1-schema": "~1.24.0",
     "async-mutex": "~0.5.0",
     "ethers": "^6.16.0",
     "lru-cache": "^11.2.6"

package/src/config/Config.ts

@@ -1,58 +1,27 @@
 import { deepMerge } from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
+import z from 'zod'
 
-import {
-  ApiConfigZod, BridgeConfigZod, MempoolConfigZod, ProducerConfigZod, RewardRedemptionConfigZod,
-} from './actors/index.ts'
-import type { BaseConfig } from './Base.ts'
 import { BaseConfigZod } from './Base.ts'
 
-export const ActorsConfigZod = z.object({
-  api: ApiConfigZod.default(ApiConfigZod.parse({})).register(globalRegistry, {
-    description: 'Configuration for the api Actor',
-    type: 'object',
-  }),
-  bridge: BridgeConfigZod.default(BridgeConfigZod.parse({})).register(globalRegistry, {
-    description: 'Configuration for the bridge Actor',
-    type: 'object',
-  }),
-  mempool: MempoolConfigZod.default(MempoolConfigZod.parse({})).register(globalRegistry, {
-    description: 'Configuration for the mempool Actor',
-    type: 'object',
-  }),
-  producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).register(globalRegistry, {
-    description: 'Configuration for the producer Actor',
-    type: 'object',
-  }),
-  rewardRedemption: RewardRedemptionConfigZod.default(RewardRedemptionConfigZod.parse({})).register(globalRegistry, {
-    description: 'Configuration for the rewardRedemption Actor',
-    type: 'object',
-  }),
-}).describe('Actor-specific configurations that override the base configuration when the actor is running').default({
-  api: ApiConfigZod.parse({}),
-  bridge: BridgeConfigZod.parse({}),
-  mempool: MempoolConfigZod.parse({}),
-  producer: ProducerConfigZod.parse({}),
-  rewardRedemption: RewardRedemptionConfigZod.parse({}),
-})
+export const ActorsConfigZod = z.array(BaseConfigZod.loose()).describe('Actor-specific configurations that override the base configuration when the actor is running').default([])
 
 export type ActorsConfig = z.infer<typeof ActorsConfigZod>
 
-export const ConfigZod = BaseConfigZod.extend(z.object({ actors: ActorsConfigZod.default(ActorsConfigZod.parse({})) })
+export const ConfigZod = BaseConfigZod.extend(z.object({ actors: ActorsConfigZod })
   .describe('Actor-specific configurations that override the base configuration when the actor is running').shape)
 
 export type Config = z.infer<typeof ConfigZod>
 export type ActorName = keyof ActorsConfig
 
-export function resolveConfig<T extends ActorName>(
+export function resolveConfig(
   config: Config,
-  actor: ActorName,
 ) {
   const parsedConfig = ConfigZod.parse(config)
-  if (parsedConfig.actors?.[actor] === undefined) {
-    return BaseConfigZod.parse(config) as BaseConfig & Partial<ActorsConfig[T]>
-  }
-  return deepMerge(BaseConfigZod.parse(config), parsedConfig.actors[actor]) as ActorsConfig[T]
+  const { actors, ...rootConfig } = parsedConfig
+  parsedConfig.actors = actors.map((actorConfig) => {
+    return BaseConfigZod.loose().parse(deepMerge(rootConfig, actorConfig))
+  })
+  return parsedConfig
 }
 
 /** @deprecated Use ConfigZod.parse({}) instead */

package/src/config/index.ts

@@ -1,4 +1,4 @@
-export * from './actors/index.ts'
+export * from './Base.ts'
 export * from './Config.ts'
 export { hasMongoConfig } from './storage/index.ts'
 export { DefaultMetricsScrapePorts } from './Telemetry.ts'

package/dist/neutral/config/actors/Api.d.ts

@@ -1,76 +0,0 @@
-import { z } from 'zod';
-export declare const ApiConfigZod: z.ZodObject<{
-    chain: z.ZodDefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>;
-    }, z.core.$strip>>;
-    evm: z.ZodDefault<z.ZodObject<{
-        chainId: z.ZodOptional<z.ZodString>;
-        infura: z.ZodOptional<z.ZodObject<{
-            projectId: z.ZodOptional<z.ZodString>;
-            projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        jsonRpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    log: z.ZodDefault<z.ZodObject<{
-        logLevel: z.ZodDefault<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    remote: z.ZodDefault<z.ZodObject<{
-        rpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    storage: z.ZodDefault<z.ZodObject<{
-        mongo: z.ZodOptional<z.ZodObject<{
-            connectionString: z.ZodOptional<z.ZodString>;
-            database: z.ZodOptional<z.ZodString>;
-            domain: z.ZodOptional<z.ZodString>;
-            password: z.ZodOptional<z.ZodString>;
-            username: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    telemetry: z.ZodDefault<z.ZodObject<{
-        metrics: z.ZodOptional<z.ZodObject<{
-            scrape: z.ZodObject<{
-                path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: z.ZodOptional<z.ZodObject<{
-            otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodDefault<z.ZodObject<{
-        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-    }, z.core.$strip>>;
-    host: z.ZodDefault<z.ZodString>;
-    initRewardsCache: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>, z.ZodTransform<boolean, string | number | boolean>>>;
-    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
-export type ApiConfig = z.infer<typeof ApiConfigZod>;
-//# sourceMappingURL=Api.d.ts.map

package/dist/neutral/config/actors/Api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Api.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/Api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBhB,CAAA;AAET,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/neutral/config/actors/Bridge.d.ts

@@ -1,124 +0,0 @@
-import { z } from 'zod';
-export declare const BasisPointsZod: z.ZodCoercedNumber<unknown>;
-export type BasisPoints = z.infer<typeof BasisPointsZod>;
-export declare const BridgeConfigZod: z.ZodObject<{
-    chain: z.ZodDefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>;
-    }, z.core.$strip>>;
-    evm: z.ZodDefault<z.ZodObject<{
-        chainId: z.ZodOptional<z.ZodString>;
-        infura: z.ZodOptional<z.ZodObject<{
-            projectId: z.ZodOptional<z.ZodString>;
-            projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        jsonRpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    log: z.ZodDefault<z.ZodObject<{
-        logLevel: z.ZodDefault<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    remote: z.ZodDefault<z.ZodObject<{
-        rpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    storage: z.ZodDefault<z.ZodObject<{
-        mongo: z.ZodOptional<z.ZodObject<{
-            connectionString: z.ZodOptional<z.ZodString>;
-            database: z.ZodOptional<z.ZodString>;
-            domain: z.ZodOptional<z.ZodString>;
-            password: z.ZodOptional<z.ZodString>;
-            username: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    telemetry: z.ZodDefault<z.ZodObject<{
-        metrics: z.ZodOptional<z.ZodObject<{
-            scrape: z.ZodObject<{
-                path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: z.ZodOptional<z.ZodObject<{
-            otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodDefault<z.ZodObject<{
-        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-    }, z.core.$strip>>;
-    escrowAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>>;
-    feesAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>>;
-    feeFixed: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-    feeRateBasisPoints: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    host: z.ZodDefault<z.ZodString>;
-    maxBridgeAmount: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-    minBridgeAmount: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    redisHost: z.ZodDefault<z.ZodString>;
-    redisPort: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    remoteBridgeContractAddress: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>>;
-    remoteChainId: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-    remoteTokenAddress: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-    remoteChainWalletPrivateKey: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-    xl1ChainId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-    xl1TokenAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-}, z.core.$strip>;
-export type BridgeConfig = z.infer<typeof BridgeConfigZod>;
-export declare const BridgeSettingsZod: z.ZodObject<{
-    escrowAddress: z.ZodNonOptional<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>>>;
-    feesAddress: z.ZodNonOptional<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>>>;
-    feeFixed: z.ZodNonOptional<z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>>;
-    feeRateBasisPoints: z.ZodNonOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
-    maxBridgeAmount: z.ZodNonOptional<z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>>;
-    minBridgeAmount: z.ZodNonOptional<z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>>;
-    remoteChainId: z.ZodNonOptional<z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>>;
-    remoteTokenAddress: z.ZodNonOptional<z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>>;
-    xl1ChainId: z.ZodNonOptional<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>>;
-    xl1TokenAddress: z.ZodNonOptional<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>>;
-}, z.core.$strip>;
-export type BridgeSettings = z.infer<typeof BridgeSettingsZod>;
-//# sourceMappingURL=Bridge.d.ts.map

package/dist/neutral/config/actors/Bridge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Bridge.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/Bridge.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAavC,eAAO,MAAM,cAAc,6BAAoD,CAAA;AAC/E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiGnB,CAAA;AAET,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;iBAWjB,CAAA;AAEb,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/config/actors/Mempool.d.ts

@@ -1,76 +0,0 @@
-import { z } from 'zod';
-export declare const MempoolConfigZod: z.ZodObject<{
-    chain: z.ZodDefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>;
-    }, z.core.$strip>>;
-    evm: z.ZodDefault<z.ZodObject<{
-        chainId: z.ZodOptional<z.ZodString>;
-        infura: z.ZodOptional<z.ZodObject<{
-            projectId: z.ZodOptional<z.ZodString>;
-            projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        jsonRpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    log: z.ZodDefault<z.ZodObject<{
-        logLevel: z.ZodDefault<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    remote: z.ZodDefault<z.ZodObject<{
-        rpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    storage: z.ZodDefault<z.ZodObject<{
-        mongo: z.ZodOptional<z.ZodObject<{
-            connectionString: z.ZodOptional<z.ZodString>;
-            database: z.ZodOptional<z.ZodString>;
-            domain: z.ZodOptional<z.ZodString>;
-            password: z.ZodOptional<z.ZodString>;
-            username: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    telemetry: z.ZodDefault<z.ZodObject<{
-        metrics: z.ZodOptional<z.ZodObject<{
-            scrape: z.ZodObject<{
-                path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: z.ZodOptional<z.ZodObject<{
-            otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodDefault<z.ZodObject<{
-        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-    }, z.core.$strip>>;
-    enabled: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>, z.ZodTransform<boolean, string | boolean>>;
-    host: z.ZodDefault<z.ZodString>;
-    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
-export type MempoolConfig = z.infer<typeof MempoolConfigZod>;
-//# sourceMappingURL=Mempool.d.ts.map

package/dist/neutral/config/actors/Mempool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mempool.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/Mempool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCpB,CAAA;AAET,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/neutral/config/actors/Producer.d.ts

@@ -1,84 +0,0 @@
-import { z } from 'zod';
-export declare const ProducerConfigZod: z.ZodObject<{
-    chain: z.ZodDefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>;
-    }, z.core.$strip>>;
-    evm: z.ZodDefault<z.ZodObject<{
-        chainId: z.ZodOptional<z.ZodString>;
-        infura: z.ZodOptional<z.ZodObject<{
-            projectId: z.ZodOptional<z.ZodString>;
-            projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        jsonRpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    log: z.ZodDefault<z.ZodObject<{
-        logLevel: z.ZodDefault<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    remote: z.ZodDefault<z.ZodObject<{
-        rpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    storage: z.ZodDefault<z.ZodObject<{
-        mongo: z.ZodOptional<z.ZodObject<{
-            connectionString: z.ZodOptional<z.ZodString>;
-            database: z.ZodOptional<z.ZodString>;
-            domain: z.ZodOptional<z.ZodString>;
-            password: z.ZodOptional<z.ZodString>;
-            username: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    telemetry: z.ZodDefault<z.ZodObject<{
-        metrics: z.ZodOptional<z.ZodObject<{
-            scrape: z.ZodObject<{
-                path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: z.ZodOptional<z.ZodObject<{
-            otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodDefault<z.ZodObject<{
-        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-    }, z.core.$strip>>;
-    allowlist: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>>>>;
-    disableIntentRedeclaration: z.ZodOptional<z.ZodBoolean>;
-    healthCheckPort: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    heartbeatInterval: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    minStake: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    rewardAddress: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ProducerConfig = z.infer<typeof ProducerConfigZod>;
-//# sourceMappingURL=Producer.d.ts.map

package/dist/neutral/config/actors/Producer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Producer.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/Producer.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDrB,CAAA;AAET,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/config/actors/RewardRedemption.d.ts

@@ -1,75 +0,0 @@
-import { z } from 'zod';
-export declare const RewardRedemptionConfigZod: z.ZodObject<{
-    chain: z.ZodDefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>;
-    }, z.core.$strip>>;
-    evm: z.ZodDefault<z.ZodObject<{
-        chainId: z.ZodOptional<z.ZodString>;
-        infura: z.ZodOptional<z.ZodObject<{
-            projectId: z.ZodOptional<z.ZodString>;
-            projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        jsonRpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    log: z.ZodDefault<z.ZodObject<{
-        logLevel: z.ZodDefault<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    remote: z.ZodDefault<z.ZodObject<{
-        rpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    storage: z.ZodDefault<z.ZodObject<{
-        mongo: z.ZodOptional<z.ZodObject<{
-            connectionString: z.ZodOptional<z.ZodString>;
-            database: z.ZodOptional<z.ZodString>;
-            domain: z.ZodOptional<z.ZodString>;
-            password: z.ZodOptional<z.ZodString>;
-            username: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    telemetry: z.ZodDefault<z.ZodObject<{
-        metrics: z.ZodOptional<z.ZodObject<{
-            scrape: z.ZodObject<{
-                path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: z.ZodOptional<z.ZodObject<{
-            otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodDefault<z.ZodObject<{
-        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-    }, z.core.$strip>>;
-    host: z.ZodDefault<z.ZodString>;
-    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
-export type RewardRedemptionConfig = z.infer<typeof RewardRedemptionConfigZod>;
-//# sourceMappingURL=RewardRedemption.d.ts.map

package/dist/neutral/config/actors/RewardRedemption.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RewardRedemption.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/RewardRedemption.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkB7B,CAAA;AAET,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA"}

package/dist/neutral/config/actors/index.d.ts

@@ -1,7 +0,0 @@
-export * from './Api.ts';
-export * from './Api.ts';
-export * from './Bridge.ts';
-export * from './Mempool.ts';
-export * from './Producer.ts';
-export * from './RewardRedemption.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/neutral/config/actors/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,uBAAuB,CAAA"}

package/src/config/actors/Api.ts

@@ -1,33 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-import { MnemonicStringZod } from '../../validation/index.ts'
-import { BaseConfigZod } from '../Base.ts'
-
-export const ApiConfigZod = BaseConfigZod.extend(z.object({
-  host: z.string().default('localhost').register(globalRegistry, {
-    default: 'localhost',
-    description: 'Host for the API',
-    title: 'api.host',
-    type: 'string',
-  }),
-  initRewardsCache: z.union([z.number(), z.string(), z.boolean()]).transform(
-    v => v !== '0' && v !== 'false' && v !== false && v != 0,
-  ).default(true).register(globalRegistry, {
-    description: 'Whether to initialize the rewards cache on startup',
-    title: 'api.initRewardsCache',
-    type: 'boolean',
-  }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
-    description: 'Mnemonic for the API wallet',
-    title: 'api.mnemonic',
-    type: 'string',
-  }),
-  port: z.coerce.number().default(8080).register(globalRegistry, {
-    default: 8080,
-    description: 'Port for the API',
-    title: 'api.port',
-    type: 'number',
-  }),
-}).shape)
-
-export type ApiConfig = z.infer<typeof ApiConfigZod>