@xyo-network/chain-services 1.17.0 → 1.17.1

package/src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts

@@ -21,74 +21,74 @@ export interface BaseNetworkStakeStepRewardServiceParams extends BaseServicePara
 @creatable()
 export class BaseNetworkStakeStepRewardService extends BaseService<BaseNetworkStakeStepRewardServiceParams> implements NetworkStakeStepRewardService {
   networkStakeStepRewardAddressHistory(_address: Address): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardAddressHistory] not implemented.')
   }
 
   networkStakeStepRewardAddressReward(_context: StepIdentity, _address: Address): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardAddressReward] not implemented.')
   }
 
   networkStakeStepRewardAddressShare(_context: StepIdentity, _address: Address): Promisable<[bigint, bigint]> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardAddressShare] not implemented.')
   }
 
   networkStakeStepRewardClaimedByAddress(_address: Address): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardClaimedByAddress] not implemented.')
   }
 
   networkStakeStepRewardForPosition(_position: number, _range: [number, number]): Promisable<[bigint, bigint]> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardForPosition] not implemented.')
   }
 
   networkStakeStepRewardForStep(_context: StepIdentity): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardForStep] not implemented.')
   }
 
   networkStakeStepRewardForStepForPosition(_context: StepIdentity, _position: number): Promisable<[bigint, bigint]> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardForStepForPosition] not implemented.')
   }
 
   networkStakeStepRewardPoolRewards(_context: StepIdentity): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardPoolRewards] not implemented.')
   }
 
   networkStakeStepRewardPoolShares(_context: StepIdentity): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardPoolShares] not implemented.')
   }
 
   networkStakeStepRewardPositionWeight(_context: StepIdentity, _position: number): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardPositionWeight] not implemented.')
   }
 
   networkStakeStepRewardPotentialPositionLoss(_context: StepIdentity, _position: number): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardPotentialPositionLoss] not implemented.')
   }
 
   networkStakeStepRewardRandomizer(_context: StepIdentity): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardRandomizer] not implemented.')
   }
 
   networkStakeStepRewardStakerCount(_context: StepIdentity): Promisable<number> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardStakerCount] not implemented.')
   }
 
   networkStakeStepRewardUnclaimedByAddress(_address: Address): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardUnclaimedByAddress] not implemented.')
   }
 
   networkStakeStepRewardWeightForAddress(_context: StepIdentity, _address: Address): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardWeightForAddress] not implemented.')
   }
 
   networkStakeStepRewardsForPosition(_position: number, _range: [number, number]): Promisable<Record<StepIdentityString, [bigint, bigint]>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardsForPosition] not implemented.')
   }
 
   networkStakeStepRewardsForRange(_range: [number, number]): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardsForRange] not implemented.')
   }
 
   networkStakeStepRewardsForStepLevel(_stepLevel: number, _range: [number, number]): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardsForStepLevel] not implemented.')
   }
 }

package/src/PendingTransactions/BasePendingTransactions.ts

@@ -12,12 +12,13 @@ import {
 } from '@xyo-network/payload-model'
 import {
   asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, ChainId, HydratedTransactionValidationFunction, isTransactionBoundWitnessWithStorageMeta,
+  SignedHydratedBlockWithHashMeta,
   SignedHydratedTransactionWithHashMeta,
   SignedHydratedTransactionWithStorageMeta,
   XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
 import {
-  findMostRecentBlock, MempoolViewer, PendingTransactionsOptions,
+  findMostRecentBlock, MempoolViewer, PendingBlocksOptions, PendingTransactionsOptions,
 } from '@xyo-network/xl1-protocol-sdk'
 import { TransactionJsonSchemaValidator, validateTransaction } from '@xyo-network/xl1-validation'
 import { Mutex } from 'async-mutex'
@@ -29,10 +30,10 @@ import { hydratedTransactionToPayloadBundle } from './hydratedTransactionToPaylo
 
 export interface BasePendingTransactionsServiceParams extends BaseServiceParams {
   additionalPendingTransactionValidators?: HydratedTransactionValidationFunction[]
-  chainArchivist?: ArchivistInstance
-  chainId?: ChainId
-  pendingBundledTransactionsArchivist?: ArchivistInstance
-  rejectedTransactionsArchivist?: ArchivistInstance
+  chainArchivist: ArchivistInstance
+  chainId: ChainId
+  pendingBundledTransactionsArchivist: ArchivistInstance
+  rejectedTransactionsArchivist: ArchivistInstance
 }
 
 @creatable()
@@ -143,6 +144,10 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
     })
   }
 
+  pendingBlocks(_options?: PendingBlocksOptions): Promise<SignedHydratedBlockWithHashMeta[]> {
+    throw new Error('Method [pendingBlocks] not implemented.')
+  }
+
   async pendingTransactions({ limit = 100 }: PendingTransactionsOptions = {}): Promise<SignedHydratedTransactionWithStorageMeta[]> {
     return await this.spanAsync('getPendingTransactions', async () => {
     // Acquires an exclusive mutex to ensure no race conditions while accessing pending transactions.

package/src/Schemas/BaseSchemasService.ts

@@ -22,7 +22,7 @@ export class BaseSchemasService extends BaseService<BaseSchemasServiceParams> im
 
   async schemas(head: Hash, schemas: Schema[]): Promise<Partial<Record<Schema, number>>> {
     return await spanRootAsync('transfers', async () => {
-      const summary = await schemasSummary(this.params.context)
+      const [summary] = await schemasSummary(this.params.context)
       const result: Record<Schema, number> = {}
       for (const schema of schemas) {
         const count = summary[schema] ?? 0

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -34,10 +34,10 @@ import { BaseService } from '../BaseService.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
 export interface XyoStakeIntentServiceParams extends BaseServiceParams<Pick<Config, 'producer'>> {
-  blockViewer?: BlockViewer
-  chainArchivist?: ArchivistInstance
-  chainStakeViewer?: ChainStakeViewer
-  stakeIntentStateArchivist?: ArchivistInstance
+  blockViewer: BlockViewer
+  chainArchivist: ArchivistInstance
+  chainStakeViewer: ChainStakeViewer
+  stakeIntentStateArchivist: ArchivistInstance
 }
 
 /**
@@ -66,19 +66,29 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
   protected _updateMutex = new Mutex()
 
   protected get blockViewer() {
-    return assertEx(this.params.blockViewer, () => 'blockViewer not set')
+    return this.params.blockViewer
   }
 
   protected get chainArchivist() {
-    return assertEx(this.params.chainArchivist, () => 'chainArchivist not set')
+    return assertEx(this.params.chainArchivist!, () => 'chainArchivist not set')
   }
 
   protected get chainStakeViewer() {
-    return assertEx(this.params.chainStakeViewer, () => 'chainStakeViewer not set')
+    return assertEx(this.params.chainStakeViewer!, () => 'chainStakeViewer not set')
   }
 
   protected get stakeIntentStateArchivist() {
-    return assertEx(this.params.stakeIntentStateArchivist, () => 'stakeIntentStateArchivist not set')
+    return assertEx(this.params.stakeIntentStateArchivist!, () => 'stakeIntentStateArchivist not set')
+  }
+
+  static override async paramsHandler(params?: Partial<XyoStakeIntentServiceParams>): Promise<XyoStakeIntentServiceParams> {
+    return {
+      ...await super.paramsHandler(params),
+      blockViewer: assertEx(params?.blockViewer, () => 'blockViewer is required'),
+      chainArchivist: assertEx(params?.chainArchivist, () => 'chainArchivist is required'),
+      chainStakeViewer: assertEx(params?.chainStakeViewer, () => 'chainStakeViewer is required'),
+      stakeIntentStateArchivist: assertEx(params?.stakeIntentStateArchivist, () => 'stakeIntentStateArchivist is required'),
+    } as XyoStakeIntentServiceParams
   }
 
   override async createHandler() {

package/src/StepStake/BaseStepStakeService.ts

@@ -15,10 +15,10 @@ export interface BaseStepStakeServiceParams extends BaseServiceParams {
 @creatable()
 export class BaseStepStakeService extends BaseService<BaseStepStakeServiceParams> implements StepStakeViewer {
   stepStake(_step: StepIdentity): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [stepStake] not implemented.')
   }
 
   stepStakeForAddress(_address: Address, _step: StepIdentity): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [stepStakeForAddress] not implemented.')
   }
 }

package/src/blockViewerFromChainIteratorAndArchivist.ts

@@ -1,7 +1,8 @@
-import type { Hash } from '@xylabs/sdk-js'
+import type { Hash, Promisable } from '@xylabs/sdk-js'
 import { isDefined } from '@xylabs/sdk-js'
 import type { ReadArchivist } from '@xyo-network/archivist-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 import type {
   SignedHydratedBlockWithHashMeta,
   XL1BlockNumber,
@@ -68,6 +69,12 @@ export function blockViewerFromChainIteratorAndArchivist(
       const head = await chainIterator.head()
       return head.block
     },
+    payloadByHash: function (_hash: Hash): Promisable<WithHashMeta<Payload> | null> {
+      throw new Error('Function not implemented.')
+    },
+    payloadsByHash: function (_hashes: Hash[]): Promisable<WithHashMeta<Payload>[]> {
+      throw new Error('Function not implemented.')
+    },
   } satisfies BlockViewer
   return result
 }

package/src/implementation/accountBalance.ts

@@ -0,0 +1,29 @@
+import { isDefined, type Promisable } from '@xylabs/sdk-js'
+import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
+import type { AccountBalanceViewer, Config } from '@xyo-network/xl1-protocol-sdk'
+import {
+  AccountBalanceViewerRpcSchemas,
+  HttpRpcTransport,
+  JsonRpcAccountBalanceViewer,
+} from '@xyo-network/xl1-rpc'
+
+let balanceServiceSingleton: Promisable<AccountBalanceViewer> | undefined
+
+export type InitAccountBalanceServiceParams = InitializableParams<{
+  config: Config
+}>
+
+export const initAccountBalanceService: Initializable<InitAccountBalanceServiceParams, AccountBalanceViewer>
+  = (params): Promisable<AccountBalanceViewer> => {
+    const { config, logger } = params
+    if (balanceServiceSingleton) return balanceServiceSingleton
+    const endpoint = config.services?.accountBalanceViewerEndpoint ?? config.services?.apiEndpoint
+    if (isDefined(endpoint)) {
+      const transport = new HttpRpcTransport(endpoint, { ...AccountBalanceViewerRpcSchemas })
+      const viewer = new JsonRpcAccountBalanceViewer(transport)
+      logger?.log('Using AccountBalanceViewer RPC service at', endpoint)
+      return viewer
+    } else {
+      throw new Error('No AccountBalanceViewer endpoint configured')
+    }
+  }

package/src/implementation/blockViewer.ts

@@ -0,0 +1,29 @@
+import { isDefined, type Promisable } from '@xylabs/sdk-js'
+import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
+import type { BlockViewer, Config } from '@xyo-network/xl1-protocol-sdk'
+import {
+  BlockViewerRpcSchemas,
+  HttpRpcTransport,
+  JsonRpcBlockViewer,
+} from '@xyo-network/xl1-rpc'
+
+let blockViewerSingleton: Promisable<BlockViewer> | undefined
+
+export type InitBlockViewerParams = InitializableParams<{
+  config: Config
+}>
+
+export const initBlockViewer: Initializable<InitBlockViewerParams, BlockViewer>
+  = (params): Promisable<BlockViewer> => {
+    const { config, logger } = params
+    if (blockViewerSingleton) return blockViewerSingleton
+    const endpoint = config.services?.apiEndpoint
+    if (isDefined(endpoint)) {
+      const transport = new HttpRpcTransport(endpoint, { ...BlockViewerRpcSchemas })
+      const viewer = new JsonRpcBlockViewer(transport)
+      logger?.log('Using BlockViewer RPC service at', endpoint)
+      return viewer
+    } else {
+      throw new Error('No BlockViewer endpoint configured')
+    }
+  }

package/src/implementation/chain/evm.ts

@@ -0,0 +1,39 @@
+import type { Address, Promisable } from '@xylabs/sdk-js'
+import {
+  asAddress, assertEx, isDefined, ZERO_ADDRESS,
+} from '@xylabs/sdk-js'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import type { ContractRunner } from 'ethers'
+import { Wallet } from 'ethers/wallet'
+
+import { EvmChainService } from '../../ChainService/index.ts'
+import type { BaseAccountableServiceParams } from '../../model/index.ts'
+import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
+
+let chainStakeServiceSingleton: Promisable<EvmChainService> | undefined
+
+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<Pick<Config, 'chain' | 'evm'>>, EvmChainService> = async ({
+  account, config, traceProvider, meterProvider, logger,
+}) => {
+  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
+  // Parse config
+  const emvStakingContractAddress = assertEx(config.chain.id, () => 'config.chain.id is required')
+  // Configure ContractRunner
+  const id: Address = assertEx(asAddress(emvStakingContractAddress), () => 'config.chain.id is not a valid address')
+  const provider = assertEx(await initEvmProvider({ config }))
+  const privateKey = assertEx(account.private?.hex, () => 'Account does not have a private key')
+  const runner: ContractRunner = new Wallet(privateKey, provider)
+  // Create service
+  chainStakeServiceSingleton = EvmChainService.create({
+    id, runner, traceProvider, meterProvider, logger,
+  })
+  const result = await chainStakeServiceSingleton
+  await result.start()
+  return result
+}

package/src/implementation/chain/index.ts

@@ -0,0 +1,46 @@
+import {
+  assertEx, type CreatableName, type Promisable,
+} from '@xylabs/sdk-js'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+import type { Config } from 'cosmiconfig'
+
+import { MemoryChainService } from '../../ChainService/index.ts'
+import type { BaseAccountableServiceParams } from '../../model/index.ts'
+import { canUseEvmContractChainService, initEvmContractChainService } from './evm.ts'
+
+let chainStakeServiceSingleton: Promisable<ChainService> | undefined
+
+export const initChainService: Initializable<BaseAccountableServiceParams<
+  Pick<Config, 'chain' | 'evm' | 'producer'>>,
+ChainService> = ({
+  account, config, logger,
+}) => {
+  logger?.log('ChainService: Initializing...')
+  const result = init({
+    config, name: 'ChainService' as CreatableName, account,
+  })
+  logger?.log('ChainService: Initialized')
+  return result
+}
+
+export const initMemoryChainService: Initializable<BaseAccountableServiceParams<
+  Pick<Config, 'producer'>>, ChainService> = async ({ config }) => {
+  const result = await MemoryChainService.create({
+    config,
+    name: 'MemoryChainService' as CreatableName,
+  })
+  assertEx(await result.start(), () => 'Failed to start MemoryChainService')
+  return result
+}
+
+const init: Initializable<BaseAccountableServiceParams<Pick<Config, 'chain' | 'evm' | 'producer'>>,
+  ChainService> = async (params): Promise<ChainService> => {
+  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
+  const { config } = params
+  chainStakeServiceSingleton = canUseEvmContractChainService(config)
+    ? await initEvmContractChainService({ ...params, name: 'ChainStakeService' as CreatableName })
+    : await initMemoryChainService(params)
+  // Create service
+  return chainStakeServiceSingleton
+}

package/src/implementation/evm/index.ts

@@ -0,0 +1 @@
+export * from './initEvmProvider.ts'

package/src/implementation/evm/initChainId.ts

@@ -0,0 +1,20 @@
+import {
+  assertEx, hexFrom, isDefined, isHex,
+} from '@xylabs/sdk-js'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+
+export const canUseChainId = (config: Pick<Config, 'evm'>): boolean => {
+  return isDefined(config.evm.chainId)
+}
+
+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)
+    const parsed = Number.parseInt(hex, 16)
+    return parsed
+  } else {
+    const parsed = Number.parseInt(chainId, 10)
+    return parsed
+  }
+}

package/src/implementation/evm/initEvmProvider.ts

@@ -0,0 +1,24 @@
+import type { Logger } from '@xylabs/sdk-js'
+import { assertEx } from '@xylabs/sdk-js'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import type { Provider } from 'ethers'
+import type { JsonRpcProvider } from 'ethers/providers'
+
+import { canUseInfuraProvider, initInfuraProvider } from './initInfuraProvider.ts'
+import { canUseJsonRpcProvider, initJsonRpcProvider } from './initJsonRpcProvider.ts'
+
+let provider: Promise<JsonRpcProvider> | undefined
+
+export const initEvmProvider = async ({ config }: { config: Pick<Config, 'evm'>; logger?: Logger }): Promise<Provider> => {
+  if (provider) return provider
+  if (canUseInfuraProvider(config)) {
+    provider = initInfuraProvider(config)
+  } else if (canUseJsonRpcProvider(config)) {
+    provider = initJsonRpcProvider(config)
+  }
+  return assertEx(await provider, () => 'No provider available')
+}
+
+export const canUseEvmProvider = ({ config }: { config: Pick<Config, 'evm'> }) => {
+  return canUseInfuraProvider(config) || canUseJsonRpcProvider(config)
+}

package/src/implementation/evm/initInfuraProvider.ts

@@ -0,0 +1,26 @@
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import { InfuraProvider } from 'ethers/providers'
+
+import { canUseChainId, getChainId } from './initChainId.ts'
+
+let instance: Promise<InfuraProvider> | undefined
+
+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: Pick<Config, 'evm'>): boolean => {
+  return canUseChainId(config)
+    && isDefined(config.evm?.infura?.projectId)
+    && isDefined(config.evm?.infura?.projectSecret)
+}
+
+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/implementation/evm/initJsonRpcProvider.ts

@@ -0,0 +1,20 @@
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import { JsonRpcProvider } from 'ethers/providers'
+
+import { canUseChainId, getChainId } from './initChainId.ts'
+
+export const initJsonRpcProvider = (config: Pick<Config, 'evm'>) => {
+  const providerConfig = getJsonRpcProviderConfig(config)
+  return Promise.resolve(new JsonRpcProvider(...providerConfig))
+}
+
+export const canUseJsonRpcProvider = (config: Pick<Config, 'evm'>) => {
+  return canUseChainId(config)
+    && isDefined(config.evm.jsonRpc?.url)
+}
+
+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/implementation/head/createBootstrapHead.ts

@@ -0,0 +1,31 @@
+import {
+  buildNextBlock, createDeclarationIntent, createGenesisBlock,
+} from '@xyo-network/chain-protocol'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+
+export const createBootstrapHead = async (account: WalletInstance, chainService: ChainService): Promise<SignedHydratedBlockWithHashMeta[]> => {
+  const chainId = await chainService.chainId()
+  const chain: SignedHydratedBlockWithHashMeta[] = []
+
+  // Create genesis block
+  const genesisBlock = await createGenesisBlock(account, chainId, 10_000_000n, account.address)
+  chain.push(genesisBlock)
+
+  // Create producer declaration block
+  const producerDeclarationPayload = createDeclarationIntent(
+    account.address,
+    'producer',
+    genesisBlock[0].block,
+    genesisBlock[0].block + 10_000,
+  )
+  const producerDeclarationBlock = await buildNextBlock(
+    genesisBlock[0],
+    [],
+    [producerDeclarationPayload],
+    [account],
+  )
+  chain.push(producerDeclarationBlock)
+  return chain
+}

package/src/implementation/head/createForkedHead/config/getBridgeDestinationDetails.ts

@@ -0,0 +1,27 @@
+import { toHex } from '@xylabs/sdk-js'
+import type { BridgeDetailsDestinationFields } from '@xyo-network/xl1-protocol'
+
+import { getForkBlockRewardHex } from './getForkDetails.ts'
+
+// const bridgeableTokenContract = toHex('0x4865Cb10d55cfB0E60DD2B4F9b888f6a49B76733')
+// const bridgeDestAddress = toHex('0xe53218d47913b5f9E58bb74F0a0eD790bbF21972')
+// const destConfirmation = toHex('0x4fa05d7e799f36f1d45c441a4866eb4570a00a753a39377f404a8d113c01a657') // Eth TX for mint
+const ethChainId = toHex('0x1')
+const bridgeableTokenContract = toHex('0xf72aE3E0DA743033AbD7A407557D684c1aE66aed')
+const bridgeDestAddress = toHex('0x0e65b65B10C791942665030402c35023d88B14dA')
+const destConfirmation = toHex('0x950861b10523b52cdbb4a9ee52ed26601db555d2652bfec21c709e5e70d5b7d3') // Eth TX for mint
+
+export const getBridgeDestChainId = () => ethChainId
+export const getBridgeDestToken = () => bridgeableTokenContract
+export const getBridgeDestAddress = () => bridgeDestAddress
+export const getBridgeDestAmount = () => getForkBlockRewardHex()
+export const getBridgeDestConfirmation = () => destConfirmation
+
+export const getBridgeDestinationDetails = (): BridgeDetailsDestinationFields => {
+  return {
+    dest: getBridgeDestChainId(),
+    destToken: getBridgeDestToken(),
+    destAddress: getBridgeDestAddress(),
+    destAmount: getBridgeDestAmount(),
+  }
+}

package/src/implementation/head/createForkedHead/config/getBridgeSourceDetails.ts

@@ -0,0 +1,19 @@
+import type { AccountInstance } from '@xyo-network/account-model'
+import type { BridgeDetailsSourceFields } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+
+import { getForkBlockRewardHex } from './getForkDetails.ts'
+
+export const getBridgeSrcChainId = (chainService: ChainService) => chainService.chainId()
+export const getBridgeSrcAddress = (account: AccountInstance) => account.address
+export const getBridgeSrcToken = (chainService: ChainService) => chainService.chainId()
+export const getBridgeSrcAmount = () => getForkBlockRewardHex()
+
+export const getBridgeSourceDetails = async (account: AccountInstance, chainService: ChainService): Promise<BridgeDetailsSourceFields> => {
+  return {
+    src: await getBridgeSrcChainId(chainService),
+    srcAddress: getBridgeSrcAddress(account),
+    srcToken: await getBridgeSrcToken(chainService),
+    srcAmount: getBridgeSrcAmount(),
+  }
+}

package/src/implementation/head/createForkedHead/config/getForkDetails.ts

@@ -0,0 +1,10 @@
+import { type Hex, toHex } from '@xylabs/sdk-js'
+import { AttoXL1ConvertFactor } from '@xyo-network/xl1-protocol'
+
+export const getForkBlockReward = (): bigint => {
+  return 18_000_000_000n * AttoXL1ConvertFactor.xl1 // 18b XL1 in AttoXL1
+}
+
+export const getForkBlockRewardHex = (): Hex => {
+  return toHex(getForkBlockReward())
+}

package/src/implementation/head/createForkedHead/config/index.ts

@@ -0,0 +1,3 @@
+export * from './getBridgeDestinationDetails.ts'
+export * from './getBridgeSourceDetails.ts'
+export * from './getForkDetails.ts'

package/src/implementation/head/createForkedHead/createForkedHead.ts

@@ -0,0 +1,29 @@
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { SignedBlockBoundWitnessWithHashMeta, SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+
+import { getBridgeDestinationObservation } from './getBridgeDestinationObservation.ts'
+import { getBridgeIntent } from './getBridgeIntent.ts'
+import { getBridgeSourceObservation } from './getBridgeSourceObservation.ts'
+import { getFirstBlockForNewChain } from './getFirstBlockForNewChain.ts'
+
+export const createForkedHead = async (
+  forkFromBlock: SignedBlockBoundWitnessWithHashMeta,
+  account: WalletInstance,
+  chainService: ChainService,
+): Promise<SignedHydratedBlockWithHashMeta[]> => {
+  const chain: SignedHydratedBlockWithHashMeta[] = []
+  // Build the first block for the new chain
+  const firstBlockForNewChain = await getFirstBlockForNewChain(forkFromBlock, account, chainService)
+  chain.push(firstBlockForNewChain)
+  // Build the bridge intent
+  const bridgeIntent = await getBridgeIntent(firstBlockForNewChain, account, chainService)
+  chain.push(bridgeIntent)
+  // Build the bridge source observation
+  const bridgeSourceObservation = await getBridgeSourceObservation(bridgeIntent, account, chainService)
+  chain.push(bridgeSourceObservation)
+  // Build the bridge destination observation
+  const bridgeDestinationObservation = await getBridgeDestinationObservation(bridgeSourceObservation, account, chainService)
+  chain.push(bridgeDestinationObservation)
+  return chain
+}

package/src/implementation/head/createForkedHead/getBridgeDestinationObservation.ts

@@ -0,0 +1,42 @@
+import { buildNextBlock } from '@xyo-network/chain-protocol'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type {
+  BridgeDestinationObservation, BridgeDestinationObservationFields,
+  HydratedBlockWithHashMeta,
+  SignedHydratedBlockWithHashMeta,
+} from '@xyo-network/xl1-protocol'
+import { BridgeDestinationObservationSchema } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+
+import {
+  getBridgeDestConfirmation, getBridgeDestinationDetails, getBridgeSourceDetails,
+} from './config/index.ts'
+
+/**
+ * Get the bridge destination observation for a given block.
+ * @param previousBlock The previous block to base the observation on.
+ * @param account The wallet account to use for the observation.
+ * @param chainService The chain service to use for the observation.
+ */
+export const getBridgeDestinationObservation = async (
+  previousBlock: HydratedBlockWithHashMeta,
+  account: WalletInstance,
+  chainService: ChainService,
+): Promise<SignedHydratedBlockWithHashMeta> => {
+  const bridgeDestinationObservationFields: BridgeDestinationObservationFields = {
+    ...await getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    destConfirmation: getBridgeDestConfirmation(),
+  }
+  const bridgeDestinationObservation = new PayloadBuilder<BridgeDestinationObservation>({ schema: BridgeDestinationObservationSchema })
+    .fields(bridgeDestinationObservationFields)
+    .build()
+
+  return await buildNextBlock(
+    previousBlock[0],
+    [],
+    [bridgeDestinationObservation],
+    [account],
+  )
+}