@recoillink/sdk 0.0.0-stage → 45.0.1

package/dist/metadata/agentConfig.js

@@ -0,0 +1,750 @@
+/**
+ * The types defined here are the source of truth for chain metadata.
+ * ANY CHANGES HERE NEED TO BE REFLECTED IN HYPERLANE-BASE CONFIG PARSING.
+ */
+import { PublicKey } from '@solana/web3.js';
+import { z } from 'zod';
+import { ModuleType } from '@recoillink/sdk';
+import { ProtocolType, isEmptyAddress } from '@recoillink/utils';
+import { ChainMetadataSchemaObject } from './chainMetadataTypes.js';
+import { ZHash, ZNzUint, ZUWei } from './customZodTypes.js';
+import { HyperlaneDeploymentArtifactsSchema, } from './deploymentArtifacts.js';
+import { MatchingListSchema } from './matchingList.js';
+// Keep in sync with MAX_SIGN_CONCURRENCY in the validator settings parser.
+const MAX_SIGN_CONCURRENCY = 1_000;
+export var RpcConsensusType;
+(function (RpcConsensusType) {
+    RpcConsensusType["Single"] = "single";
+    RpcConsensusType["Fallback"] = "fallback";
+    RpcConsensusType["Quorum"] = "quorum";
+    RpcConsensusType["Majority"] = "majority";
+})(RpcConsensusType || (RpcConsensusType = {}));
+export var AgentLogLevel;
+(function (AgentLogLevel) {
+    AgentLogLevel["Off"] = "off";
+    AgentLogLevel["Error"] = "error";
+    AgentLogLevel["Warn"] = "warn";
+    AgentLogLevel["Info"] = "info";
+    AgentLogLevel["Debug"] = "debug";
+    AgentLogLevel["Trace"] = "trace";
+})(AgentLogLevel || (AgentLogLevel = {}));
+export var AgentLogFormat;
+(function (AgentLogFormat) {
+    AgentLogFormat["Json"] = "json";
+    AgentLogFormat["Compact"] = "compact";
+    AgentLogFormat["Full"] = "full";
+    AgentLogFormat["Pretty"] = "pretty";
+})(AgentLogFormat || (AgentLogFormat = {}));
+export var AgentIndexMode;
+(function (AgentIndexMode) {
+    AgentIndexMode["Block"] = "block";
+    AgentIndexMode["Sequence"] = "sequence";
+})(AgentIndexMode || (AgentIndexMode = {}));
+export var AgentSignerKeyType;
+(function (AgentSignerKeyType) {
+    AgentSignerKeyType["Aws"] = "aws";
+    AgentSignerKeyType["Gcp"] = "gcp";
+    AgentSignerKeyType["Hex"] = "hexKey";
+    AgentSignerKeyType["Node"] = "node";
+    AgentSignerKeyType["Cosmos"] = "cosmosKey";
+    AgentSignerKeyType["Starknet"] = "starkKey";
+    AgentSignerKeyType["Radix"] = "radixKey";
+})(AgentSignerKeyType || (AgentSignerKeyType = {}));
+export var AgentSealevelPriorityFeeOracleType;
+(function (AgentSealevelPriorityFeeOracleType) {
+    AgentSealevelPriorityFeeOracleType["Helius"] = "helius";
+    AgentSealevelPriorityFeeOracleType["Constant"] = "constant";
+})(AgentSealevelPriorityFeeOracleType || (AgentSealevelPriorityFeeOracleType = {}));
+export var AgentSealevelHeliusFeeLevel;
+(function (AgentSealevelHeliusFeeLevel) {
+    AgentSealevelHeliusFeeLevel["Recommended"] = "recommended";
+    AgentSealevelHeliusFeeLevel["Min"] = "min";
+    AgentSealevelHeliusFeeLevel["Low"] = "low";
+    AgentSealevelHeliusFeeLevel["Medium"] = "medium";
+    AgentSealevelHeliusFeeLevel["High"] = "high";
+    AgentSealevelHeliusFeeLevel["VeryHigh"] = "veryHigh";
+    AgentSealevelHeliusFeeLevel["UnsafeMax"] = "unsafeMax";
+})(AgentSealevelHeliusFeeLevel || (AgentSealevelHeliusFeeLevel = {}));
+export var AgentSealevelTransactionSubmitterType;
+(function (AgentSealevelTransactionSubmitterType) {
+    AgentSealevelTransactionSubmitterType["Rpc"] = "rpc";
+    AgentSealevelTransactionSubmitterType["Jito"] = "jito";
+})(AgentSealevelTransactionSubmitterType || (AgentSealevelTransactionSubmitterType = {}));
+const AgentSignerHexKeySchema = z
+    .object({
+    type: z.literal(AgentSignerKeyType.Hex).optional(),
+    key: ZHash,
+})
+    .describe('A local hex key');
+const AgentSignerAwsKeySchema = z
+    .object({
+    type: z.literal(AgentSignerKeyType.Aws).optional(),
+    id: z.string().describe('The UUID identifying the AWS KMS key'),
+    region: z.string().describe('The AWS region'),
+})
+    .describe('An AWS signer. Note that AWS credentials must be inserted into the env separately.');
+const AgentSignerGcpKeySchema = z
+    .object({
+    // Required, unlike Hex/Aws's optional `type` - those stay optional only
+    // for backward compat with configs written before those had a
+    // discriminant; Gcp has no such pre-discriminant format to preserve, and
+    // an optional type here would let `signerType` resolve to `undefined`,
+    // silently skipping the protocol-signer refinement below.
+    type: z.literal(AgentSignerKeyType.Gcp),
+    keyVersionName: z
+        .string()
+        .describe('The full GCP KMS CryptoKeyVersion resource name'),
+})
+    .describe('A GCP Cloud KMS signer. Note that GCP credentials (e.g. Workload Identity) must be available in the env separately.');
+const AgentSignerCosmosKeySchema = z
+    .object({
+    type: z.literal(AgentSignerKeyType.Cosmos),
+    prefix: z.string().describe('The bech32 prefix for the cosmos address'),
+    key: ZHash,
+})
+    .describe('Cosmos key');
+const AgentSignerRadixKeySchema = z
+    .object({
+    type: z.literal(AgentSignerKeyType.Radix),
+    suffix: z.string().describe('The network suffix for the signer'),
+    key: ZHash,
+})
+    .describe('Radix key');
+const AgentSignerNodeSchema = z
+    .object({
+    type: z.literal(AgentSignerKeyType.Node),
+})
+    .describe('Assume the local node will sign on RPC calls automatically');
+const AgentSignerSchema = z.union([
+    AgentSignerHexKeySchema,
+    AgentSignerAwsKeySchema,
+    AgentSignerGcpKeySchema,
+    AgentSignerCosmosKeySchema,
+    AgentSignerNodeSchema,
+    AgentSignerRadixKeySchema,
+]);
+// Additional chain metadata for Cosmos chains required by the agents.
+const AgentCosmosChainMetadataSchema = z.object({
+    canonicalAsset: z
+        .string()
+        .describe('The name of the canonical asset for this chain, usually in "micro" form, e.g. untrn'),
+    gasPrice: z.object({
+        denom: z
+            .string()
+            .describe('The coin denom, usually in "micro" form, e.g. untrn'),
+        amount: z
+            .string()
+            .regex(/^(\d*[.])?\d+$/)
+            .describe('The gas price, in denom, to pay for each unit of gas'),
+    }),
+    contractAddressBytes: z
+        .number()
+        .int()
+        .positive()
+        .lte(32)
+        .describe('The number of bytes used to represent a contract address.'),
+});
+const AgentSealevelChainMetadataSchema = z.object({
+    maxSupportedTransactionVersion: z
+        .union([z.literal(0), z.literal(1)])
+        .optional(),
+    priorityFeeOracle: z
+        .union([
+        z.object({
+            type: z.literal(AgentSealevelPriorityFeeOracleType.Helius),
+            url: z.string(),
+            // TODO add options
+            feeLevel: z.enum(AgentSealevelHeliusFeeLevel),
+        }),
+        z.object({
+            type: z.literal(AgentSealevelPriorityFeeOracleType.Constant),
+            // In microlamports
+            fee: ZUWei,
+        }),
+    ])
+        .optional(),
+    transactionSubmitter: z
+        .object({
+        type: z.enum(AgentSealevelTransactionSubmitterType),
+        url: z.string().optional(),
+    })
+        .optional(),
+    mailboxProcessAlt: z
+        .string()
+        .optional()
+        .describe('Legacy single ALT for Mailbox.process transactions.'),
+    mailboxProcessAlts: z
+        .array(z.string())
+        .min(1)
+        .optional()
+        .describe('ALTs used for Mailbox.process transactions, in compile order.'),
+    processAltOverrides: z
+        .union([
+        z.array(z.union([
+            z.object({
+                matchingList: MatchingListSchema,
+                addressLookupTables: z.array(z.string()).min(1),
+            }),
+            z.object({
+                matchingList: MatchingListSchema,
+                addressLookupTable: z.string(),
+                addressLookupTables: z.never().optional(),
+            }),
+        ])),
+        z.string().min(1),
+    ])
+        .optional()
+        .describe('Per-message ALT overrides. Accepts legacy addressLookupTable or plural addressLookupTables.'),
+    urReveal: z
+        .object({
+        ccsUrl: z
+            .url()
+            .refine((value) => {
+            try {
+                const url = new URL(value);
+                return (url.protocol === 'https:' &&
+                    !url.username &&
+                    !url.password &&
+                    !url.href.includes('?') &&
+                    !url.href.includes('#'));
+            }
+            catch {
+                return false;
+            }
+        }, 'CCS requires HTTPS without credentials, query, or fragment')
+            .describe('CCS endpoint for calldata lookup'),
+        programId: z
+            .string()
+            .refine((val) => {
+            try {
+                new PublicKey(val);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }, 'Must be a valid Solana public key (base58)')
+            .describe('Universal Router program ID (base58)'),
+    })
+        .optional()
+        .describe('When set, the relayer automatically submits RouterInstruction::Reveal after confirming delivery of a UR COMMIT message.'),
+});
+const CompiledAgentCosmosChainMetadataSchema = z.compile(AgentCosmosChainMetadataSchema);
+const CompiledAgentSealevelChainMetadataSchema = z.compile(AgentSealevelChainMetadataSchema);
+export const AgentChainMetadataSchema = ChainMetadataSchemaObject.extend(HyperlaneDeploymentArtifactsSchema.shape)
+    .extend({
+    customRpcUrls: z
+        .string()
+        .optional()
+        .describe('Specify a comma separated list of custom RPC URLs to use for this chain. If not specified, the default RPC urls will be used.'),
+    mevSubmission: z
+        .object({
+        rpcUrls: z.array(z.url({ protocol: /^https$/ })).nonempty(),
+        icaRouter: ZHash,
+        additionalIcaRouters: z.array(ZHash).optional(),
+    })
+        .optional()
+        .describe('EVM Lander only: submit matching messages exclusively through these protected endpoints. No public fallback.'),
+    additionalQuorumRpcUrls: z
+        .never()
+        .optional()
+        .describe('Removed. Move endpoints into rpcUrls/customRpcUrls and remove this setting.'),
+    customAdditionalQuorumRpcUrls: z
+        .never()
+        .optional()
+        .describe('Removed. Move endpoints into rpcUrls/customRpcUrls and remove this setting.'),
+    rpcConsensusType: z
+        .enum(RpcConsensusType)
+        .describe('RPC consensus policy. Validators default to majority for ceil(2N/3), with optional quorum for ceil(N/2) matching checkpoint histories across protocols. Majority is validator-only. Lightweight validators always require ceil(2N/3).')
+        .optional(),
+    fallbackHedgeDelayMillis: ZNzUint.optional().describe('For fallback RPC consensus, start one speculative immutable read on the next provider after this delay. Unset disables hedging.'),
+    fallbackHedgeTimeoutMillis: ZNzUint.optional().describe('Per-provider timeout for hedged immutable reads. Requires fallbackHedgeDelayMillis and defaults to 30000ms.'),
+    ccsSigner: z
+        .union([
+        AgentSignerHexKeySchema,
+        AgentSignerAwsKeySchema,
+        AgentSignerGcpKeySchema,
+    ])
+        .optional()
+        .describe('Optional EVM identity for CCS reads on Sealevel; omitting it disables automated UR reveals only.'),
+    signer: AgentSignerSchema.optional().describe('The signer to use for this chain'),
+    index: z
+        .object({
+        from: z
+            .number()
+            .int()
+            .optional()
+            .describe('The absolute block or sequence to start indexing from. Negative values are offsets from the current tip in the selected index mode unit.'),
+        chunk: ZNzUint.optional().describe('The number of blocks to index at a time.'),
+        mode: z
+            .enum(AgentIndexMode)
+            .optional()
+            .describe('The indexing method to use for this chain; will attempt to choose a suitable default if not specified.'),
+        interval: ZNzUint.optional().describe('How long to wait between polls when idle/caught up, in seconds. Defaults to 5s.'),
+    })
+        .optional(),
+})
+    .extend(AgentCosmosChainMetadataSchema.partial().shape)
+    .extend(AgentSealevelChainMetadataSchema.partial().shape)
+    .refine((metadata) => metadata.fallbackHedgeTimeoutMillis === undefined ||
+    metadata.fallbackHedgeDelayMillis !== undefined, {
+    message: 'fallbackHedgeTimeoutMillis requires fallbackHedgeDelayMillis',
+    path: ['fallbackHedgeTimeoutMillis'],
+})
+    .refine((metadata) => metadata.fallbackHedgeDelayMillis === undefined ||
+    metadata.protocol === ProtocolType.Ethereum, {
+    message: 'fallback RPC hedging is only supported for Ethereum chains',
+    path: ['fallbackHedgeDelayMillis'],
+})
+    .refine((metadata) => metadata.fallbackHedgeDelayMillis === undefined ||
+    metadata.rpcConsensusType === RpcConsensusType.Fallback, {
+    message: 'fallback RPC hedging requires fallback RPC consensus',
+    path: ['fallbackHedgeDelayMillis'],
+})
+    .refine((metadata) => metadata.mevSubmission === undefined ||
+    metadata.protocol === ProtocolType.Ethereum, {
+    message: 'MEV submission is only supported for Ethereum chains',
+    path: ['mevSubmission'],
+})
+    .refine((metadata) => {
+    // Make sure that the signer is valid for the protocol
+    const signerType = metadata.signer?.type;
+    // If no signer is specified, no validation is needed
+    if (signerType === undefined) {
+        return true;
+    }
+    switch (metadata.protocol) {
+        case ProtocolType.Tron:
+        case ProtocolType.Ethereum:
+            if (![
+                AgentSignerKeyType.Hex,
+                AgentSignerKeyType.Aws,
+                AgentSignerKeyType.Node,
+                AgentSignerKeyType.Gcp,
+            ].includes(signerType)) {
+                return false;
+            }
+            break;
+        case ProtocolType.Cosmos:
+        case ProtocolType.CosmosNative:
+            if (![AgentSignerKeyType.Cosmos].includes(signerType)) {
+                return false;
+            }
+            break;
+        case ProtocolType.Sealevel:
+            if (![AgentSignerKeyType.Hex].includes(signerType)) {
+                return false;
+            }
+            break;
+        default:
+        // Just accept it if we don't know the protocol
+    }
+    // If the protocol type is Cosmos, require everything in AgentCosmosChainMetadataSchema
+    if (metadata.protocol === ProtocolType.Cosmos ||
+        metadata.protocol === ProtocolType.CosmosNative) {
+        if (!z.validate(CompiledAgentCosmosChainMetadataSchema, metadata)) {
+            return false;
+        }
+    }
+    // If the protocol type is Sealevel, require everything in AgentSealevelChainMetadataSchema
+    if (metadata.protocol === ProtocolType.Sealevel) {
+        if (!z.validate(CompiledAgentSealevelChainMetadataSchema, metadata)) {
+            return false;
+        }
+    }
+    return true;
+});
+export const AgentConfigSchema = z.object({
+    metricsPort: ZNzUint.lte(65535)
+        .optional()
+        .describe('The port to expose prometheus metrics on. Accessible via `GET /metrics`.'),
+    chains: z
+        .record(z.string(), AgentChainMetadataSchema)
+        .describe('Chain metadata for all chains that the agent will index.')
+        .superRefine((data, ctx) => {
+        for (const c in data) {
+            if (c != data[c].name) {
+                ctx.addIssue({
+                    message: `Chain name ${c} does not match chain name in metadata ${data[c].name}`,
+                    code: z.ZodIssueCode.custom,
+                });
+            }
+        }
+    }),
+    defaultSigner: AgentSignerSchema.optional().describe('Default signer to use for any chains that have not defined their own.'),
+    log: z
+        .object({
+        format: z
+            .enum(AgentLogFormat)
+            .optional()
+            .describe('The format to use for tracing logs.'),
+        level: z
+            .enum(AgentLogLevel)
+            .optional()
+            .describe("The log level to use for the agent's logs."),
+    })
+        .optional(),
+});
+const CommaSeparatedChainList = z.string().regex(/^[a-z0-9]+(,[a-z0-9]+)*$/);
+const CommaSeparatedDomainList = z.string().regex(/^\d+(,\d+)*$/);
+export var GasPaymentEnforcementPolicyType;
+(function (GasPaymentEnforcementPolicyType) {
+    GasPaymentEnforcementPolicyType["None"] = "none";
+    GasPaymentEnforcementPolicyType["Minimum"] = "minimum";
+    GasPaymentEnforcementPolicyType["OnChainFeeQuoting"] = "onChainFeeQuoting";
+})(GasPaymentEnforcementPolicyType || (GasPaymentEnforcementPolicyType = {}));
+const GasPaymentEnforcementBaseSchema = z.object({
+    matchingList: MatchingListSchema.optional().describe('An optional matching list, any message that matches will use this policy. By default all messages will match.'),
+    feeToken: ZHash.optional().describe('The origin fee token that must have paid the IGP. The zero address, or unset, represents native tokens.'),
+});
+const GasPaymentEnforcementSchema = z.union([
+    GasPaymentEnforcementBaseSchema.extend({
+        type: z.literal(GasPaymentEnforcementPolicyType.None).optional(),
+    }),
+    GasPaymentEnforcementBaseSchema.extend({
+        type: z.literal(GasPaymentEnforcementPolicyType.Minimum).optional(),
+        payment: ZUWei,
+    }),
+    GasPaymentEnforcementBaseSchema.extend({
+        type: z.literal(GasPaymentEnforcementPolicyType.OnChainFeeQuoting),
+        gasFraction: z
+            .string()
+            .regex(/^\d+ ?\/ ?[1-9]\d*$/)
+            .optional(),
+    }),
+]);
+function feeTokenIsNonZero(feeToken) {
+    return !isEmptyAddress(feeToken);
+}
+function gasPaymentEnforcementPolicies(gasPaymentEnforcement) {
+    if (Array.isArray(gasPaymentEnforcement)) {
+        return { policies: gasPaymentEnforcement, parseError: false };
+    }
+    if (typeof gasPaymentEnforcement !== 'string') {
+        return { policies: undefined, parseError: false };
+    }
+    try {
+        const result = z
+            .array(GasPaymentEnforcementSchema)
+            .safeParse(JSON.parse(gasPaymentEnforcement));
+        return result.success
+            ? { policies: result.data, parseError: false }
+            : { policies: undefined, parseError: true };
+    }
+    catch {
+        return { policies: undefined, parseError: true };
+    }
+}
+const MetricAppContextSchema = z.object({
+    name: z.string().min(1),
+    matchingList: MatchingListSchema.describe('A matching list, any message that matches will be classified as this app context.'),
+});
+export var IsmCachePolicy;
+(function (IsmCachePolicy) {
+    IsmCachePolicy["MessageSpecific"] = "messageSpecific";
+    IsmCachePolicy["IsmSpecific"] = "ismSpecific";
+})(IsmCachePolicy || (IsmCachePolicy = {}));
+export var IsmCacheSelectorType;
+(function (IsmCacheSelectorType) {
+    IsmCacheSelectorType["DefaultIsm"] = "defaultIsm";
+    IsmCacheSelectorType["AppContext"] = "appContext";
+})(IsmCacheSelectorType || (IsmCacheSelectorType = {}));
+const IsmCacheSelector = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal(IsmCacheSelectorType.DefaultIsm),
+    }),
+    z.object({
+        type: z.literal(IsmCacheSelectorType.AppContext),
+        context: z.string(),
+    }),
+]);
+const IsmCacheConfigSchema = z.object({
+    selector: IsmCacheSelector.describe('The selector to use for the ISM cache policy'),
+    moduleTypes: z
+        .array(z.enum(ModuleType))
+        .describe('The ISM module types to use the cache policy for.'),
+    chains: z
+        .array(z.string())
+        .optional()
+        .describe('The chains to use the cache policy for. If not specified, all chains will be used.'),
+    cachePolicy: z.enum(IsmCachePolicy).describe('The cache policy to use.'),
+});
+export const RelayerAgentConfigSchema = AgentConfigSchema.extend({
+    db: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('The path to the relayer database.'),
+    relayChains: CommaSeparatedChainList.describe('Comma separated list of chains to relay messages between.'),
+    gasPaymentEnforcement: z
+        .union([z.array(GasPaymentEnforcementSchema), z.string().min(1)])
+        .optional()
+        .describe('The gas payment enforcement configuration as JSON. Expects an ordered array of `GasPaymentEnforcementConfig`.'),
+    whitelist: z
+        .union([MatchingListSchema, z.string().min(1)])
+        .optional()
+        .describe('If no whitelist is provided ALL messages will be considered on the whitelist.'),
+    blacklist: z
+        .union([MatchingListSchema, z.string().min(1)])
+        .optional()
+        .describe('If no blacklist is provided ALL will be considered to not be on the blacklist.'),
+    addressBlacklist: z
+        .string()
+        .optional()
+        .describe('Comma separated list of addresses to blacklist.'),
+    transactionGasLimit: ZUWei.optional().describe('This is optional. If not specified, any amount of gas will be valid, otherwise this is the max allowed gas in wei to relay a transaction.'),
+    skipTransactionGasLimitFor: CommaSeparatedDomainList.optional().describe('Comma separated List of chain names to skip applying the transaction gas limit to.'),
+    allowLocalCheckpointSyncers: z
+        .boolean()
+        .optional()
+        .describe('If true, allows local storage based checkpoint syncers. Not intended for production use.'),
+    metricAppContexts: z
+        .union([z.array(MetricAppContextSchema), z.string().min(1)])
+        .optional()
+        .describe('A list of app contexts and their matching lists to use for metrics. A message will be classified as the first matching app context.'),
+    ismCacheConfigs: z
+        .union([z.array(IsmCacheConfigSchema), z.string().min(1)])
+        .optional()
+        .describe('The ISM cache configs to be used. If not specified, default caching will be used.'),
+    allowContractCallCaching: z
+        .boolean()
+        .optional()
+        .describe('If true, allows caching of certain contract calls that can be appropriately cached.'),
+    txIdIndexingEnabled: z
+        .boolean()
+        .optional()
+        .describe('Whether to enable TX ID based indexing for hook events given indexed messages'),
+    igpIndexingEnabled: z
+        .boolean()
+        .optional()
+        .describe('Whether to enable IGP indexing'),
+    websocketUrl: z
+        .url()
+        .refine((value) => value.startsWith('ws://') || value.startsWith('wss://'), {
+        message: 'websocketUrl must use ws:// or wss://',
+    })
+        .optional()
+        .describe('Scraper-proxy WebSocket URL used for shared dispatch, Merkle, and gas-payment indexing.'),
+    websocketAuthorityEnabled: z
+        .boolean()
+        .optional()
+        .describe('Whether a healthy scraper-proxy stream may replace direct RPC indexing. Defaults to false.'),
+    relayApiEnabled: z
+        .boolean()
+        .optional()
+        .describe('Whether to enable the relay API HTTP server. Defaults to false.'),
+    relayApiPort: z
+        .number()
+        .int()
+        .positive()
+        .lte(65535)
+        .optional()
+        .describe('Port for the relay API HTTP server. When set, the relay API is served on this dedicated port instead of the shared metrics port.'),
+    relayApiRateLimitMaxRequests: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Relay API rate limit: max requests allowed per window. Defaults to 100.'),
+    relayApiRateLimitWindowSecs: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Relay API rate limit: window duration in seconds. Defaults to 60.'),
+    relayApiCorsOrigins: z
+        .string()
+        .optional()
+        .describe('Relay API allowed CORS origins, comma-separated. Defaults to https://nexus.hyperlane.xyz.'),
+}).superRefine((config, ctx) => {
+    if (config.websocketAuthorityEnabled && !config.websocketUrl) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['websocketUrl'],
+            message: 'websocketUrl is required when websocketAuthorityEnabled is true',
+        });
+    }
+    // Mirror the Rust relayer gate: the current IGP event does not expose the
+    // token address, so exact non-native `feeToken` enforcement is rejected.
+    const { policies, parseError } = gasPaymentEnforcementPolicies(config.gasPaymentEnforcement);
+    if (parseError) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['gasPaymentEnforcement'],
+            message: 'Invalid gasPaymentEnforcement JSON payload',
+        });
+        return;
+    }
+    if (!policies) {
+        return;
+    }
+    policies.forEach((policy, policyIndex) => {
+        if (!feeTokenIsNonZero(policy.feeToken)) {
+            return;
+        }
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['gasPaymentEnforcement', policyIndex, 'feeToken'],
+            message: '`feeToken` gas payment enforcement is not supported without token-aware IGP indexing; leave it unset and use onChainFeeQuoting for ERC20 IGP gas-amount sufficiency.',
+        });
+    });
+});
+export const ScraperAgentConfigSchema = AgentConfigSchema.extend({
+    db: z.string().min(1).describe('Database connection string'),
+    chainsToScrape: CommaSeparatedChainList.describe('Comma separated list of chain names to scrape'),
+    ccrRouters: z
+        .record(z.string(), z.record(z.string(), z.string()))
+        .optional()
+        .describe('Per-domain CCR router → underlying ERC20 token mapping. Domain ID → { router_address → token_address }. Auto-populated from registry.'),
+});
+export const ValidatorAgentConfigSchema = AgentConfigSchema.extend({
+    db: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('The path to the validator database.'),
+    originChainName: z
+        .string()
+        .min(1)
+        .describe('Name of the chain to validate messages on'),
+    validator: AgentSignerSchema.describe('The validator attestation signer'),
+    checkpointSyncer: z.discriminatedUnion('type', [
+        z
+            .object({
+            type: z.literal('localStorage'),
+            path: z.string().min(1).describe('Path to the local storage location'),
+        })
+            .describe('A local checkpoint syncer'),
+        z
+            .object({
+            type: z.literal('s3'),
+            bucket: z.string().min(1),
+            region: z.string().min(1),
+            folder: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('The folder/key-prefix to use, defaults to the root of the bucket'),
+        })
+            .describe('A checkpoint syncer that uses S3'),
+        z
+            .object({
+            type: z.literal('gcs'),
+            bucket: z.string().min(1),
+            folder: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('The folder to use, defaults to the root of the bucket'),
+            serviceAccountKey: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('The path to GCS service account key file'),
+            userSecrets: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('The path to GCS user secret file'),
+            useApplicationDefault: z
+                .boolean()
+                .optional()
+                .describe('Use ambient Application Default Credentials (e.g. GKE Workload Identity) instead of a key file or user secrets'),
+        })
+            .describe('A checkpoint syncer that uses Google Cloud Storage'),
+    ]),
+    interval: ZNzUint.optional().describe('How long to wait between checking for new checkpoints in seconds. Defaults to 2s, falling back to the origin chain’s index.interval if set and this is unset.'),
+    maxSignConcurrency: ZNzUint.max(MAX_SIGN_CONCURRENCY)
+        .optional()
+        .describe(`Maximum number of checkpoints signed concurrently. Defaults to 50; maximum ${MAX_SIGN_CONCURRENCY}.`),
+    lightweight: z
+        .boolean()
+        .optional()
+        .describe('Uses trusted websocket indexing and requires at least two thirds of configured state-read endpoints to match local roots. Signs through the highest index supported by that majority, independently of rpcConsensusType. Disables RPC indexing fallback; insufficient agreement pauses signing.'),
+    leightweigt: z.boolean().optional().describe('Alias for lightweight.'),
+    websocketUrl: z
+        .url()
+        .refine((url) => /^wss?:\/\//i.test(url), {
+        message: 'Must use ws:// or wss://',
+    })
+        .optional()
+        .describe('Merkle tree insertion source for replay and live events. RPC indexing fallback is disabled in lightweight mode.'),
+}).superRefine((config, ctx) => {
+    if (config.lightweight !== undefined &&
+        config.leightweigt !== undefined &&
+        config.lightweight !== config.leightweigt) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['lightweight'],
+            message: 'lightweight and leightweigt must agree when both are set',
+        });
+    }
+    if ((config.lightweight ?? config.leightweigt) && !config.websocketUrl) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['websocketUrl'],
+            message: 'websocketUrl is required in lightweight mode',
+        });
+    }
+});
+function formatAleoAddress(addresses) {
+    const [mailboxProgram, mailbox] = addresses.mailbox.split('/');
+    const interchainSecurityModule = addresses.interchainSecurityModule
+        ?.split('/')
+        .at(1);
+    const [hookManagerProgram, merkleTreeHook] = addresses.merkleTreeHook.split('/');
+    const interchainGasPaymaster = addresses.interchainGasPaymaster.split('/').at(1) ||
+        '0x0000000000000000000000000000000000000000';
+    const [validatorAnnounceProgram, validatorAnnounce] = addresses.validatorAnnounce.split('/');
+    const ismManagerProgram = mailboxProgram.replaceAll('mailbox', 'ism_manager');
+    return {
+        mailbox,
+        interchainSecurityModule,
+        merkleTreeHook,
+        interchainGasPaymaster,
+        validatorAnnounce,
+        mailboxProgram,
+        hookManagerProgram,
+        ismManagerProgram,
+        validatorAnnounceProgram,
+    };
+}
+// Note this works well for EVM chains only, and likely needs some love
+// before being useful for non-EVM chains.
+export function buildAgentConfig(chains, multiProvider, addresses, startBlocks, additionalConfig) {
+    const chainConfigs = {};
+    for (const chain of [...chains].sort()) {
+        const metadata = multiProvider.tryGetChainMetadata(chain);
+        // Cosmos Native chains have the correct gRPC URL format in the registry. So only delete the gRPC URL for legacy Cosmos chains.
+        if (metadata?.protocol === ProtocolType.Cosmos) {
+            // Note: the gRPC URL format in the registry lacks a correct http:// or https:// prefix at the moment,
+            // which is expected by the agents. For now, we intentionally skip this.
+            delete metadata.grpcUrls;
+        }
+        // Delete transaction overrides for all Cosmos chains.
+        if (metadata?.protocol === ProtocolType.Cosmos ||
+            metadata?.protocol === ProtocolType.CosmosNative) {
+            // The agents expect gasPrice.amount and gasPrice.denom and ignore the transaction overrides.
+            // To reduce confusion when looking at the config, we remove the transaction overrides.
+            delete metadata.transactionOverrides;
+        }
+        const coreAddresses = metadata?.protocol == ProtocolType.Aleo
+            ? formatAleoAddress(addresses[chain])
+            : addresses[chain];
+        const chainConfig = {
+            ...metadata,
+            ...coreAddresses,
+            ...(additionalConfig ? additionalConfig[chain] : {}),
+            ...(startBlocks[chain] !== undefined && {
+                index: {
+                    from: startBlocks[chain],
+                },
+            }),
+        };
+        chainConfigs[chain] = chainConfig;
+    }
+    return {
+        chains: chainConfigs,
+    };
+}
+//# sourceMappingURL=agentConfig.js.map