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

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>

package/src/config/actors/Bridge.ts

@@ -1,136 +0,0 @@
-import {
-  AddressZod, HexZod, toAddress, toHex,
-} from '@xylabs/sdk-js'
-import type { ChainId } from '@xyo-network/xl1-protocol'
-import { AttoXL1ConvertFactor, XL1 } from '@xyo-network/xl1-protocol'
-import { globalRegistry, z } from 'zod'
-
-import { MnemonicStringZod } from '../../validation/index.ts'
-import { BaseConfigZod } from '../Base.ts'
-
-const DEFAULT_FIXED_FEE = toHex(XL1(1n) * AttoXL1ConvertFactor.xl1)
-const DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress('2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6')
-const DEFAULT_HARDHAT_CHAIN_ID: ChainId = toHex('7A69')
-const DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80')
-const DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress('5FbDB2315678afecb367f032d93F642f64180aa3')
-const DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(100_000n) * AttoXL1ConvertFactor.xl1)
-const DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(10n) * AttoXL1ConvertFactor.xl1)
-
-export const BasisPointsZod = z.coerce.number().int().nonnegative().max(10_000)
-export type BasisPoints = z.infer<typeof BasisPointsZod>
-
-export const BridgeConfigZod = BaseConfigZod.extend(z.object({
-  escrowAddress: AddressZod.optional().register(globalRegistry, {
-    description: 'Address to which bridge escrow will be sent',
-    title: 'bridge.escrowAddress',
-    type: 'string',
-  }),
-  feesAddress: AddressZod.optional().register(globalRegistry, {
-    description: 'Address to which bridge fees will be sent',
-    title: 'bridge.feesAddress',
-    type: 'string',
-  }),
-  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry, {
-    default: DEFAULT_FIXED_FEE,
-    description: 'Fixed fee (in AttoXL1) applied to bridge transfers',
-    title: 'bridge.feeFixed',
-    type: 'bigint',
-  }),
-  feeRateBasisPoints: BasisPointsZod.default(500).register(globalRegistry, {
-    default: 500,
-    description: 'Variable rate fee (in basis points where 1 bps = 0.01%) applied to bridge transfers',
-    title: 'bridge.feeRateBasisPoints',
-    type: 'number',
-  }),
-  host: z.string().default('localhost').register(globalRegistry, {
-    default: 'localhost',
-    description: 'Host for the Bridge',
-    title: 'bridge.host',
-    type: 'string',
-  }),
-  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry, {
-    default: DEFAULT_MAX_BRIDGE_AMOUNT,
-    description: 'Maximum amount allowed for a bridge transfer',
-    title: 'bridge.maxBridgeAmount',
-    type: 'string',
-  }),
-  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry, {
-    default: DEFAULT_MIN_BRIDGE_AMOUNT,
-    description: 'Minimum amount required for a bridge transfer',
-    title: 'bridge.minBridgeAmount',
-    type: 'string',
-  }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
-    description: 'Mnemonic for the Bridge wallet',
-    title: 'bridge.mnemonic',
-    type: 'string',
-  }),
-  port: z.coerce.number().int().positive().default(8081).register(globalRegistry, {
-    default: 8081,
-    description: 'Port for the Bridge',
-    title: 'bridge.port',
-    type: 'number',
-  }),
-  redisHost: z.string().default('localhost').register(globalRegistry, {
-    default: 'localhost',
-    description: 'Host for the Bridge Redis instance',
-    title: 'bridge.redisHost',
-    type: 'string',
-  }),
-  redisPort: z.coerce.number().int().positive().default(6379).register(globalRegistry, {
-    default: 6379,
-    description: 'Port for the Bridge Redis instance',
-    title: 'bridge.redisPort',
-    type: 'number',
-  }),
-  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry, {
-    default: DEFAULT_HARDHAT_BRIDGE_CONTRACT,
-    description: 'Hex representation of remote token address used for bridging',
-    title: 'bridge.remoteBridgeContractAddress',
-    type: 'string',
-  }),
-  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry, {
-    default: DEFAULT_HARDHAT_CHAIN_ID,
-    description: 'Remote chain ID',
-    title: 'bridge.remoteChainId',
-    type: 'string',
-  }),
-  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry, {
-    default: DEFAULT_HARDHAT_TOKEN_CONTRACT,
-    description: 'Hex representation of remote token address used for bridging',
-    title: 'bridge.remoteTokenAddress',
-    type: 'string',
-  }),
-  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry, {
-    description: 'Private key for the wallet to use for the remote chain wallet',
-    title: 'bridge.remoteChainWalletPrivateKey',
-    type: 'string',
-  }),
-  xl1ChainId: HexZod.optional().register(globalRegistry, {
-    description: 'XL1 chain id used for bridging',
-    title: 'bridge.xl1ChainId',
-    type: 'string',
-  }),
-  xl1TokenAddress: HexZod.optional().register(globalRegistry, {
-    description: 'XL1 token address used for bridging',
-    title: 'bridge.xl1TokenAddress',
-    type: 'string',
-  }),
-}).shape)
-
-export type BridgeConfig = z.infer<typeof BridgeConfigZod>
-
-export const BridgeSettingsZod = BridgeConfigZod.pick({
-  feeFixed: true,
-  feeRateBasisPoints: true,
-  feesAddress: true,
-  escrowAddress: true,
-  maxBridgeAmount: true,
-  minBridgeAmount: true,
-  remoteChainId: true,
-  remoteTokenAddress: true,
-  xl1TokenAddress: true,
-  xl1ChainId: true,
-}).required()
-
-export type BridgeSettings = z.infer<typeof BridgeSettingsZod>

package/src/config/actors/Mempool.ts

@@ -1,43 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-import { MnemonicStringZod } from '../../validation/index.ts'
-import { BaseConfigZod } from '../Base.ts'
-
-export const MempoolConfigZod = BaseConfigZod.extend(z.object({
-  enabled: z.union([z.string(), z.boolean()]).default('false').transform((val, ctx) => {
-    if (typeof val === 'boolean') return val
-    const normalized = val.toLowerCase().trim()
-    if (['true', '1', 'yes', 'on'].includes(normalized)) return true
-    if (['false', '0', 'no', 'off'].includes(normalized)) return false
-    ctx.addIssue({
-      code: 'invalid_type',
-      expected: 'boolean',
-      message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`,
-    })
-    return z.NEVER
-  }).register(globalRegistry, {
-    default: 'false',
-    description: 'Enable the Mempool',
-    title: 'mempool.enabled',
-    type: 'boolean',
-  }),
-  host: z.string().default('localhost').register(globalRegistry, {
-    default: 'localhost',
-    description: 'Host for the Mempool',
-    title: 'mempool.host',
-    type: 'string',
-  }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
-    description: 'Mnemonic for the Mempool wallet',
-    title: 'mempool.mnemonic',
-    type: 'string',
-  }),
-  port: z.coerce.number().default(8083).register(globalRegistry, {
-    default: 8083,
-    description: 'Port for the Mempool',
-    title: 'mempool.port',
-    type: 'number',
-  }),
-}).shape)
-
-export type MempoolConfig = z.infer<typeof MempoolConfigZod>

package/src/config/actors/Producer.ts

@@ -1,61 +0,0 @@
-import { AddressZod, asAddress } from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
-
-import { MnemonicStringZod } from '../../validation/index.ts'
-import { BaseConfigZod } from '../Base.ts'
-
-export const ProducerConfigZod = BaseConfigZod.extend(z.object({
-  allowlist: z.preprocess((val) => {
-    if (typeof val === 'string') {
-      return val.split(',').map(s => asAddress(s.trim()))
-    }
-    return val
-  }, z.array(AddressZod).optional().register(globalRegistry, {
-    description: 'List of allowed producer addresses, if undefined anyone can participate',
-    title: 'allowlist',
-    type: 'array',
-  })),
-
-  disableIntentRedeclaration: z.boolean().optional().register(globalRegistry, {
-    description: 'Should the producer skip redeclaring their intent to continue producing blocks',
-    title: 'producer.disableIntentRedeclaration',
-    type: 'boolean',
-  }),
-  // TODO: Port schema
-  healthCheckPort: z.coerce.number().optional().register(globalRegistry, {
-    description: 'Port for the Producer health checks',
-    title: 'producer.healthCheckPort',
-    type: 'number',
-  }),
-  heartbeatInterval: z.coerce.number().default(3_600_000).register(globalRegistry, {
-    description: 'The number of milliseconds between heartbeats if no blocks are produced',
-    title: 'producer.heartbeatInterval',
-    type: 'number',
-  }),
-  // TODO: BigInt schema
-  minStake: z.coerce.number().default(1).register(globalRegistry, {
-    description: 'Minimum stake required to be a Producer',
-    title: 'producer.minStake',
-    type: 'number',
-  }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
-    description: 'Mnemonic for the Producer wallet',
-    title: 'producer.mnemonic',
-    type: 'string',
-  }),
-  // TODO: Port schema
-  port: z.coerce.number().default(8081).register(globalRegistry, {
-    default: 8081,
-    description: 'Port for the Producer',
-    title: 'producer.port',
-    type: 'number',
-  }),
-  // TODO: Address schema
-  rewardAddress: z.string().optional().register(globalRegistry, {
-    description: 'Address to receive block rewards',
-    title: 'producer.rewardAddress',
-    type: 'string',
-  }),
-}).shape)
-
-export type ProducerConfig = z.infer<typeof ProducerConfigZod>

package/src/config/actors/RewardRedemption.ts

@@ -1,26 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-import { MnemonicStringZod } from '../../validation/index.ts'
-import { BaseConfigZod } from '../Base.ts'
-
-export const RewardRedemptionConfigZod = BaseConfigZod.extend(z.object({
-  host: z.string().default('localhost').register(globalRegistry, {
-    default: 'localhost',
-    description: 'Host for the Redemption API',
-    title: 'rewardRedemptionApi.host',
-    type: 'string',
-  }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
-    description: 'Mnemonic for the Redemption API wallet',
-    title: 'rewardRedemptionApi.mnemonic',
-    type: 'string',
-  }),
-  port: z.coerce.number().default(8082).register(globalRegistry, {
-    default: 8082,
-    description: 'Port for the Redemption API',
-    title: 'rewardRedemptionApi.port',
-    type: 'number',
-  }),
-}).shape)
-
-export type RewardRedemptionConfig = z.infer<typeof RewardRedemptionConfigZod>

package/src/config/actors/index.ts

@@ -1,6 +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'