@xyo-network/chain-sdk 1.0.1

package/package.json

@@ -0,0 +1,120 @@
+{
+  "$schema": "http://json.schemastore.org/package.json",
+  "name": "@xyo-network/chain-sdk",
+  "version": "1.0.1",
+  "description": "XYO Layer One SDK",
+  "homepage": "https://xylabs.com",
+  "bugs": {
+    "url": "git+https://github.com/xylabs/xyo-chain/issues",
+    "email": "support@xylabs.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xylabs/xyo-chain.git"
+  },
+  "license": "LGPL-3.0-only",
+  "author": {
+    "name": "XY Labs Development Team",
+    "email": "support@xylabs.com",
+    "url": "https://xylabs.com"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/browser/index-browser.mjs"
+      },
+      "node": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/node/index-node.mjs"
+      },
+      "neutral": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/neutral/index.mjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "./dist/neutral/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "scripts": {
+    "build": "xy build -j 8",
+    "build-tests": "tsc --noEmit --lib dom,esnext",
+    "deploy": "echo Deploy not allowed!",
+    "deploy3": "echo Deploy3 not allowed!"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@xylabs/assert": "^4.6.0",
+    "@xylabs/decimal-precision": "^4.6.0",
+    "@xylabs/delay": "^4.6.0",
+    "@xylabs/hex": "^4.6.0",
+    "@xyo-network/account": "^3.9.37",
+    "@xyo-network/account-model": "^3.9.37",
+    "@xyo-network/archivist-memory": "^3.9.37",
+    "@xyo-network/archivist-model": "^3.9.37",
+    "@xyo-network/boundwitness-builder": "^3.9.37",
+    "@xyo-network/bridge-http": "^3.9.37",
+    "@xyo-network/bridge-model": "^3.9.37",
+    "@xyo-network/chain-ethereum": "^1.0.1",
+    "@xyo-network/chain-model": "^1.0.1",
+    "@xyo-network/chain-modules": "^1.0.1",
+    "@xyo-network/chain-protocol": "^1.0.1",
+    "@xyo-network/chain-services": "^1.0.1",
+    "@xyo-network/chain-utils": "^1.0.1",
+    "@xyo-network/chain-validation": "^1.0.1",
+    "@xyo-network/diviner-model": "^3.9.37",
+    "@xyo-network/module-model": "^3.9.37",
+    "@xyo-network/node-memory": "^3.9.37",
+    "@xyo-network/payload-builder": "^3.9.37",
+    "@xyo-network/payload-model": "^3.9.37",
+    "@xyo-network/sentinel-memory": "^3.9.37",
+    "@xyo-network/sentinel-model": "^3.9.37",
+    "@xyo-network/typechain": "^3.4.15",
+    "async-mutex": "^0.5.0",
+    "ethers": "^6.13.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "@typescript-eslint/eslint-plugin": "^8.26.1",
+    "@typescript-eslint/parser": "^8.26.1",
+    "@xylabs/config": "^6.0.9",
+    "@xylabs/delay": "^4.6.0",
+    "@xylabs/eslint-config-flat": "^6.0.9",
+    "@xylabs/ts-scripts-yarn3": "^6.0.9",
+    "@xylabs/tsconfig": "^6.0.9",
+    "@xylabs/tsconfig-react": "^6.0.9",
+    "@xylabs/vitest-extended": "^4.6.0",
+    "@xyo-network/account": "^3.9.37",
+    "@xyo-network/id-payload-plugin": "^3.9.37",
+    "@xyo-network/node-model": "^3.9.37",
+    "@xyo-network/open-zeppelin-typechain": "^3.4.15",
+    "eslint": "^9.22.0",
+    "eslint-import-resolver-typescript": "^3.8.7",
+    "ganache": "^7.9.2",
+    "knip": "^5.46.0",
+    "reflect-metadata": "^0.2.2",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.27.9",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.2",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.8",
+    "vitest-mock-extended": "^3.0.1"
+  },
+  "packageManager": "yarn@4.6.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "engineStrict": true,
+  "volta": {
+    "node": "22.3.0",
+    "yarn": "4.6.0"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  }
+}

package/src/Layers.md

@@ -0,0 +1,64 @@
+# Blockchain State Layers
+
+## Table of Contents
+- [Blockchain State Layers](#blockchain-state-layers)
+  - [Table of Contents](#table-of-contents)
+  - [Layers](#layers)
+    - [Protocol Services](#protocol-services)
+    - [Chain Builder Services](#chain-builder-services)
+    - [Chain Iterator Services](#chain-iterator-services)
+    - [Validator Services](#validator-services)
+    - [Producer Services](#producer-services)
+    - [Dapp/Gateway Services Common](#dappgateway-services-common)
+
+---
+## Layers
+---
+
+### Protocol Services
+**Description:** Used to build individual, protocol-valid blocks  
+**State:** Stateless
+- Block Services
+  - Transaction Services
+
+---
+
+### Chain Builder Services
+**Description:** Used to build protocol-valid chain for a specific staking contract  
+**State:** Staking contract
+- Contract Services
+- Chain Services
+
+---
+
+### Chain Iterator Services
+**Description:** Services that enable read access of a chain 
+**State:** XYO Chain Head, Archivist(s)
+- Chain State & History
+  - Account Balance Services
+
+---
+
+### Validator Services
+**Description:** Services that enable historical & next-block validation
+**State:** XYO Chain Creation
+- Leader Election
+- Block Reward Calculation
+
+---
+
+### Producer Services
+**Description:** Services that enable next-block production  
+**State:** Pending transactions for inclusion in the blockchain
+- Mempool/Pending Transaction Service
+- Voucher Service
+
+---
+
+### Dapp/Gateway Services Common
+**Description:** Services that enable Dapps to Interact with Chain  
+**State:** Application state
+- `web2 RPC`
+  - `addTransaction`
+  - `readBalance`
+  - `validatePending`

package/src/index-browser.ts

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

package/src/index-node.ts

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

package/src/index-shared.ts

@@ -0,0 +1,8 @@
+export * from './orchestration/index.ts'
+export * from '@xyo-network/chain-ethereum'
+export * from '@xyo-network/chain-model'
+export * from '@xyo-network/chain-modules'
+export * from '@xyo-network/chain-protocol'
+export * from '@xyo-network/chain-services'
+export * from '@xyo-network/chain-utils'
+export * from '@xyo-network/chain-validation'

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './index-shared.ts'
+export * from './test/index.ts'

package/src/orchestration/archivist/index.ts

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

package/src/orchestration/archivist/initArchivistSync.ts

@@ -0,0 +1,61 @@
+import { TracerProvider } from '@opentelemetry/api'
+import { ArchivistSyncDiviner } from '@xyo-network/chain-modules'
+import { spanAsync } from '@xyo-network/chain-utils'
+import { ArchivistInstance } from '@xyo-network/archivist-model'
+import { DivinerConfigSchema } from '@xyo-network/diviner-model'
+import { ModuleIdentifier } from '@xyo-network/module-model'
+import { MemoryNode } from '@xyo-network/node-memory'
+import { MemorySentinel } from '@xyo-network/sentinel-memory'
+import { SentinelConfigSchema } from '@xyo-network/sentinel-model'
+
+export const initArchivistSync = async (
+  name: ModuleIdentifier,
+  inArchivist: ArchivistInstance,
+  outArchivist: ArchivistInstance,
+  frequency = 1000,
+  traceProvider?: TracerProvider,
+) => {
+  const tracer = traceProvider?.getTracer(`archivist-sync-diviner [${name}]`)
+  return await spanAsync(`initArchivistSync [${name}]`, async () => {
+    const node = await MemoryNode.create({ account: 'random' })
+    const finalizedArchivistSyncDiviner = await ArchivistSyncDiviner.create({
+      account: 'random',
+      inArchivist,
+      outArchivist,
+      tracer,
+      config: { schema: DivinerConfigSchema, name },
+    })
+
+    await node.register(finalizedArchivistSyncDiviner)
+    await node.attach(finalizedArchivistSyncDiviner.address)
+
+    const sentinel = await MemorySentinel.create({
+      account: 'random',
+      config: {
+        name,
+        schema: SentinelConfigSchema,
+        tasks: [
+          {
+            required: true,
+            mod: finalizedArchivistSyncDiviner.address,
+            endPoint: 'divine',
+          },
+        ],
+        automations: [
+          {
+            frequency,
+            frequencyUnits: 'millis',
+            schema: 'network.xyo.automation.interval',
+            start: Date.now(),
+            type: 'interval',
+          },
+        ],
+      },
+    })
+
+    await node.register(sentinel)
+    await node.attach(sentinel.address)
+
+    return node
+  }, tracer)
+}

package/src/orchestration/bridge.ts

@@ -0,0 +1,25 @@
+import { HttpBridge, HttpBridgeConfigSchema } from '@xyo-network/bridge-http'
+import { AttachableBridgeInstance } from '@xyo-network/bridge-model'
+import { Mutex } from 'async-mutex'
+
+const initMutex = new Mutex()
+const bridgeSingletonMap = new Map<string, AttachableBridgeInstance>()
+
+export const initBridge = async (nodeUrl: string): Promise<AttachableBridgeInstance> => {
+  return await initMutex.runExclusive(async () => {
+    const existing = bridgeSingletonMap.get(nodeUrl)
+    if (existing) return existing
+    const bridge = await HttpBridge.create({
+      account: 'random',
+      config: {
+        name: 'HttpBridge',
+        client: { url: nodeUrl, discoverRoots: 'start' },
+        schema: HttpBridgeConfigSchema,
+        security: { allowAnonymous: true },
+      },
+    })
+    await bridge.start()
+    bridgeSingletonMap.set(nodeUrl, bridge)
+    return bridge
+  })
+}

package/src/orchestration/index.ts

@@ -0,0 +1,3 @@
+export * from './archivist/index.ts'
+export * from './bridge.ts'
+export * from './initBridgedModule.ts'

package/src/orchestration/initBridgedModule.ts

@@ -0,0 +1,35 @@
+import { assertEx } from '@xylabs/assert'
+import { Initializable } from '@xyo-network/chain-model'
+import { Address } from '@xylabs/hex'
+import { asAttachableArchivistInstance, AttachableArchivistInstance } from '@xyo-network/archivist-model'
+import { BridgeInstance } from '@xyo-network/bridge-model'
+import {
+  asAttachableModuleInstance, AttachableModuleInstance, ModuleIdentifier,
+} from '@xyo-network/module-model'
+import { Mutex } from 'async-mutex'
+
+const initMutex = new Mutex()
+const bridgedModuleDictionary: Record<Address, Record<ModuleIdentifier, AttachableModuleInstance>> = {}
+
+export const initBridgedModule: Initializable<
+  { bridge: BridgeInstance; moduleName: ModuleIdentifier }, AttachableModuleInstance
+> = async ({ bridge, moduleName }): Promise<AttachableModuleInstance> => {
+  return await initMutex.runExclusive(async () => {
+    const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName]
+    if (existing) return existing
+    const mod = assertEx(await bridge.resolve(moduleName), () => `Error: Could not resolve ${moduleName}`)
+    const moduleInstance = assertEx(asAttachableModuleInstance(mod), () => `Error: Could not convert ${moduleName} to attachable module instance`)
+    bridgedModuleDictionary[bridge.address] = bridgedModuleDictionary[bridge.address] || {}
+    bridgedModuleDictionary[bridge.address][moduleName] = moduleInstance
+    return moduleInstance
+  })
+}
+
+export const initBridgedArchivistModule: Initializable<
+  { bridge: BridgeInstance; moduleName: ModuleIdentifier }, AttachableArchivistInstance
+> = async ({ bridge, moduleName }): Promise<AttachableArchivistInstance> => {
+  return assertEx(
+    asAttachableArchivistInstance(await initBridgedModule({ bridge, moduleName })),
+    () => `Error: Could not convert ${moduleName} to attachable archivist instance`,
+  )
+}

package/src/test/evm/index.ts

@@ -0,0 +1,2 @@
+export * from './runGanache.ts'
+export * from './stakingContractUtils.ts'

package/src/test/evm/runGanache.ts

@@ -0,0 +1,41 @@
+import { ChildProcess, spawn } from 'node:child_process'
+
+import { delay } from '@xylabs/delay'
+import { JsonRpcProvider } from 'ethers/providers'
+
+async function isGanacheRunning(url: string) {
+  try {
+    const provider = new JsonRpcProvider(url)
+    await provider.getBlockNumber() // Try to fetch the latest block number
+    return true // If this succeeds, the server is running
+  } catch {
+    return false // If this fails, the server is not running
+  }
+}
+
+export async function startGanache(port: number, mnemonic: string) {
+  console.log('Starting Ganache CLI...')
+
+  // Start Ganache CLI
+  const ganacheProcess = spawn(
+    'yarn',
+    ['ganache', '--port', `${port}`, '--chain.chainId', '1337', '--mnemonic', mnemonic],
+    { stdio: 'inherit' },
+  )
+
+  // Wait for Ganache to be ready
+  while (!await isGanacheRunning(`http://127.0.0.1:${port}`)) {
+    await delay(500)
+  }
+
+  return ganacheProcess
+}
+
+export function stopGanache(process: ChildProcess) {
+  console.log('Stopping Ganache CLI...')
+
+  if (process) {
+    process.kill('SIGTERM')
+    console.log('Ganache CLI stopped.')
+  }
+}

package/src/test/evm/setup.ts

@@ -0,0 +1,75 @@
+import { assertEx } from '@xylabs/assert'
+import { createChain } from '@xyo-network/chain-ethereum'
+import { toEthAddress } from '@xyo-network/chain-model'
+import { EvmChainService } from '@xyo-network/chain-services'
+import { XYO_ZERO_ADDRESS } from '@xyo-network/chain-utils'
+import { asAddress } from '@xylabs/hex'
+import { HDWallet } from '@xyo-network/account'
+import { BurnableErc20__factory as Erc20Factory, StakedXyoChain__factory as StakedXyoChainFactory } from '@xyo-network/typechain'
+import { JsonRpcProvider } from 'ethers/providers'
+import { parseUnits } from 'ethers/utils'
+import { Wallet } from 'ethers/wallet'
+
+import { startGanache } from './runGanache.ts'
+
+const ganachePort = 8545
+const testPhrase = 'edit hill neutral usage share kite knee abandon slim open lottery abandon'
+
+const gasConfig = () => {
+  return {
+    gasLimit: 2_000_000, // Set the gas limit
+    gasPrice: parseUnits('100', 'gwei'),
+  }
+}
+
+// Create Erc20
+await startGanache(ganachePort, testPhrase)
+const walletPerson = await HDWallet.fromPhrase(testPhrase, "m/44'/60'/0'/0")
+const initialProducer = await HDWallet.fromPhrase(testPhrase, "m/44'/60'/1'/0")
+const account0 = await walletPerson.derivePath("m/44'/60'/0'/0/0")
+const account1 = await walletPerson.derivePath("m/44'/60'/0'/0/1")
+const provider0 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+const ethWalletPerson0 = new Wallet(account0.privateKey, provider0)
+const provider1 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+const ethWalletPerson1 = new Wallet(account1.privateKey, provider1)
+
+const erc20 = new Erc20Factory(ethWalletPerson0)
+const erc20Contract = await (await erc20.deploy('Test Token', 'TST', parseUnits('1000000', 18), gasConfig())).waitForDeployment()
+const erc20Address = await erc20Contract.getAddress()
+console.log('ERC20 Contract Address:', erc20Address)
+const erc20ContractPerson0 = Erc20Factory.connect(erc20Address, ethWalletPerson0)
+
+// Transfer Tokens
+await (await erc20ContractPerson0.transfer(ethWalletPerson1.address, parseUnits('1000', 18), gasConfig())).wait()
+const erc20ContractPerson1 = Erc20Factory.connect(erc20Address, ethWalletPerson1)
+const balance = await erc20ContractPerson1.balanceOf(ethWalletPerson1.address)
+console.log(erc20Address, 'ERC20 Balance:', balance.toString())
+
+// Create Chain Contract
+const [xyoChainContractAddress] = await (createChain(
+  ethWalletPerson0, // signer
+  toEthAddress(erc20Address), // stakingTokenAddress
+  initialProducer, // initialProducer
+  null,
+  0n,
+  XYO_ZERO_ADDRESS,
+  50_000n,
+  gasConfig(),
+))
+
+const xyoChainPerson0 = StakedXyoChainFactory.connect(xyoChainContractAddress)
+
+console.log('XYO Chain Contract Address:', xyoChainContractAddress)
+// const xyoChainPerson1 = StakedXyoChainFactory.connect(xyoChainContractAddress, ethWalletPerson1)
+
+// Approve Stake Chain Address
+await (await erc20ContractPerson1.approve(xyoChainContractAddress, parseUnits('100', 18), gasConfig())).wait()
+
+// Stake Chain Contract
+const address = assertEx(asAddress(xyoChainContractAddress))
+const xyoChainPerson1 = await EvmChainService.create({ id: address, runner: ethWalletPerson1 })
+await xyoChainPerson1.addStake(await ethWalletPerson1.getAddress(), parseUnits('50', 18))
+
+// Read Stake
+const stakeByAddressResult = await xyoChainPerson0.activeByAddressStaked(await ethWalletPerson1.getAddress())
+console.log('Stake By Address:', stakeByAddressResult.toString())

package/src/test/evm/stakingContractUtils.ts

@@ -0,0 +1,109 @@
+import { assertEx } from '@xylabs/assert'
+import { createChain } from '@xyo-network/chain-ethereum'
+import { ChainStakeIntent, ChainStakeIntentSchema, HydratedBlock } from '@xyo-network/chain-model'
+import {
+  buildBlock, buildTransaction 
+} from '@xyo-network/chain-protocol'
+import { XYO_ZERO_ADDRESS } from '@xyo-network/chain-utils'
+import { Address, asAddress } from '@xylabs/hex'
+import {
+  Account, AccountInstance, WalletInstance,
+} from '@xyo-network/account'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { BurnableErc20__factory as Erc20Factory } from '@xyo-network/typechain'
+import { getAddress } from 'ethers/address'
+import { JsonRpcProvider } from 'ethers/providers'
+import { parseUnits } from 'ethers/utils'
+import { Wallet } from 'ethers/wallet'
+
+const gasConfig = () => {
+  return {
+    gasLimit: 2_000_000, // Set the gas limit
+    gasPrice: parseUnits('100', 'gwei'),
+  }
+}
+
+export const createTestErc20 = async (ganachePort: number, testPhrase: string, contractCreator: WalletInstance): Promise<Address> => {
+  const provider = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+  const ethWallet = new Wallet(contractCreator.privateKey, provider)
+  const erc20 = new Erc20Factory(ethWallet)
+  const totalSupply = parseUnits('1000000', 18)
+  const erc20Contract = await (await erc20.deploy('Test Token', 'TST', totalSupply, gasConfig())).waitForDeployment()
+  const erc20Address = await erc20Contract.getAddress()
+  const erc20ContractPerson0 = Erc20Factory.connect(erc20Address, ethWallet)
+  const balance = await erc20ContractPerson0.balanceOf(ethWallet.address)
+  assertEx(balance === totalSupply, () => 'Balance does not match total supply')
+  return assertEx(asAddress(erc20Address), () => 'Invalid ERC20 contract address')
+}
+
+export const transferTestTokens = async (ganachePort: number, erc20Address: Address, account0: WalletInstance, account1: WalletInstance) => {
+  const provider0 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+  const ethWalletPerson0 = new Wallet(account0.privateKey, provider0)
+  const provider1 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+  const ethWalletPerson1 = new Wallet(account1.privateKey, provider1)
+  const erc20ContractPerson0 = Erc20Factory.connect(getAddress(erc20Address), ethWalletPerson0)
+  const transferAmount = parseUnits('1000', 18)
+  await (await erc20ContractPerson0.transfer(ethWalletPerson1.address, transferAmount, gasConfig())).wait()
+  const erc20ContractPerson1 = Erc20Factory.connect(getAddress(erc20Address), ethWalletPerson1)
+  const balance = await erc20ContractPerson1.balanceOf(ethWalletPerson1.address)
+  assertEx(balance === transferAmount, () => 'Balance does not match transfer amount')
+}
+
+export const createTestChainContract = async (
+  ganachePort: number,
+  erc20Address: Address,
+  account0: WalletInstance,
+  initialProducer: AccountInstance,
+): Promise<Address> => {
+  const provider0 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+  const ethWalletPerson0 = new Wallet(account0.privateKey, provider0)
+  const [xyoChainContractAddress] = await createChain(
+    ethWalletPerson0,
+    erc20Address,
+    initialProducer,
+    XYO_ZERO_ADDRESS,
+    0n,
+    XYO_ZERO_ADDRESS,
+    50_000n,
+    gasConfig(),
+  )
+  return assertEx(asAddress(xyoChainContractAddress), () => 'Invalid staking contract address')
+}
+
+export const approveTestStakeChainAddress = async (ganachePort: number, erc20Address: Address, xyoChainContractAddress: Address, account1: WalletInstance) => {
+  const provider1 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+  const ethWalletPerson1 = new Wallet(account1.privateKey, provider1)
+  const erc20ContractPerson1 = Erc20Factory.connect(getAddress(erc20Address), ethWalletPerson1)
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const _approveResultTx = await (await erc20ContractPerson1.approve(getAddress(xyoChainContractAddress), parseUnits('100', 18), gasConfig())).wait()
+}
+
+export const createTestGenesisBlock = async (
+  blockProducerAccounts: WalletInstance[],
+): Promise<HydratedBlock> => {
+  const randomChainId = (await Account.random()).address
+  // Create staked intents for all the block producers declaring their intent to produce blocks
+  const signedStakedBlockProducerIntents = await Promise.all(blockProducerAccounts.map(async (blockProducerAccount) => {
+    const stakeIntent = new PayloadBuilder<ChainStakeIntent>({ schema: ChainStakeIntentSchema }).fields({
+      from: blockProducerAccount.address,
+      exp: Number.MAX_SAFE_INTEGER,
+      nbf: 0,
+      intent: 'producer',
+    }).build()
+
+    const signedStakedBlockProducerIntent = await buildTransaction(
+      randomChainId,
+      [stakeIntent],
+      0n,
+      blockProducerAccount,
+      0,
+      1000,
+      [],
+    )
+    return signedStakedBlockProducerIntent
+  }))
+  const intents = signedStakedBlockProducerIntents.map(intent => intent[0])
+  const payloads = signedStakedBlockProducerIntents.flatMap(intent => intent[1])
+  const [firstBlock, signedTransactionBws] = await buildBlock(randomChainId, signedStakedBlockProducerIntents, [], blockProducerAccounts)
+  return [firstBlock, [...intents, ...signedTransactionBws, ...payloads]] as const
+}

package/src/test/globalSetup.ts

@@ -0,0 +1,14 @@
+const globalTeardown = async () => {
+  console.log('Running global teardown after all tests...')
+  // TODO: Stop Ganache here?
+  await new Promise(resolve => setTimeout(resolve, 1))
+}
+
+export default async function globalSetup() {
+  console.log('Running global setup before all tests...')
+  // TODO: Start Ganache here?
+  await new Promise(resolve => setTimeout(resolve, 1))
+
+  // Return a teardown function that Vitest will call after all tests complete
+  return globalTeardown
+}

package/src/test/index.ts

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

package/xy.config.ts

@@ -0,0 +1,10 @@
+import { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
+const config: XyTsupConfig = {
+  compile: {
+    browser: { src: { entry: ['src/index-browser.ts'] } },
+    node: { src: { entry: ['src/index-node.ts'] } },
+    neutral: { src: true },
+  },
+}
+
+export default config