@xyo-network/xl1-cli-lib 1.16.7 → 1.16.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/xl1-cli-lib",
-  "version": "1.16.7",
+  "version": "1.16.9",
   "description": "XYO Layer One CLI Library",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -55,19 +55,19 @@
     "@xyo-network/archivist-lmdb": "~5.1.21",
     "@xyo-network/archivist-memory": "~5.1.21",
     "@xyo-network/archivist-model": "~5.1.21",
-    "@xyo-network/chain-api": "~1.16.7",
-    "@xyo-network/chain-bridge": "~1.16.7",
-    "@xyo-network/chain-mempool": "~1.16.7",
-    "@xyo-network/chain-reward-redemption": "~1.16.7",
-    "@xyo-network/chain-sdk": "~1.16.7",
-    "@xyo-network/chain-services": "~1.16.7",
+    "@xyo-network/chain-api": "~1.16.9",
+    "@xyo-network/chain-bridge": "~1.16.9",
+    "@xyo-network/chain-mempool": "~1.16.9",
+    "@xyo-network/chain-reward-redemption": "~1.16.9",
+    "@xyo-network/chain-sdk": "~1.16.9",
+    "@xyo-network/chain-services": "~1.16.9",
     "@xyo-network/payload-builder": "~5.1.21",
     "@xyo-network/payload-model": "~5.1.21",
     "@xyo-network/wallet": "~5.1.21",
     "@xyo-network/wallet-model": "~5.1.21",
     "@xyo-network/xl1-protocol": "~1.13.6",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.7",
-    "@xyo-network/xl1-validation": "~1.16.7",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.9",
+    "@xyo-network/xl1-validation": "~1.16.9",
     "async-mutex": "~0.5.0",
     "cosmiconfig": "~9.0.0",
     "dotenv": "~17.2.3",
@@ -80,7 +80,7 @@
     "@xylabs/tsconfig": "~7.2.8",
     "@xylabs/vitest-extended": "~5.0.24",
     "@xyo-network/account-model": "~5.1.21",
-    "@xyo-network/chain-test": "~1.16.7",
+    "@xyo-network/chain-test": "~1.16.9",
     "eslint": "^9.39.1",
     "lmdb": "~3.4.4",
     "nodemon": "~3.1.11",

package/src/orchestration/services/implementation/chain/evm.ts

@@ -14,12 +14,12 @@ import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
 
 let chainStakeServiceSingleton: Promisable<EvmChainService> | undefined
 
-export const canUseEvmContractChainService = (config: Config) => {
+export const canUseEvmContractChainService = (config: Pick<Config, 'chain' | 'evm'>) => {
   const { id } = config.chain
   return isDefined(id) && id !== ZERO_ADDRESS && canUseEvmProvider({ config })
 }
 
-export const initEvmContractChainService: Initializable<BaseAccountableServiceParams, EvmChainService> = async ({
+export const initEvmContractChainService: Initializable<BaseAccountableServiceParams<Pick<Config, 'chain' | 'evm'>>, EvmChainService> = async ({
   account, config, traceProvider, meterProvider, logger,
 }) => {
   if (chainStakeServiceSingleton) return chainStakeServiceSingleton

package/src/orchestration/services/implementation/chain/index.ts

@@ -3,16 +3,18 @@ import type { Promisable } from '@xylabs/promise'
 import { type BaseAccountableServiceParams, MemoryChainService } from '@xyo-network/chain-services'
 import type { Initializable } from '@xyo-network/xl1-protocol'
 import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+import type { Config } from 'cosmiconfig'
 
 import { canUseEvmContractChainService, initEvmContractChainService } from './evm.ts'
 
 let chainStakeServiceSingleton: Promisable<ChainService> | undefined
 
-export const initChainService: Initializable<BaseAccountableServiceParams, ChainService> = ({ account, config }) => init({
+export const initChainService: Initializable<BaseAccountableServiceParams<Pick<Config, 'chain' | 'evm' | 'producer'>>,
+  ChainService> = ({ account, config }) => init({
   config, name: 'ChainService' as CreatableName, account,
 })
 
-const init: Initializable<BaseAccountableServiceParams, ChainService> = (params): Promisable<ChainService> => {
+const init: Initializable<BaseAccountableServiceParams<Pick<Config, 'chain' | 'evm' | 'producer'>>, ChainService> = (params): Promisable<ChainService> => {
   if (chainStakeServiceSingleton) return chainStakeServiceSingleton
   const { config } = params
   chainStakeServiceSingleton = canUseEvmContractChainService(config)

package/src/orchestration/services/implementation/evm/initChainId.ts

@@ -3,11 +3,11 @@ import { hexFrom, isHex } from '@xylabs/hex'
 import { isDefined } from '@xylabs/typeof'
 import type { Config } from '@xyo-network/xl1-protocol-sdk'
 
-export const canUseChainId = (config: Config): boolean => {
+export const canUseChainId = (config: Pick<Config, 'evm'>): boolean => {
   return isDefined(config.evm.chainId)
 }
 
-export const getChainId = (config: Config) => {
+export const getChainId = (config: Pick<Config, 'evm'>) => {
   const chainId = assertEx(config.evm.chainId, () => 'Missing config.evm.chainId')
   if (isHex(chainId, { prefix: true })) {
     const hex = hexFrom(chainId)

package/src/orchestration/services/implementation/evm/initEvmProvider.ts

@@ -9,7 +9,7 @@ import { canUseJsonRpcProvider, initJsonRpcProvider } from './initJsonRpcProvide
 
 let provider: Promise<JsonRpcProvider> | undefined
 
-export const initEvmProvider = async ({ config }: { config: Config; logger?: Logger }): Promise<Provider> => {
+export const initEvmProvider = async ({ config }: { config: Pick<Config, 'evm'>; logger?: Logger }): Promise<Provider> => {
   if (provider) return provider
   if (canUseInfuraProvider(config)) {
     provider = initInfuraProvider(config)
@@ -19,6 +19,6 @@ export const initEvmProvider = async ({ config }: { config: Config; logger?: Log
   return assertEx(await provider, () => 'Error: No provider available')
 }
 
-export const canUseEvmProvider = ({ config }: { config: Config }) => {
+export const canUseEvmProvider = ({ config }: { config: Pick<Config, 'evm'> }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config)
 }

package/src/orchestration/services/implementation/evm/initInfuraProvider.ts

@@ -7,20 +7,20 @@ import { canUseChainId, getChainId } from './initChainId.ts'
 
 let instance: Promise<InfuraProvider> | undefined
 
-export const initInfuraProvider = (config: Config) => {
+export const initInfuraProvider = (config: Pick<Config, 'evm'>) => {
   if (instance) return instance
   const providerConfig = getInfuraProviderConfig(config)
   instance = Promise.resolve(new InfuraProvider(...providerConfig))
   return instance
 }
 
-export const canUseInfuraProvider = (config: Config): boolean => {
+export const canUseInfuraProvider = (config: Pick<Config, 'evm'>): boolean => {
   return canUseChainId(config)
     && isDefined(config.evm?.infura?.projectId)
     && isDefined(config.evm?.infura?.projectSecret)
 }
 
-export const getInfuraProviderConfig = (config: Config) => {
+export const getInfuraProviderConfig = (config: Pick<Config, 'evm'>) => {
   const projectId = assertEx(config.evm?.infura?.projectId, () => 'Missing config.evm.infura.projectId')
   const projectSecret = assertEx(config.evm?.infura?.projectSecret, () => 'Missing config.evm.infura.projectSecret')
   return [getChainId(config), projectId, projectSecret] as const

package/src/orchestration/services/implementation/evm/initJsonRpcProvider.ts

@@ -5,17 +5,17 @@ import { JsonRpcProvider } from 'ethers/providers'
 
 import { canUseChainId, getChainId } from './initChainId.ts'
 
-export const initJsonRpcProvider = (config: Config) => {
+export const initJsonRpcProvider = (config: Pick<Config, 'evm'>) => {
   const providerConfig = getJsonRpcProviderConfig(config)
   return Promise.resolve(new JsonRpcProvider(...providerConfig))
 }
 
-export const canUseJsonRpcProvider = (config: Config) => {
+export const canUseJsonRpcProvider = (config: Pick<Config, 'evm'>) => {
   return canUseChainId(config)
     && isDefined(config.evm.jsonRpc?.url)
 }
 
-export const getJsonRpcProviderConfig = (config: Config) => {
+export const getJsonRpcProviderConfig = (config: Pick<Config, 'evm'>) => {
   const jsonRpcUrl = assertEx(config.evm.jsonRpc?.url, () => 'Missing config.evm.jsonRpc.url')
   return [jsonRpcUrl, getChainId(config)] as const
 }

package/src/orchestration/services/implementation/reward.ts

@@ -10,7 +10,7 @@ import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
 let rewardServiceSingleton: Promise<BlockRewardService> | undefined
 
 export const initBlockRewardService: Initializable<
-  BaseBlockRewardServiceParams | EvmBlockRewardServiceParams,
+  BaseBlockRewardServiceParams<Pick<Config, 'evm'>> | EvmBlockRewardServiceParams,
   BlockRewardService
 > = (params): Promise<BlockRewardService> => {
   if (rewardServiceSingleton) return rewardServiceSingleton
@@ -27,7 +27,7 @@ const initXyoBlockRewardService = (params: BaseBlockRewardServiceParams): Promis
   return rewardServiceSingleton
 }
 
-const canUseEvmBlockRewardService = (params: { config: Config }) => canUseEvmProvider({ config: params.config })
+const canUseEvmBlockRewardService = (params: { config: Pick<Config, 'evm'> }) => canUseEvmProvider({ config: params.config })
 
 const initEvmBlockRewardService = async (params: EvmBlockRewardServiceParams): Promise<BlockRewardService> => {
   if (rewardServiceSingleton) return rewardServiceSingleton

package/src/orchestration/services/implementation/time.ts

@@ -1,13 +1,14 @@
 import type { Promisable } from '@xylabs/promise'
 import { type BaseTimeServiceParams, BaseTimeSyncService } from '@xyo-network/chain-services'
 import type { Initializable } from '@xyo-network/xl1-protocol'
-import type { TimeSyncService } from '@xyo-network/xl1-protocol-sdk'
+import type { TimeSyncViewer } from '@xyo-network/xl1-protocol-sdk'
+import type { Config } from 'cosmiconfig'
 
 import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
 
-let timeSyncServiceSingleton: Promisable<TimeSyncService> | undefined
+let timeSyncServiceSingleton: Promisable<TimeSyncViewer> | undefined
 
-export const initTimeService: Initializable<BaseTimeServiceParams, TimeSyncService> = async ({
+export const initTimeService: Initializable<BaseTimeServiceParams<Pick<Config, 'evm'>>, TimeSyncViewer> = async ({
   chainArchivist, chainIterator, config, logger, meterProvider, traceProvider,
 }) => {
   if (timeSyncServiceSingleton) return timeSyncServiceSingleton