unionlabs/union

This release delivers a comprehensive overhaul of the App2 frontend, introducing a modern Svelte 5 architecture with an Effect-based runtime for robust state management and error handling. The update significantly expands cross-chain functionality by adding light client implementations for Arbitrum, Base, and Starknet, alongside new staking, transfer, and dashboard features. Additionally, the release introduces the Ceremony web application, new CosmWasm contracts for access management and liquid staking, and a multi-chain faucet service.

A new Move module for the 'ping-pong' IBC application has been added to the Aptos ecosystem. This includes the project configuration in Move.toml and the core logic in sources/ping\_pong.move, which implements the IBC application interface (handling packet reception, acknowledgment, and timeouts) to facilitate the standard ping-pong test between chains.

aptos/ucs00-ping-pong · high confidence

Added new Move modules for the Aptos zkgm implementation, including \acknowledgement\, \batch\, \batch\_ack\, \dispatcher\, \engine\, \eth\_abi\, \forward\, and \fungible\_asset\_order\. These files introduce the core data structures and serialization logic (encode/decode functions) for handling zkgm instructions, acknowledgements, and fungible asset orders on the Aptos blockchain.

aptos/ucs03-zkgm/sources · high confidence

The lib/bob-types library now includes a new Rust source file defining the L2\_TO\_L1\_MESSAGE\_PASSER constant, which holds the Ethereum address 0x4200000000000000000000000000000000000016, referencing the Bob mainnet L2 contract. Additionally, a LICENSE file was added to the lib/bob-types directory, establishing the licensing terms for the library's contents.

lib/bob-types · high confidence

The lib/bob-client directory now includes a new Rust library (src/lib.rs) that provides functions to query the L1 dispute game factory, allowing clients to determine the finalized L2 block number for a given L1 block. The addition of the LICENSE file indicates this is a new, standalone component within the codebase.

lib/bob-client · high confidence

The \lib/bob-verifier\ crate has been introduced, providing a new verification library for the Bob protocol. This includes a \LICENSE\ file and a \src/lib.rs\ implementing header verification (\verify\_header\) and related helper functions (\compute\_game\_slot\, \compute\_output\_root\_proof\_hash\, \verify\_l2\_header\_is\_related\_to\_output\_root\_proof\). The library validates L2 headers against L1 state roots, verifying dispute game factory inclusion, game code, and output root proofs, returning specific error types for invalid proofs or hash mismatches.

lib/bob-verifier · high confidence

A new Rust library at lib/create3/src/lib.rs implements the CREATE3 algorithm to compute deterministic contract addresses from a deployer address and a salt. The implementation uses Keccak256 hashing and includes a test case to verify the predicted address against known values.

lib/create3 · high confidence

The \cairo/cometbls\_verifier\ directory now contains a new Groth16 verification contract for CometBLS, generated by Garaga 1.0.1. This includes the main \groth16\_verifier.cairo\ contract, its constants, and a corresponding test suite that validates proof verification on Starknet using the \garaga\ and \starknet\ dependencies.

_cairo/cometbls\verifier · high confidence

Introduces the Cairo implementation of the IBC (Inter-Blockchain Communication) module, providing the core logic for managing light clients, establishing connections, and handling packet lifecycle (send, receive, acknowledge, timeout). The change adds the \cairo/ibc\ directory containing the module's source files (\app.cairo\, \contract.cairo\, \event.cairo\, \lightclient.cairo\, \msg.cairo\, \path.cairo\, \types.cairo\) and associated configuration files (\Scarb.toml\, \Scarb.lock\, \snfoundry.toml\). This establishes the foundational interface and state management for IBC operations on the Starknet chain.

cairo/ibc · high confidence

This change introduces two new Cairo-based light client implementations: a CometBLS light client and a Starknet loopback light client. The CometBLS client (\cairo/cometbls\_light\_client\) implements the IBC light client interface, including client creation, header updates, and membership verification using ICS23 Merkle proofs. The Starknet loopback client (\cairo/loopback\_light\_client\) provides a local verification mechanism for Starknet block headers, enabling the system to verify state against the local chain's consensus state. Both clients include their respective type definitions, storage structures, and build configuration files (Scarb.toml, Scarb.lock, snfoundry.toml).

_cairo/cometbls\_light\client · high confidence

Users can now deploy an EVM attestor plugin to track and submit attestations for EVM-compatible chains. This new component, located in \voyager/plugins/attestor/evm\, includes the core Rust implementation (\main.rs\, \call.rs\) and a configuration example (\example-config.jsonc\) that sets up the state, proof, consensus, and client modules required for EVM attestation.

voyager/plugins/attestor · high confidence

The \tools\ directory now includes a new \build-evm-deployer-tx\ tool that generates pre-signed, pre-EIP-155 transactions for deploying EVM contracts across multiple chains. Additionally, the \tools\ area introduces several new utilities: a \cairols\ patch to remove test dependencies, a \docgen\ system for templating and verifying documentation, a \json-schema-to-nixos-module-options\ converter for generating NixOS module options from JSON schemas, an \iaviewer\ package for inspecting IAVL trees, and Nix derivations for \libblst\ and \libwasmvm\ to manage cryptographic and WebAssembly runtime libraries.

tools · high confidence

A new Rust utility has been added at \tools/build-evm-deployer-tx\ to construct EVM deployer transactions. The tool uses the \alloy\ library to generate either the signature hash or the raw encoded transaction (EIP-2718) for a hardcoded deployer bytecode, allowing users to prepare deployment transactions for EVM-compatible chains.

tools/build-evm-deployer-tx · medium confidence

New Solidity libraries were added to the EVM contracts to verify ICS23 Merkle proofs. The \ICS23\ library implements \verifyChainedMembership\ and \verifyChainedNonMembership\ functions that validate existence and non-existence proofs against a given state root. The \ICS23Verifier\ library exposes these as \verifyMembership\ and \verifyNonMembership\ entry points. Additionally, \CometblsZKVerifier\ was added to support Groth16 zero-knowledge proof verification for the CometBLS client, and \MPTVerifier\ was added to handle Merkle Patricia Tree proof verification. These changes enable the EVM to verify state proofs from the Cosmos/CometBLS backend.

evm/contracts · high confidence

The \beacon-api-types\ library now includes comprehensive type definitions for the Ethereum consensus specs, covering the Altair, Bellatrix, and Capella upgrades. This adds support for light client synchronization protocols, execution payloads, and beacon block structures required for interacting with modern Ethereum nodes. The changes also introduce chain specification traits and constants to handle network-specific parameters like committee sizes and payload limits.

lib/beacon-api-types · high confidence

Introduces a new Ethereum light client implementation for the IBC protocol, including the core client logic, contract entrypoints, error handling, and sync committee management. The implementation supports both Mainnet and Minimal chain specifications, handling header verification, state updates, and misbehavior detection. Test fixtures for headers, sync committees, and finality updates are also included to validate the client's behavior.

(repo-wide) · high confidence

Introduced a new \ClientState\ struct in the \ethermint-light-client-types\ library to support tracking an Ethermint chain. This struct extends the standard Tendermint consensus verification with additional configuration parameters required for verifying the EVM state, including the store key, key prefix for smart contract storage, and the IBC contract address.

lib/ethermint-light-client-types · high confidence

A new 'Find packet' page has been added at /explorer/find-packet. Users can enter a transaction hash to retrieve and view the associated packet and transfer information, with direct links to the respective explorer pages.

app2/src/routes/explorer/find-packet · high confidence

Introduces a new \gnark-mimc\ library that implements the MiMC hash function for the BN254 and BLS12-377 curves, matching the parameters and behavior of the Gnark crypto library. This provides a Rust-native implementation of the hash function used in the Linea protocol, enabling compatibility with existing cryptographic proofs and verifiers that rely on this specific hash algorithm.

lib/gnark-mimc · high confidence

Introduces new Rust types for the Gno blockchain, including light-client state structures (ClientState, ConsensusState, Header) and an RPC client with associated response types (BlockResponse, StatusResponse, AbciQueryResponse, etc.). This enables Voyager to interact with Gno nodes via JSON-RPC and WebSocket, supporting block queries, validator sets, and ABCI methods.

lib/gno-types · high confidence

New GraphQL fragments are introduced to define the shape of data for individual packet and transfer list items. The \PacketListItem\ fragment specifies fields such as \packet\_hash\, \status\, and \sort\_order\ for the \v2\_packet\_type\. The \TransferListItem\ fragment defines fields including \sender\_canonical\, \base\_amount\, and \sort\_order\ for the \v2\_transfer\_type\. These fragments enable the application to fetch structured data for displaying packets and transfers in list views.

app2/src/lib/queries/fragments · high confidence

The \lib/ibc-classic-spec\ crate now contains the implementation of the \IbcClassic\ struct, which serves as the specification for the classic IBC protocol. This includes the \StorePath\ enum and its associated path types (such as \ClientStatePath\ and \ClientConsensusStatePath\) that define how data is stored and accessed for classic IBC channels and connections.

lib/ibc-classic-spec · high confidence

New light client implementations are added for Arbitrum, Base, Berachain, Bob, and CometBLS, each providing the \IbcClient\ trait to verify headers, manage client states, and handle IBC packet verification. The \cosmwasm/core/msg\ module introduces new message and query types for IBC-Union, including \IbcUnionMsg\ for channel and packet handling, and \msg.rs\/\query.rs\ for core IBC operations like client registration, connection/channel management, and state queries. Bob's implementation includes a \V1ToV2\ migration message to upgrade client states. These changes enable the IBC-Union protocol to support multiple L1 and L2 chains with standardized verification and state management.

(repo-wide) · high confidence

The lib/aptos.nix file has been added to define the build environment for the Aptos project within the Nix package manager. This configuration introduces the 'movefmt' tool, a formatter for the Move language, built from the 'develop' branch of the movebit/movefmt repository. It sets up the necessary Rust toolchain and Cargo build targets for various systems (Linux aarch64/x86\_64 and macOS aarch64/x86\_64) to compile the formatter.

lib · high confidence

The ProofLens light client is introduced, implementing the IBC client interface to verify membership and non-membership proofs by querying a counterparty chain. This enables the system to validate state changes on the L2 chain using proofs generated by the L1 client, supporting header updates and status checks for the ProofLens integration.

cosmwasm/lightclient/proof-lens · high confidence

The \lib/ssz-derive\ crate is added, providing a \\#\[derive(Ssz)\]\ macro that generates SSZ (Simple Serialize) encoding and decoding implementations for Rust structs and enums. The macro supports container structs, transparent wrappers, and union enums, enabling automatic serialization of data structures for the Ethereum light client and other SSZ-based protocols.

lib/ssz-derive · high confidence

Added new files to handle Safe wallet interactions: a new \safe.ts\ file configures the Safe Apps SDK with allowed domains and debug settings, while \safe-hash.ts\ introduces a \resolveSafeTx\ function that polls for transaction hashes using the Safe SDK. This enables the application to resolve and track Safe wallet transactions.

app2/src/lib/transfer/shared/services/handlers · medium confidence

The \starknet-verifier\ library now includes a \verify\_header\ function that validates a StarkNet block header by verifying the L2 block hash against the L1 state root and confirming the L2 IBC account proof. This introduces the core verification logic for StarkNet light clients, relying on \evm\_storage\_verifier\ and \starknet\_storage\_verifier\ to validate account proofs and storage roots.

lib/starknet-verifier · high confidence

The lib/starknet-storage-verifier library was introduced to provide cryptographic verification of StarkNet storage proofs. It implements Merkle tree traversal and hashing (using both Pedersen and Poseidon hash functions) to validate membership and non-membership proofs for contract storage keys, enabling the system to verify on-chain state roots and storage values.

lib/starknet-storage-verifier · high confidence

Introduces new Rust types for Starknet light client integration, including client state, consensus state, header, and storage proof structures. The \starknet-light-client-types\ library defines data structures for validating Starknet blocks and state roots, while \starknet-types\ provides a \Felt\ type and \MerkleNode\ enum to handle Starknet's 256-bit field elements and Merkle-Patricia tree nodes.

lib/starknet-light-client-types, lib/starknet-types · high confidence

The repository now includes a new \state-lens-ics23-ics23\ CosmWasm light client implementation. This adds support for verifying state proofs for a Layer-2 chain using the ICS23 commitment scheme, enabling the network to track and validate headers from the L2 via the L1 client. The change introduces the core client logic, contract entry points, and error handling for this specific light client type.

cosmwasm/lightclient/state-lens-ics23-ics23 · high confidence

The Sui subdirectory now includes the core IBC implementation and an escrow vault module. The \ibc\ package provides the foundational IBC logic, including a CometBLS light client for header verification, a Groth16 verifier for zero-knowledge proofs, and event emission structures for client, connection, channel, and packet states. The \escrow\_vault\ package introduces a new \EscrowVault\ object that manages fungible asset counterparties and intent whitelists, enabling the handling of cross-chain token orders and escrowed assets on Sui.

sui · high confidence

Introduce the \sui-ibc-app\ plugin, which implements the core logic for processing IBC packets (receive, acknowledge, and timeout) on the Sui blockchain. The new \call.rs\ file defines the message types, while \main.rs\ implements the \TransactionPluginServer\ interface to build and submit transactions for packet handling. The \coin.rs\ module provides helpers to update coin metadata (name, symbol, icon, description) via the Sui SDK, and \zkgm.rs\ contains the specific logic for ZKGM token registration and vault interactions during packet processing.

voyager/plugins/sui-ibc-app · high confidence

The lib/sui-verifier library now includes the core verification logic for Sui checkpoints and object membership. This introduces a new error module defining mismatch and digest errors, and implements the \SignatureVerification\ trait along with \verify\_checkpoint\ and \verify\_membership\ functions. These functions validate checkpoint signatures, verify object state against transaction effects, and ensure checkpoint contents integrity, enabling the system to verify Sui blockchain state transitions.

lib/sui-verifier · high confidence

A new \SuiQuery\ utility has been added to \lib/sui-utils/src/lib.rs\ to simplify calling Move functions via the Sui \dev-inspect\ API. The utility handles building \ProgrammableTransactionBuilder\ calls, managing shared object arguments, and parsing return values from \dev\_inspect\_transaction\_block\.

lib/sui-utils · high confidence

The \lib/sui-light-client-types\ module introduces a comprehensive set of Rust types to represent Sui blockchain data structures, enabling the light client to parse and verify chain state. This includes \CheckpointSummary\ for block headers and epoch data, \Transaction\ and \TransactionEffects\ for transaction details and execution results, \Object\ for on-chain state, and \StorageProof\ for verification. The types support both \serde\ (JSON) and \bincode\ serialization, and include specific handling for Sui's consensus, committee, and cryptographic signatures.

lib/arbitrum-light-client-types, lib/sui-light-client-types · high confidence

The application now supports connecting to Sui-compatible wallets using the Mysten wallet-standard interface. A new Sui store manages connection state, persisting the connected wallet and address in session storage, and provides a signer that leverages the wallet's \sui:signAndExecuteTransaction\ or \sui:signTransaction\ features to handle transaction signing and execution.

app2/src/lib/wallet/sui · high confidence

New CosmWasm contracts have been introduced to the \cosmwasm/app\ directory. The \ucs03-zkgm\ contract implements a ZK-GM protocol for cross-chain asset management, supporting operations such as forwarding, calling contracts, batching, and token ordering (including escrow, initialization, and solving). It includes a token minter for managing wrapped tokens and rate-limiting via a token bucket mechanism. Additionally, the \ucs00-pingpong\ contract provides a basic IBC ping-pong test implementation, handling packet reception, timeouts, and channel lifecycle events. These contracts introduce new entry points, state structures, and error types for cross-chain interactions.

cosmwasm/app · high confidence

A new example contract is added at e2e/access-managed-example, implementing access control via the access-manager pattern. The contract exposes standard operations (increment, decrement, noop) alongside delegation and scheduling endpoints that route through the access manager, and includes a reply handler for scheduled operations. This provides a reference implementation for integrating access management into CosmWasm contracts.

e2e/access-managed-example · high confidence

Added the \lib/access-manager-types\ crate, which defines the core types, messages, and events for the access manager and access managed contracts, including role management, scheduled operations, and target configurations. Also added the \lib/cosmwasm-event\ proc-macro library to simplify deriving \cosmwasm\_std::Event\ implementations for these types.

lib/access-manager-types · high confidence

Added new utility functions in app2/src/lib/utils to support Svelte 5's $effect rune and the Effect library. This includes an 'effect.svelte' module providing 'runFork' and 'runPromiseExit' helpers for managing Effect lifecycles within Svelte components, alongside a 'snippets.svelte' file offering Svelte 5 snippets for handling Effect's Option and Exit types. Additional utilities include 'actions.ts' for click-outside detection, 'avatar.ts' for generating SVG avatars, 'convert-display.ts' for address conversion, 'json.ts' for safe circular JSON stringification, and 'queries.ts' for GraphQL and HTTP request handling with retry and caching logic.

app2/src/lib/utils · high confidence

The lib/base-client library now includes Rust code to query the L1 dispute game factory proxy contract. New functions allow retrieving the latest game count and the finalized L2 block number for a given L1 block, enabling clients to track dispute game state.

lib/base-client · medium confidence

Introduces a new \beacon-api\ library providing a client for the Ethereum Beacon API, including caching for spec and genesis data, and route handlers for blocks, headers, and light client updates. Additionally, adds \ethereum-sync-protocol-types\ for light client headers and updates, and \proof-lens-light-client-types\ for managing multi-chain client states, consensus states, and headers with support for JSON, bincode, and ethabi serialization.

lib/beacon-api · high confidence

A new \cargo-tidy\ tool has been added to the \tools/tidy\ directory. This utility enforces workspace hygiene by checking that all packages inherit workspace lints, use the \0.0.0\ version placeholder, and avoid duplicating dependencies that should be shared via \workspace.dependencies\. It also warns about unused \default-features\ settings and suggests promoting frequently used dependencies to workspace-level definitions.

tools/tidy · high confidence

The Voyager framework now includes new client-bootstrap modules for Arbitrum, Base, Bob, Gno, Movement, Parlia, and Proof-Lens, each implementing the \ClientBootstrapModule\ interface to provide initial client and consensus state information for their respective chains. These modules enable the Voyager system to bootstrap light clients for these specific networks, supporting both V1 and V2 client state formats where applicable, and integrating with the broader IBC-Union and state-lens infrastructure.

voyager/modules/client-bootstrap · high confidence

The ceremony module now includes a new client-side API layer to manage the contributor workflow. This introduces an HTTP client (http.ts) for making GET and POST requests to the backend, along with a client index (index.ts) that handles session validation, queue payload retrieval, and state checking. The change also adds TypeScript types (types.ts) to define the client status states and the body structure for the contribution endpoint, enabling the frontend to track and update the progress of a user's contribution.

ceremony/src/lib/client · high confidence

A new \lib/embed-commit\ library and \verifier\ binary are introduced to embed and extract the git commit hash from build artifacts. The Rust library defines a \Rev\ enum representing the build state (Unknown, Dirty, or a specific 20-byte hash) and exposes it via a static \GIT\_REV\ variable. The verifier tool can parse ELF and WASM binaries to extract this embedded commit information, enabling users to verify the exact code version of compiled artifacts.

lib/embed-commit · high confidence

The \lib/cometbft-types\ library now includes a complete set of Rust types for CometBFT protocol buffers, including ABCI, crypto, p2p, and core types (block, commit, vote, evidence, etc.). Each type implements Serde for JSON serialization and conversion traits for protobuf (both CometBFT and Tendermint) mappings. This enables the application to serialize and deserialize block data, validator information, and consensus messages in the standard formats expected by the network.

lib/cometbft-types · high confidence

The \lib/aptos-types\ library now includes a comprehensive set of Rust structs for handling Aptos blockchain data, including \AccountAddress\ with strict parsing and display logic, \BlockInfo\, \LedgerInfo\, \StateProof\, \TransactionInfo\, and related proof structures. These types enable the construction and verification of state and transaction proofs, allowing users to authenticate ledger state and transaction data against the chain's root hashes.

lib/aptos-types · high confidence

A new dynamic route at /contributions/\[hash\] has been added to display specific contribution data. Users can now view a public key and signature associated with a unique hash, with the ability to copy these values to the clipboard via dedicated buttons. The page fetches the contribution using the hash parameter and handles loading states and error conditions gracefully.

ceremony/src/routes/contributions · high confidence

A new CLI tool, tools/devnet-utils/src/main.rs, is introduced to support development and testing workflows. It provides commands for generating cryptographic keys (supporting both Ed25519 and Secp256k1 key types via mnemonic phrases) and computing CosmWasm Instantiate2 addresses. This consolidates previously scattered key generation and address computation logic into a single, accessible utility.

tools/devnet-utils · high confidence

A new route at /explorer/dust/\[packet\_hash\] has been added, allowing users to view detailed information about dust withdrawals. The page fetches and displays the status, amount, and timestamps associated with a specific packet hash, providing a dedicated view for tracking these specific types of withdrawals.

app2/src/routes/explorer/dust · high confidence

The TypeScript SDK now includes a \.env.example\ file defining environment variables such as \HUBBLE\_URL\ and \DRY\_RUN\, alongside a \.gitignore\ for build artifacts and caches. A \bun.lock\ file and \bunfig.toml\ configure the Bun runtime environment. Additionally, a \playground/\ directory has been added containing numerous example scripts (e.g., \babylon-to-holesky.ts\, \cw20-increase-allowance.ts\) that demonstrate how to use the SDK's transfer and query capabilities.

typescript-sdk · high confidence

A new route at /explorer/unstakes/\[packet\_hash\] has been added, allowing users to view the status, amount, and chain details of a specific unstake transaction using its packet hash. The page fetches data via a GraphQL query to the indexer, handling both success and failure states, and redirects to the stake page if the hash is invalid.

app2/src/routes/explorer/unstakes · high confidence

A new health status page has been added to the application, displaying the operational status of production, staging, and development environments. The page fetches health check data from respective API endpoints every 30 seconds, showing each environment's status (OK or ERROR), last update time, and environment color. It uses the Effect runtime for managing asynchronous health checks and displays a loading skeleton while data is being fetched.

app2/src/routes/health · medium confidence

The \lib/serde-utils\ crate now provides new helper modules for serializing and deserializing hex-encoded and base64-encoded byte arrays using Serde. This includes a \FromHexStringError\ type for robust hex parsing, a \to\_hex\ function, and dedicated Serde modules (\base64\, \inner\_base64\, \base64\_opt\, \base64\_opt\_default\) that handle base64 encoding/decoding for various optional and defaulting scenarios.

lib/serde-utils · high confidence

A new three-step process for checking and claiming BTCfi points has been added to the app. Step 1 allows users to connect their wallet or enter an address to check their points. Step 2 displays the user's points and eligibility for rewards. Step 3 enables users to verify ownership of their Babylon address by signing a message and linking an Ethereum address to receive rewards.

app2/src/routes/btcfi · high confidence

A new SenderInput.svelte component has been added to the multisig transfer flow. It provides a text input for the sender address, automatically validating the input against the Bech32 format (specifically 'bbn1' prefix) using the @unionlabs/sdk schema. On valid input, it updates the transfer data and registers the address with the wallet store; invalid inputs display specific error messages.

app2/src/lib/transfer/multisig/components · high confidence

A new native transfer page has been added at app2/src/routes/transfer/native/+page.svelte. The page implements a multi-phase transfer flow using a state machine (TransferSubmission) that progresses through states like Pending, Complete, or Failed. It includes a Submit button that triggers the transfer process and displays the current state, with UI updates to show 'Submitting...', 'Retry', or 'Submit' based on the transfer status.

app2/src/routes/transfer/native · high confidence

The Voyager event-source plugin architecture is expanded with new implementations for CosmWasm, EVM, Gno, Movement, and Starknet chains. Each plugin provides the necessary logic to fetch and parse IBC-related events from their respective chains, enabling Voyager to index and process IBC state and packet events for these networks.

voyager/plugins/event-source · high confidence

The Voyager system now includes new finality modules for Arbitrum, Base, Bob, Ethereum, Berachain, CometBLS, Gno, Movement, Parlia, Sui, and Tendermint. Each module implements the FinalityModule interface to query the latest finalized height and timestamp for its respective chain, enabling the Voyager to track finality across a wider range of networks.

voyager/modules/finality · high confidence

The Voyager proof module directory now includes eight new modules—attested, cosmwasm, ethermint, evm-mpt, gno, movement, parlia, and sui—each implementing the \ProofModule\ trait to generate state proofs for their respective chains. These modules enable the Voyager system to verify IBC state across a wider range of blockchain environments, including EVM-based chains, Cosmos SDK chains, and Move-based chains.

voyager/modules/proof · high confidence

A new nodes page has been added to the app2 application, providing a UI to monitor the health and response times of RPC endpoints for both Cosmos and EVM chains. The page fetches status data from each configured node, displaying whether each endpoint is OK, ERROR, or currently checking, allowing users to verify the connectivity of their node infrastructure.

app2/src/routes/nodes · high confidence

A new packet explorer page has been added at \app2/src/routes/explorer/packets/+page.svelte\. This page displays a list of packets using client-side GQL queries (\packetListLatestQuery\, \packetListPageGtQuery\, \packetListPageLtQuery\) and supports URL-based pagination via \page\ query parameters. It also includes a 'Mainnet Only' switch that filters the packet list, allowing users to toggle between mainnet and testnet data.

app2/src/routes/explorer/packets · high confidence

The transfers explorer page now supports paginated navigation via URL parameters, allowing users to move between pages of transfer data. A 'Mainnet Only' toggle lets users filter the displayed transfers to mainnet only. The page also displays error states and loading skeletons for a smoother user experience.

app2/src/routes/explorer/transfers · high confidence

A new \periodic-client-update\ plugin is introduced to periodically check the age of IBC clients and trigger updates when they lag behind the latest finalized height. The plugin exposes a \CheckForClientAge\ command that compares a client's current height against a configurable \max\_age\ threshold; if the client is too old, it initiates an update via \FetchUpdateHeaders\ and \WaitForTrustedHeight\, otherwise it schedules a deferred retry. This allows users to maintain up-to-date client states automatically.

voyager/plugins/periodic-client-update · high confidence

A new \reconnecting-jsonrpc-ws-client\ library is introduced, providing a WebSocket client that automatically handles reconnection logic. The implementation manages the lifecycle of the underlying \jsonrpsee\ client, spawning a background task to detect disconnections and attempt reconnection. It exposes methods to check connection health, wait for an active connection, and perform RPC requests or notifications, ensuring the application can maintain a stable connection to the server.

lib/reconnecting-jsonrpc-ws-client · high confidence

A new command-line tool, rustfmt-sort, has been added to the tools directory. It uses the clap library for argument parsing and the syn crate to parse and sort Rust source files. The tool reads a Rust file, partitions items to place all 'use' statements before other items, and sorts the remaining items by their token stream representation, outputting the result to the console.

tools/rustfmt-sort · high confidence

A new route at /explorer/stakes/\[packet\_hash\] has been added, allowing users to view the status and details of a specific stake by its packet hash. The page fetches bond data from the indexer, displaying the packet hash, amount, and a status indicator that reflects whether the bond and delivery phases succeeded, failed, or are pending.

app2/src/routes/explorer/stakes · high confidence

New state modules have been added to the Voyager SDK to support querying IBC state on multiple blockchain platforms. This includes CosmWasm (querying via CometBFT RPC and smart contract calls), EVM (using eth\_call and eth\_getLogs), Gno (via GraphQL and RPC), Movement (using Aptos REST client), and Sui (using the Sui SDK). Each module implements the StateModule trait for the IbcUnion specification, enabling the Voyager to fetch packet, connection, and client state from these specific chains.

voyager/modules/state · high confidence

The explorer homepage now displays cumulative statistics and daily activity charts for transfers and packets. Users can view key metrics in a grid of cards and interact with side-by-side bar charts that highlight the day with the highest activity, with synchronized hover states across both charts.

app2/src/routes/explorer · high confidence

A new command-line utility has been added at tools/parse-wasm-client-type that extracts and prints the Wasm client type from a given file. The tool accepts an optional expected client type argument; if provided, it validates the extracted type against the expected value, exiting with an error if they do not match.

tools/parse-wasm-client-type · high confidence

A new page has been added at /explorer/withdrawals/\[packet\_hash\] that allows users to view the status, amount, and timestamps of a specific withdrawal by its packet hash. The page fetches withdrawal data via GraphQL, handles lenient packet hash parsing, and displays the withdrawal's success or failure state, including send and receive timestamps.

app2/src/routes/explorer/withdrawals · high confidence

A new module was added to manage Cosmos blockchain wallet interactions. The \config.svelte.ts\ file introduces a \CosmosStore\ class that handles connection states (disconnected, connecting, connected) and persists wallet selection and address data to session storage. It supports connecting to Leap and Keplr wallets by suggesting the \union-1\ chain and retrieving the user's address. The \index.ts\ file exports this store, making the wallet connection logic available to the application.

app2/src/lib/wallet/cosmos · high confidence

Introduced a new LST configuration module that defines settings for mainnet, sepolia, and custom environments, including RPC endpoints, chain IDs, and contract addresses. Added a deterministic address prediction function for cross-chain operations and new schemas for staking rates, unstake requests, and batch statuses to support the staking workflow.

app2/src/lib/stake · high confidence

Introduced a new Parlia light client implementation, including the core interface definitions in \cosmwasm/core/light-client-interface\ and the specific Parlia client logic in \cosmwasm/lightclient/parlia\. This adds support for verifying Parlia consensus states and managing valset storage, enabling IBC connectivity for Parlia-based chains.

cosmwasm/core/light-client-interface, cosmwasm/lightclient/parlia · high confidence

The \lib/arbitrum-types\ crate now includes Rust definitions for the Arbitrum \RollupCore\ contract, covering both the legacy v1 state (including slot offsets for \\_latestNodeCreated\ and \\_nodes\ mapping) and the post-BoLD upgrade v2 state (including the \\_assertions\ mapping). This provides the necessary type definitions and constant slot values for interacting with the Arbitrum light client on L1.

lib/arbitrum-types · high confidence

Users can now view Sui token balances within the application. This change introduces new service files (balances.ts, clients.ts) that integrate with the Sui TypeScript SDK to fetch and display wallet balances, including error handling for missing RPC URLs and invalid hex formats.

app2/src/lib/services/sui · high confidence

A new plugin for handling Sui packet timeouts has been introduced. This plugin monitors IBC packet send events and manages the lifecycle of packet timeouts, including making timeout commitments and waiting for their completion. It is configured with a chain ID, RPC URL, and IBC store object ID, and subscribes to specific IBC events to trigger timeout processing.

voyager/plugins/sui-packet-timeout · high confidence

A new page at /transfer/ts-packets now renders the JSON output of off-chain packet builders (FungibleAssetOrder and Batch) using viem's encodeAbiParameters. This provides a visual representation of the constructed packets, allowing users to inspect the encoded data for the specific transfer routes defined in the SDK.

app2/src/routes/transfer/ts-packets · high confidence

Introduced the Zkgm protocol implementation for EVM chains, including the main \Zkgm\ contract, \Send\ and \TokenOrder\ logic, and supporting interfaces (\IZkgm\, \ISolver\, \IZkgmable\). This adds cross-chain asset transfer and order fulfillment capabilities, featuring deterministic wrapped token creation, proxy accounts, and a token bucket rate-limiting mechanism. The change also includes a \PingPong\ demo contract to test channel handshakes and packet routing.

evm/contracts/apps/ucs · medium confidence

The application now includes the database schema for the airdrop feature, introducing tables to track user allocations, allocation shares, pre-staking records, and referral codes. A materialized view calculates user social scores based on sharing and referral activity, while a new constant file defines wallet verification messages and supported EVM chain IDs.

app2/src/lib/dashboard/constants, app2/src/lib/database · high confidence

The eU drop route now includes a complete 6-step claim process. Step 1 handles social authentication (Twitter, GitHub, Discord). Step 2 connects an Ethereum wallet and validates the address against the claim beneficiary. Step 3 displays claim details and proof. Step 4 allows users to add the eU token to their wallet. Step 5 executes the on-chain claim transaction using the EUDROP contract. Step 6 confirms success and provides a link to the staking dashboard. The layout includes a new +layout.svelte and a claim folder with step components.

app2/src/routes/eudrop · high confidence

New, empty Svelte page components have been added for the /explorer/channels and /explorer/connections routes. These files currently contain no content, serving as structural placeholders for the application's navigation and layout system.

app2/src/routes/explorer/channels, app2/src/routes/explorer/connections · high confidence

The \tools/union-test\ module was introduced to provide a comprehensive end-to-end testing framework for the IBC and ZKGM protocols. This includes a \ChannelPool\ for managing channel pair lifecycles, and specialized modules for interacting with Cosmos and EVM chains. The new codebase adds helper functions for calculating contract addresses, constructing IBC datagrams, and waiting for specific blockchain events (such as packet acknowledgments and timeouts). This infrastructure enables automated testing of complex scenarios, including staking, refund logic, and multi-account interactions across different network types.

tools/union-test · high confidence

New utility files were added to ceremony/src/lib/utils: axiom.ts initializes the Axiom logging client; error.ts provides functions to capture and send Svelte and window errors to Axiom; utils.ts adds helpers for CSS class merging, ordinal number suffixes, Safari detection, OS detection, and time formatting. These changes enable better error tracking and provide reusable utility functions for the ceremony feature.

ceremony/src/lib/utils · high confidence

A new page at /explorer/packets/incomplete now displays a list of incomplete packets, supporting filtering by mainnet or testnet via an 'exceeding\_sla' query parameter. The page fetches data using a new 'missing-packets-list' query and renders each packet using a dedicated list component, with appropriate error handling and loading states.

app2/src/routes/explorer/packets/incomplete · high confidence

The app now includes a new liquid staking route featuring a two-step user flow. Step 1 provides social login options (Twitter, GitHub, Discord) to authenticate users, while Step 2 displays the user's pre-stake allocation amount. The implementation includes a new \StepLayout\ component for the layout, along with \LiquidStakingStep1\ and \LiquidStakingStep2\ components that handle the respective stages of the staking process.

app2/src/routes/liquid-staking · high confidence

A new Svelte component at app2/src/lib/transfer/multisig/index.svelte introduces the user interface for a multisig transfer workflow. The component manages a multi-step process (Filling, CheckMessage) using the Effect runtime and displays a step progress bar, handling state transitions and fiber interruption for the transfer context.

app2/src/lib/transfer/multisig · high confidence

The ceremony UI received three new Svelte components: Blink, which displays a random blinking eye animation; Circles, which renders a rotating border animation; and Spinner, a standard loading indicator. These components are now available for use within the ceremony application.

ceremony/src/lib/components · high confidence

New Node.js scripts were added to the \scripts/\ directory to support the TypeScript SDKs (\ts-sdk\, \ts-sdk-evm\, \ts-sdk-cosmos\, \ts-sdk-sui\). \circular.mjs\ detects circular dependencies in the SDK source files, \clean.mjs\ removes build artifacts and documentation directories for the SDKs, and \docs.mjs\ copies generated documentation files into the main documentation site. These scripts facilitate the migration and stabilization of the SDKs.

scripts · high confidence

New example scripts for bonding and unbonding assets across the Ethereum and Union testnets. The \bond.ts\ and \unbond.ts\ files demonstrate how to interact with the staking hub, manage ERC-20 allowances, and execute cross-chain transfers using the SDK.

app2/examples · high confidence

The App 2 area is initialized with a new CSS file defining the 'Geist' font family, a dark-mode theme using oklch color variables, and a styled scrollbar. The app.html template adds favicons and a manifest link, while hooks.client.ts implements an Effect-based runtime for handling uncaught errors and unhandled rejections, alongside a storage cleanup routine. Additionally, a humorous privacy policy page is added, and app.d.ts extends the global Window interface to include Keplr and Leap wallet types.

app2/src · high confidence

The application now uses a centralized configuration module that provides app metadata (name, base URL, documentation link, icon, and project ID) for different editions (e.g., 'app', 'btc'). This change allows the application to dynamically load settings based on the current edition, supporting a multi-edition architecture where each edition has its own unique identifier and base URL.

app2/src/lib/config · high confidence

The end-to-end (e2e) testing suite has been restructured into a modular Nix-based framework. The new setup defines reusable node configurations (such as \unionNode\ and \devnetEthNode\) and test scripts for specific scenarios including epoch staking, forced set rotation, and software upgrades. This change replaces the previous ad-hoc test definitions with a centralized \all-tests.nix\ entry point that aggregates these distinct test modules, ensuring consistent resource allocation and environment setup for each test case.

e2e · high confidence

The repository now includes foundational documentation and configuration files that define how the project is maintained. A new ARCHITECTURE.md provides a high-level overview of the system, while CONTRIBUTING.md outlines the workflow for submitting changes, including commit signing and formatting rules. Repository behavior is standardized via .gitattributes for large file handling, .gitignore for build artifacts, and .git-blame-ignore-revs to exclude formatting commits from blame. Additionally, a .envrc file configures the development environment, and a CODEOWNERS file assigns maintenance responsibilities for key directories.

(repo-wide) · high confidence

The Ethereum light client sync protocol logic has been extracted into a new \lib/ethereum-sync-protocol\ crate. This new module provides the core validation logic for light client updates, including signature verification, sync committee checks, and header validation. The implementation includes comprehensive error handling for invalid updates, signature failures, and state mismatches, along with utility functions for computing slots, epochs, and fork versions. Test data for light client updates and sync committees has also been added to the new library.

lib/ethereum-sync-protocol · high confidence

A new Rust crate, aptos-move-ibc, has been added to provide generated bindings for the Aptos Move IBC module. This crate exposes a ClientExt trait that allows Rust code to interact with the Aptos blockchain, including methods to fetch client and consensus states, and to construct transactions for IBC connection handshake steps (init, try, ack, confirm).

generated/rust/aptos-move-ibc · high confidence

The ceremony site is introduced with a new SvelteKit application structure, including the root layout (app.html) and TypeScript declarations (app.d.ts). A client-side error handling hook (hooks.client.ts) is added to capture and log errors, ensuring users receive a friendly error message instead of a raw exception.

ceremony/src · medium confidence

The App2 root layout is established with a global background video that plays on desktop and a static image on mobile. The layout renders the site header, a fixed sidebar navigation, and a scrollable main content area. It also mounts global modals for settings and errors, displays developer information, and registers keyboard shortcuts for edition switching and filtering. On load, it fetches chain and channel data and applies theme colors to CSS variables.

app2/src/routes · high confidence

A new application, app2, is introduced as a Svelte 5-based frontend that leverages the Effect runtime for error handling and state management. The setup includes a Nix build configuration (app2.nix) that integrates with the monorepo's PNPM workspaces, TypeScript project references, and static analysis checks. The app2 directory also establishes development and build tooling, including ESLint, Knip, Vitest, and SvelteKit configuration, alongside documentation (CONVENTIONS.md, README.md) and a .gitignore to standardize the new codebase.

app2 · high confidence

The Aptos IBC module is added, providing a Move-based implementation of the IBC protocol that enables permissionless smart contracts to plug in and perform general message passing and asset transfers. The update includes the core IBC state structures (channels, connections, light clients), packet handling (send, receive, acknowledge, timeout), and a dispatcher system that allows applications to register callbacks for IBC events. This establishes the foundational layer for cross-chain communication on Aptos.

aptos/ibc · high confidence

Added new Arbitrum light client modules (v1 and v2) that provide functions to query L1 contract state and retrieve finalized L2 blocks. The v1 implementation retrieves the latest confirmed node number and decodes NodeCreated events, while the v2 implementation fetches AssertionCreated events with a hardcoded 10,000 block range to avoid RPC response size errors. Both versions expose helper functions to map L1 block heights to L2 block data, supporting the revival of the Arbitrum light client feature.

lib/arbitrum-client · high confidence

The Arbitrum light client implementation now includes dedicated verification logic for both v1 and v2 protocol versions. For v1, the verifier validates the L1 contract address proof, the latest node created slot, node confirm data, and the L2 IBC handler root. For v2, it verifies the L1 contract proof, L2 header against assertion state, assertions proof, assertion status, and the L2 IBC handler root. This provides the necessary cryptographic proofs to validate headers from the Arbitrum chain against the L1 state root.

lib/arbitrum-verifier · high confidence

Added new Rust types for the Base light client, including \ClientState\, \ConsensusState\, and \Header\ structures that define the data structures used to verify the state of the Base L2 chain. This includes support for serializing these types with Serde and Bincode, and mapping them to Ethereum ABI types for smart contract interactions.

lib/base-light-client-types · high confidence

Added the \bob-light-client-types\ library, defining the Rust types for the Bob light client. This includes \ClientState\ (with \V1\ and \V2\ variants for Bedrock compatibility), \ConsensusState\, and \Header\ structures, enabling the client to verify state roots and headers for both legacy and newer contract versions.

lib/bob-light-client-types · high confidence

The CW Escrow Vault is a new CosmWasm smart contract that acts as an automated market maker (solver) in the UCS03 ZKGM protocol, enabling fungible cross-chain asset transfers between Cosmos and EVM chains. It manages the escrow and release of native and CW20 tokens, serving as the Cosmos-side counterparty to the UnionversalToken.sol contract on EVM chains. The contract implements the ISolver interface to fill orders, holding tokens in escrow for future reverse transfers and maintaining 1:1 backing between native and synthetic tokens.

cosmwasm/cw-escrow-vault · high confidence

The \cairo/zkgm\ directory now contains the initial implementation of the zkgm Starknet contract and its supporting library. This adds a new Cairo contract (\Ucs03Zkgm\) that handles IBC packet reception and channel lifecycle events, alongside interfaces for solvers and ERC20 tokens. The change also introduces a Cairo library (\lib.cairo\) providing core logic for token prediction, path manipulation, and encoding, as well as type definitions for packets, instructions, and events. The project is configured with \Scarb.toml\ and \Scarb.lock\ dependencies on the \alexandria\ and \ibc\ crates.

cairo/zkgm · high confidence

A new \cometbls-groth16-verifier\ crate has been added to the codebase. It implements the verification logic for CometBLS light clients using the Groth16 zero-knowledge proof system. The crate includes a build script (\build.rs\) that parses a \verifying\_key.bin\ file at compile time to generate Rust constants, and provides a \ZKP\ struct for deserializing and verifying proofs using the \substrate\_bn\ library.

lib/cometbls-groth16-verifier · high confidence

Added a new Rust-based deployer tool (\cosmwasm/deployer\) that enables deterministic contract deployment on CosmWasm chains. The tooling includes a minimal base bytecode template (\base-bytecode.wat\) and a comprehensive CLI (\main.rs\) supporting full deployment workflows: storing and instantiating contracts with salts for predictable addresses, managing access control roles (relayer, pauser, rate limiter), and executing migrations. This provides the infrastructure for automated, permissioned, and standard CosmWasm chain deployments.

cosmwasm/deployer · high confidence

Added new files in app2/src/lib/services/cosmos to handle Cosmos chain interactions. balances.ts implements fetching of Cosmos and CosmWasm token balances using the Effect library and the @unionlabs/sdk schema. clients.ts provides functions to create CosmWasm and SigningCosmWasm clients, including wallet connection logic. types.ts defines TypeScript interfaces for Cosmos wallet interactions, signatures, and fees.

app2/src/lib/services/cosmos · medium confidence

A new Drip service is introduced to provide a GraphQL-based faucet for Cosmos chains. It supports multiple chains and multiple denoms per chain, with configuration managed via a JSON config file. The service includes a Turnstile (Cloudflare) integration for request validation and uses SQLite for tracking requests. Example requests for 'union-devnet' and 'stargaze-devnet' are provided to demonstrate usage.

drip · high confidence

Added new Solidity contracts to the EVM stack: \CrosschainEscrowVault\ and \CrosschainVault\ for managing cross-chain fungible assets and staking instructions, alongside a \Manager\ contract for role-based access control and a \Multicall\ utility. These contracts enable the Zkgm protocol to execute market-making strategies and handle token bridging on EVM chains, while the \Manager\ enforces permissions for relayers and administrators.

evm · high confidence

Added a new \evm-storage-verifier\ crate that provides functions to verify EVM storage proofs against a given state root. The library implements RLP node codec for Ethereum's trie structure and exposes public APIs (\verify\_storage\_proof\, \verify\_storage\_absence\, \verify\_account\_storage\_root\, \verify\_account\_code\_hash\) to validate storage values and account states using Merkle proofs. The implementation relies on \unionlabs\_primitives\ for hash types and includes test data for Sepolia network proofs.

lib/evm-storage-verifier · high confidence

The app2 frontend now includes a new EVM transfer service located at app2/src/lib/services/transfer-ucs03-evm. This update introduces a state machine (machine.ts) that orchestrates the transfer lifecycle, including switching chains, submitting ERC20 approvals, and handling transaction receipts. The implementation leverages the Effect library for managing asynchronous operations and error states, with dedicated modules for account management, chain switching, channel validation, and transaction submission. Custom error types are defined to provide specific feedback for wallet and contract interaction failures.

app2/src/lib/services/transfer-ucs03-evm · high confidence

Added new type definitions for the Ethereum light client, including \ClientState\, \ConsensusState\, \Header\, \LightClientUpdate\, and related structures, all supporting both JSON and Bincode serialization. Additionally, introduced the \gno-client\ library, providing a \TxClient\ for broadcasting transactions and a \LocalSigner\ for ECDSA signing, along with gas fee calculation utilities.

lib/ethereum-light-client-types · high confidence

Added the \lib/ibc-solidity/src/lib.rs\ file, which defines the \Ibc\ Solidity contract and associated types. This new library exposes the core IBC interface, including client, connection, channel, and packet handling functions, along with corresponding events for tracking state changes on the Ethereum Virtual Machine (EVM) and other EVM-compatible chains.

lib/ibc-solidity · high confidence

The \ibc-union-spec\ library now provides a comprehensive set of Rust types and interfaces for the IBC Union protocol. This includes the \Datagram\ and \FullEvent\ enums to represent IBC messages and chain events, along with specific message structs (e.g., \MsgCreateClient\, \MsgChannelOpenInit\) and event structs (e.g., \CreateClient\, \PacketSend\). The module also defines the \IbcUnion\ spec implementation, which ties these types to the \voyager\_primitives\ and \unionlabs\ frameworks, enabling consistent handling of client states, connections, channels, and packet flows across the network.

lib/ibc-union-spec · high confidence

Added the \lib/ics23\ crate, implementing the ICS-23 specification for Merkle tree verification. This includes core modules for leaf, inner, and hash operations, as well as APIs for verifying membership and non-membership proofs. The library supports IAVL and Tendermint proof specs and includes a comprehensive test suite to validate the implementation against the ICS-23 standard.

lib/ics23 · high confidence

Added the initial structure for the Multi-Party Computation (MPC) ceremony, including a README, Nix build definitions, and a Supabase project configuration. The Supabase setup includes database schemas for user pings, wallet addresses, waitlists, and a queue system with scoring. Additionally, new edge functions were added to send email notifications about contribution slots and queue positions, utilizing the Resend API for email delivery.

mpc · high confidence

A new Rust-based CLI tool has been added to the MPC coordinator to automate the lifecycle of a distributed computation round. The tool connects to a Supabase backend to fetch the current payload and contributor, then downloads the next payload, verifies the contributor's GPG-signed public key and signature, and finally validates the cryptographic contribution. Users can now run the coordinator as a long-running process that handles downloading, verifying, and progressing through MPC rounds with structured logging.

mpc/coordinator · high confidence

A new proc-macro derive for \MoveOutputType\ has been added to \lib/move-bindgen-derive\. This macro automatically generates implementations that map between a Rust struct and a corresponding 'Raw' struct, handling field-by-field conversion via \from\_raw\ and \into\_raw\. This enables seamless integration with the Move bindgen system by providing the necessary traits for type-safe serialization and deserialization of Move output types.

lib/move-bindgen-derive · medium confidence

Added new Rust type definitions for the Movement light client, including ClientState, ConsensusState, and Header structs. These types encapsulate the state and header data required for light client verification, with support for Serde and Bincode serialization.

lib/movement-light-client-types · high confidence

The repository now uses a Nix-based build system to compile CosmWasm contracts (such as cw-account, cw-escrow-vault, and cw20-base) and manage deployment configurations for various networks (including devnet, testnet, and mainnet chains like Osmosis). This change replaces previous build and deployment workflows with a structured, reproducible Nix derivation that handles contract compilation, bytecode generation, and deployment script execution, making it easier to build and deploy contracts across different environments.

cosmwasm · high confidence

Added the Osmosis TokenFactory token minter contract, which handles minting, burning, and escrowing of native tokens, and a corresponding owner contract that delegates admin operations. The minter supports creating denoms via the ZKGM interface (v2), manages token ownership, and constructs bank metadata for tokenfactory tokens.

cosmwasm/osmosis-tokenfactory-token-minter · high confidence

Added the Parlia light client types, including client state, consensus state, header, misbehaviour, and state proof structures. This enables the IBC core contract to verify Parlia headers and validate state proofs for cross-chain communication.

lib/parlia-light-client-types · high confidence

Added the Parlia light client verifier and associated types, enabling validation of Parlia block headers and vote attestations. The new \parlia-verifier\ crate provides functions to parse header extra data, extract vote attestations, and verify header chains against a trusted validator set, including support for epoch rotation blocks and ancestor proofs. The \parlia-types\ crate defines the core data structures, including \VoteAttestation\, \Valset\, and \ParliaHeader\, with RLP and serde serialization support.

lib/parlia-verifier · high confidence

Add a new 'sentinel2' service that runs five concurrent background loops: IBC packet error tracking, escrow supply control, Babylon account funding, signer balance checks, and SSL certificate expiry monitoring. The service uses a SQLite database to track open incidents and integrates with BetterStack for alerting, with all configuration (endpoints, mnemonics, intervals) passed via a JSON config file.

sentinel2 · high confidence

Added a new Rust crate, lib/solidity-slot, which implements the Solidity storage layout algorithm. This library provides the core logic for calculating storage slots for complex data structures like mappings, arrays, and structs, including support for Keccak-256 hashing and offset calculations as defined by the Solidity specification.

lib/solidity-slot · high confidence

Added a new Supabase client configuration in \ceremony/src/lib/supabase/client.ts\ that manages session refresh every 30 minutes, and created a comprehensive data access layer (\index.ts\, \queries.ts\) that provides functions to query user states, queue positions, contributions, and wallet addresses from the Supabase database.

ceremony/src/lib/supabase · high confidence

A new \token-factory-api\ library is added to provide structured message and query types for interacting with the Osmosis Token Factory. This includes definitions for minting, burning, and transferring tokens, as well as querying denom metadata and admin status, enabling contracts to manage native tokens created via the Token Factory module.

cosmwasm/token-factory-api · high confidence

Adds the \ts-sdk-sui\ package, providing a TypeScript SDK for interacting with the Sui blockchain. The implementation includes public and wallet client layers, contract read/write utilities, and a Zkgm client for cross-chain operations. Example scripts demonstrate how to read coin metadata and balances, as well as execute contract calls and transfers on the Sui testnet.

ts-sdk-evm, ts-sdk-sui · high confidence

Added the \lib/ucs04\ Rust crate, which implements the UCS04 standard for universal chain IDs. The crate parses and validates chain identifiers composed of a family name and a chain ID, with a build script that generates Rust code from \well-known.json\ to provide compile-time constants and a \Family\ enum for all registered chain families. This enables developers to work with universal chain IDs in a type-safe manner, supporting both borrowed and owned representations of chain identifiers.

lib/ucs04 · high confidence

The cw-unionversal-token contract has been introduced, providing a token implementation that supports both standard CW20 and Tokenfactory-based tokens. The contract now manages access control externally via the access\_managed framework, removing internal access management logic and migrating to version 2 state. It supports solvable packet handling with intent whitelisting and fungible lane configuration, while maintaining compatibility with existing CW20 and tokenfactory implementations.

cosmwasm/cw-unionversal-token · medium confidence

Unionvisor is a new utility for managing \uniond\ deployments, acting as a systemd service that handles the lifecycle of \uniond\ by managing a symlink called \current\ and swapping it to newer \uniond\ versions when an upgrade signal occurs. It consumes Union Bundles, which are directories of static binaries containing each version of \uniond\ for a specific network, and provides commands to initialize, run, and manage these bundles. The implementation includes a CLI interface, logging configuration, and a symlinker to manage version upgrades.

unionvisor · high confidence

The \lib/voyager-plugin-protocol\ crate is added, establishing the communication layer between Voyager's coordinator and worker plugins. It implements a JSON-RPC-over-IPC architecture where the coordinator manages and routes messages to workers, which respond to those messages. The implementation includes a \WorkerClient\ for automatic reconnection, configurable message size limits (10x the default 10MB), and OpenTelemetry tracing integration for RPC methods.

lib/voyager-plugin-protocol · high confidence

The transaction-batch plugin is introduced to handle and batch IBC events (both IBC Classic and IBC Union) into transaction batches. It groups events by client ID and applies configurable batching rules (min/max batch size, max wait time) to optimize client updates. The plugin ensures that messages are batched with as few client updates as possible, sorting messages by their age within batches and generating client updates for the maximum provable height of all batches. It also handles cases where proofs are unavailable and manages the lifecycle of batched transactions, including waiting for specific heights and ensuring that updates are only queued when necessary.

voyager/plugins/transaction-batch · high confidence

A new \VoyagerClient\ struct is added to \lib/voyager-client\, providing a unified client for interacting with the Voyager RPC. It exposes methods to query chain state (latest height and timestamp), retrieve self client and consensus states, and encode/decode IBC proofs and states, enabling external components to communicate with the Voyager service.

lib/voyager-client · high confidence

A new \zkgm-filter\ plugin has been added to the Voyager plugin suite. This component implements filtering logic for ZKGM (Zero-Knowledge Global Market) packets, including support for both Cosmos and EVM chain providers, database integration for tracking invalid checksums, and configuration options to drop protocol fill acknowledgments, invalid checksums, or suspicious packets.

voyager/plugins/transaction-batch-proof-lens, voyager/plugins/zkgm-filter · high confidence

The repository now exposes a new public API for managing wrapped tokens across chains. This includes message types for escrowing and unescrowing local funds, as well as creating and managing wrapped tokens via CW20 contracts or Osmosis Token Factory. The API defines structured messages for minting and burning tokens, alongside queries for token metadata, enabling the ZKGM system to handle token lifecycle events and state transitions.

cosmwasm/ucs03-zkgm-token-minter-api · high confidence

Added a new \lib/ucs03-zkgm-packet\ library that implements encoding and decoding for Zkgm packets, supporting batched, forwarded, and direct call instructions. This enables the system to serialize and deserialize complex cross-chain operations, including token orders and contract calls, using the \ucs03\_zkgm\ protocol. The implementation includes dedicated modules for \batch\, \call\, \forward\, \root\, and \token\_order\ instructions, each with corresponding acknowledgment handling and shape definitions. A test in \lib.rs\ validates the decoding of a sample packet containing a token order and a call instruction.

lib/ucs03-zkgm-packet · high confidence

A new \depolama\ library has been added to provide a simple, low-level storage interface for CosmWasm contracts. It introduces a \Store\ trait that allows contracts to define custom key and value codecs, supporting both manual encoding and integration with the \unionlabs-encoding\ framework. The library also provides an \iter\_range\ method for efficient range-based storage iteration.

lib/depolama · high confidence

The ceremony interface has been replaced with a new terminal-style UI. This includes a main layout with tabs for Core, Logs, and Users, alongside a task bar and printer components. Specific workflow steps are now handled by dedicated components: authentication (Authenticate), code entry and queue joining (Code), a waitlist prompt (Waitlist), secret generation (Secret), address entry (Reward), queue status and wait times (Queue), contribution timer (Timer), and a final thanks page (Thanks). The Activity component displays a live feed of user events, while the Contributors component lists user contributions.

ceremony/src/lib/components/Terminal · high confidence

Added a new \access-managed\ module that implements an \AccessManaged\-style permissioning wrapper (\Restricted\<T\>\) for CosmWasm contracts, enforcing that all entrypoints are controlled by an authority contract. This module provides functions to query and set the current authority, and supports scheduled operations with a consuming schedule flag. Additionally, a \gatekeeper\ module was added, which integrates the access manager with an \Upgradable\ interface, ensuring that upgrade operations are authorized by the access manager's role-based system. The changes include new source files for contract logic, error handling, state management, and comprehensive tests for both modules.

cosmwasm/access-managed · high confidence

A new \aptos-verifier\ library has been added to the workspace, providing cryptographic verification for Aptos blockchain state and transactions. The library implements functions to verify transaction states against accumulator root hashes and to validate sparse Merkle inclusion proofs for storage data. It defines specific error types for hash mismatches, proof depth limits, and storage verification failures, enabling other components to validate Aptos ledger and transaction proofs.

lib/aptos-verifier · high confidence

Added the \lib/base-verifier\ library, which provides a \verify\_header\ function to validate L2 headers against L1 state roots. This new component handles verification of dispute game proofs, output root hashes, and IBC contract accounts, enabling the system to verify the state of the Base network on Ethereum.

lib/base-verifier · high confidence

A new AppErrors component has been added to display global application errors in a centralized location. The component iterates over error stores for chains, channels, and token fetchers, rendering each error using a shared ErrorComponent. This provides users with a consolidated view of system-wide errors.

app2/src/lib/components/layout/AppErrors · high confidence

The ceremony site now includes a new layout structure with authentication checks and metadata configuration. The \+layout.svelte\ file sets up the page title, Open Graph and Twitter card metadata, and global error handling. The \+layout.ts\ file implements server-side rendering configuration and redirects unauthenticated users away from the \/terminal\ route. The \+page.svelte\ file manages the main content display, conditionally rendering components like \Authenticate\, \Queue\, \Secret\, and \Thanks\ based on the user's contribution state.

ceremony/src/routes · high confidence

The ceremony directory now contains a fully configured SvelteKit application. It includes a Nix build definition (ceremony.nix) that sets up a pnpm-based build environment, along with standard configuration files for Tailwind CSS, PostCSS, and TypeScript. The app is configured to connect to a Supabase backend using environment variables, and the build process strips console logs in production.

ceremony · high confidence

A new Rust library, lib/chain-kitchen, has been added to generate standardized HTTPS endpoints for chain data. The library provides an Endpoint struct that constructs URLs in the format https://{protocol}.{id}.{family}.chain.kitchen, supporting optional tags in the subdomain. This enables consistent access to RPC, REST, and Beacon protocol endpoints for any supported chain family.

lib/chain-kitchen · high confidence

A new \concurrent-keyring\ library has been added to manage cryptographic keys across multiple chains. It provides a \ConcurrentKeyring\ struct that maintains a pool of signers and rotates through them using a thread-safe queue, allowing concurrent access to keys without blocking. The library also includes a \PrivateKey\ type for handling raw private keys in hex format, supporting both file-based and raw key configurations.

lib/concurrent-keyring · high confidence

The new \cw-account\ contract provides proxy account functionality, allowing both local admins (accounts on this chain) and remote admins (via ucs03-zkgm) to dispatch messages on behalf of the contract. This enables cross-chain account ownership and arbitrary message execution through the ucs03-zkgm \Call\ opcode. The contract supports both standard contract instantiation and \frissitheto\ initialization, with entrypoints for setting the zkgm address, adding/removing admins, dispatching messages, and handling cross-chain execution via the \Zkgmable\ interface.

cosmwasm/cw-account · medium confidence

The cw20-base module now provides a complete, deployable implementation of the CW20 token standard, including base token functionality, minting capabilities, and allowance management. Users can deploy this contract directly or import its logic to build custom ERC20-compatible tokens. The implementation includes all standard CW20 messages (transfer, approve, spend\_from, etc.) along with enumerable queries for balances and allowances, and supports marketing metadata and logo storage.

cosmwasm/cw20-base · high confidence

The dashboard now exposes a structured query layer that fetches public data (achievements, levels, categories, missions, rewards, chains, and the leaderboard) and private user-specific data (user achievements, experience, missions, rewards, and wallets). This new module, located in app2/src/lib/dashboard/queries, also defines TypeScript types for wallet verification, edge function responses, and other dashboard-related entities, enabling the UI to retrieve and display user progress and available actions.

app2/src/lib/dashboard/queries · high confidence

A new Nix module for devnet-compose has been added, defining a build workspace member and constructing a Docker image that bundles the compiled binary with coreutils and cacert, setting the appropriate entrypoint and environment variables.

devnet-compose · high confidence

Added a new Rust-based tool, devnet-compose, which generates process-compose configurations for local development. It supports configuring networks (Union, Osmosis, Stargaze, Simd) and their IBC connections, including automatic setup of Voyager relay, database migrations, and Galois circuit services for Union. The tool provides an interactive CLI for selecting networks and connections, and manages process dependencies, health checks, and logging.

devnet-compose/src · high confidence

Added a new \effect-svelte\ package that integrates the Effect library with Svelte. This includes a \Runtime\ module providing Svelte-friendly wrappers for Effect execution (\runFork\, \runPromiseExit\) that manage fiber lifecycles and state updates, a \Snippets\ module offering Svelte template helpers for matching on Effect ADTs (Option, Either, Exit), and a \SvelteConfigProvider\ for SvelteKit environment variable interoperability. The package also includes a SvelteKit application structure with a client hook for runtime initialization, a Nix build configuration, and comprehensive test coverage for the new functionality.

effect-svelte · high confidence

Added the \frissitheto\ library, which provides a mechanism for managing state versions in upgradable CosmWasm contracts. The library introduces an \UpgradeMsg\ enum to handle contract initialization and migration, ensuring that state versions are tracked and incremented correctly. It includes functions to initialize the state version and manage migrations, with specific error handling for cases like already-initiated contracts or invalid state version changes.

lib/frissitheto · medium confidence

The galoisd daemon is introduced as a gRPC service for generating and verifying zero-knowledge proofs for CometBLS block headers. It exposes endpoints for proving, verifying, and generating Solidity verifier contracts, alongside commands for managing Groth16 multi-party computation phases. The service includes a health check endpoint and supports both BN254 and BLS12-381 circuits, with configuration for connection limits and log levels.

galoisd · high confidence

Added a new gas price service that retrieves gas prices for EVM and Cosmos-based chains. For EVM chains, it fetches the base gas price and, for specific chains like BOB, also calculates the L1 data fee. For Cosmos chains, it retrieves the average gas price from the chain configuration. The service is implemented using the Effect framework and includes a custom error type for handling failures.

app2/src/lib/gasprice · high confidence

The \state-lens-light-client-types\ library now provides the core data structures for state lens light clients, including a generic \ClientState\ that tracks L1/L2 chain IDs, client IDs, and latest heights, along with a \Header\ struct for consensus state proofs. These types support serialization via Serde (JSON), Bincode, and EthAbi (Solidity), enabling consistent encoding and decoding for state lens client interactions.

lib/state-lens-light-client-types · high confidence

Added a new Rust library, \gnark-key-parser\, which provides parsers for Groth16 verification keys. The library includes modules for \bls12-381\ and \bn254\ curves, defining structs for \VerifyingKey\ and \PedersenVerifyingKey\ to hold elliptic curve points and commitment keys. It also includes an error handling module and a utility function \reencode\_evm\_zkp\_for\_sui\ to transform ZKP data for Sui integration.

lib/gnark-key-parser · high confidence

A new standalone plugin, \voyager/plugins/packet-index\, has been added to the Voyager SDK. This plugin implements logic to track IBC packets by querying chain state (channels, connections, and packet commitments) to determine packet status and generate events. It introduces a \ModuleCall\ enum with a \MakePacketEvent\ variant that accepts a chain ID, channel ID, packet hash, and an intent flag, allowing the system to process and index packet lifecycle events.

voyager/plugins/packet-index · high confidence

The app now defines a unified \InternalChainInfo\ schema and a \chainInfoMap\ to manage Cosmos chain configurations. New files introduce type-safe adapters to transform this internal representation into the specific formats required by Keplr and Leap wallet extensions, ensuring consistent chain data handling across different wallet providers.

app2/src/lib/services/cosmos/chain-info · high confidence

The lst-ocw component is now available as a NixOS module that configures a systemd service for the lst-ocw background process, with configurable RPC URL, private key, and log settings. The Rust application also provides a CLI with commands to run the background worker or query pending, submitted, and received batches from the lst-hub contract.

cosmwasm/lst-ocw · medium confidence

The \cometbft-rpc\ library now provides a new RPC client implementation using \jsonrpsee\ for both HTTP and WebSocket connections, along with updated Rust types for RPC responses. This includes handling optional hash fields in the \/status\ endpoint and supporting auto-paginated validator queries. The change also adds a custom serde module for handling empty hashes and introduces test data for validators and status responses to ensure correct deserialization.

lib/cometbft-rpc · high confidence

Added a new MPC client application (\mpc/client\) that provides a terminal-based UI for managing the contribution process, including downloading payloads, computing contributions, and uploading results. The client uses a new \mpc/shared\ library to interact with a Supabase backend for tracking contributors and payloads, and calls an external \galois\ library for Phase 2 contribution and verification. The client manages temporary directories for each contributor, generates PGP keys for signing, and exposes \/contribute\ and \/secret\_key\ endpoints to coordinate the workflow.

mpc/client · high confidence

The Voyager message library has been restructured to define explicit message types for the Voyager system. This includes the \Call\ enum for actions like indexing blocks, fetching headers, and submitting transactions; the \Callback\ enum for aggregating transaction submissions; and the \Data\ enum for handling IBC events, datagrams, and ordered headers. These types are now part of the \voyager-message\ crate, implementing the \QueueMessage\ trait to facilitate message passing between the Voyager core and its plugins.

lib/voyager-message · high confidence

A comprehensive set of new Svelte stores has been added to app2/src/lib/stores to manage application state. This includes stores for tracking errors, fetching and sorting token balances across EVM, Cosmos, Sui, and Aptos chains, and managing transfer and packet data. The update also introduces stores for fee calculations, statistics, and UI settings, alongside a new keyboard shortcut system and a banner configuration store.

app2/src/lib/stores · high confidence

A new \filling.ts\ service has been added to manage the state machine for the transfer flow. This file defines the \CreateContextState\ enum and the \createContextState\ function, which orchestrates the transfer process through validation, context creation, balance and allowance checks, and final step generation. The implementation uses the \effect\ library for side-effect management and includes specific handling for various states such as wallet connection, chain selection, and fee validation.

app2/src/lib/transfer/normal/services · high confidence

The \lib/unionlabs-primitives\ crate now provides a suite of new primitive types and encoding utilities. This includes \FixedBytes\ (renamed from \Hash\), \Bytes\, \U256\, and \Bech32\ types, each supporting \serde\ and \bincode\ serialization. The crate also introduces an \Encoding\ trait with implementations for \HexPrefixed\, \HexUnprefixed\, \Base64\, and \Base58\ formats. Additionally, compatibility shims for \primitive\_types\, \generic\_array\, and \alloy\_primitives\ are provided to ease integration with existing libraries.

lib/unionlabs-primitives · high confidence

The app2 sidebar has been replaced with a new layout component that displays the Union logo, user profile card, and a structured navigation menu. The navigation is now driven by a dedicated configuration file that defines menu sections for core features (Transfer, Explorer, Staking, BTCfi), a Developer section, and external links (Discord, Twitter, GitHub). The sidebar also includes a wallet connection button at the bottom.

app2/src/lib/components/layout/Sidebar · high confidence

Added new Rust types for the state lens light client, including \ClientState\ and \ConsensusState\ structs that define the data structures used by the light client. These types support serialization via Bincode and EthAbi, enabling interoperability with the Voyager RPC and Ethereum-based clients. The \ClientState\ includes offsets for extracting timestamp, state root, and storage root from the L2 consensus state, while \ConsensusState\ holds the timestamp and relevant hashes. Tests verify correct encoding/decoding for both formats.

lib/state-lens-ics23-mpt-light-client-types · high confidence

The ceremony state management has been refactored into dedicated Svelte classes: Contributor, Terminal, and Activity. The Contributor class now manages the user's lifecycle, including queue position, contribution status, and polling intervals. The Terminal class handles UI state, history logging, and keyboard events. The Activity class manages real-time log updates from the database. These classes are exported and wired together in the new index.svelte.ts, providing a structured approach to managing the ceremony's complex state.

ceremony/src/lib/state · high confidence

A new CosmWasm contract, on-zkgm-call-proxy, has been added to enable routing of Zkgm (cross-chain) messages. The contract allows users to forward messages to other contracts, supporting both direct execution and an indirection layer via the OnProxyOnZkgmCall entrypoint. It enforces that only the Zkgm contract can trigger these calls, preventing unauthorized access, and explicitly forbids nested proxy calls to maintain security boundaries.

cosmwasm/on-zkgm-call-proxy · high confidence

Added two new Voyager plugins: a packet-batch plugin that groups and processes batched send and acknowledgement packets, and a packet-timeout plugin that monitors for packet timeouts and generates the necessary proof and transaction messages. These plugins enable the Voyager system to handle IBC packet lifecycle events (send, ack, timeout) with dedicated logic for batching and timeout detection.

voyager/plugins/packet-timeout · high confidence

Added a new \cosmwasm/pausable\ module that implements an OpenZeppelin-style Pausable pattern for CosmWasm contracts. This allows contracts to be temporarily halted (paused) or resumed (unpaused) via \Pause\ and \Unpause\ messages, with corresponding \Paused\ and \Unpaused\ events emitted. The module provides a \WhenNotPaused\ wrapper to enforce that specific entrypoints are only callable when the contract is not paused, and a query to check the current pause status.

cosmwasm/pausable · high confidence

Added the \pg-queue\ library, a FIFO queue backed by a PostgreSQL table, which now uses OpenTelemetry for metrics collection (replacing previous Prometheus-based metrics). The library includes configuration options for database connections, batch optimization limits, and exponential backoff for retryable errors, along with a \query\_failed\ endpoint to inspect failed queue items.

lib/pg-queue · high confidence

Added new Rust types for the state lens light client, including \ClientState\ and \ConsensusState\. The \ClientState\ now carries an \Extra\ struct containing a \table\_handle\ (H256), while \ConsensusState\ tracks the execution layer's timestamp and state root. These types support serialization via serde, bincode, and ethabi (Alloy) encodings, enabling the light client to interact with the state lens for ICS23 SMT verification.

lib/berachain-light-client-types, lib/state-lens-ics23-smt-light-client-types, lib/trusted-mpt-light-client-types · medium confidence

The \deployments\ directory now contains structured JSON files that define the state of the Union IBC stack. \deployments.json\ maps chain IDs to their deployed contract addresses and commit hashes, while \clients.json\ tracks light client configurations and refresh rates. \channels.json\ specifies IBC channel details including gas fees, SLAs, and tags. Additionally, \editions.json\ controls chain visibility across development, staging, and production environments, and \token-whitelist.json\ restricts transfers to approved assets. These files are maintained by the \update-deployments-json\ build tool.

deployments · high confidence

A new \lib/fork-schedules\ library has been added to manage and expose the fork schedules for well-known Ethereum beacon chains (mainnet, Sepolia, Holesky). This change introduces a \ForkSchedule\ struct and a \Forks\ enum that map specific chain IDs to their respective fork timelines. Users can now programmatically retrieve the complete list of fork epochs and versions for a given chain, or query the status of specific forks like Electra and Fulu, ensuring the application stays in sync with the Ethereum consensus specification.

lib/fork-schedules · high confidence

The 11-cometbls package now provides a complete implementation of the IBC light client interface for the CometBFT consensus algorithm. This includes the core state structures (ClientState, ConsensusState, Header, and Misbehaviour), along with the necessary methods for header verification, misbehaviour detection, and state updates. The module also registers the necessary codec interfaces and provides migration utilities for pruning expired consensus states, enabling the system to verify and update the state of CometBFT-based chains via IBC.

11-cometbls · high confidence

Added the \access-manager\ CosmWasm contract, a central authorization system that manages roles, targets, and function selectors. The contract implements role-based access control where admins can grant or revoke roles, configure role admins and guardians, set execution delays, and manage target contracts. It provides a structured way to restrict specific functions on other contracts by requiring specific roles, with support for scheduling and cancellation of operations. The implementation includes context structs for execution and query handling, state management for roles and schedules, and comprehensive test coverage.

(repo-wide) · medium confidence

The \cosmwasm/lst-staker\ module is introduced, providing a new CosmWasm contract that manages liquid staking operations. The contract exposes entrypoints for staking, unstaking, and rebasing (distributing rewards), as well as permissionless handling of unstaked tokens. Administrators can configure the set of validators and their share weights, which triggers automatic rebalancing of existing stakes. The implementation includes state management for the LST hub address and validator configurations, along with comprehensive unit tests covering admin permissions, overflow protection, and hub access control.

cosmwasm/lst-staker · high confidence

The \cosmwasm/lst\ module is added, providing a new smart contract for liquid staking. This contract enables users to bond native tokens to receive liquid staking tokens (LST), manage unbonding requests, and receive rewards. The implementation includes core execution logic for bonding, unbonding, and batch processing, alongside state management for tracking accounting, pending batches, and protocol fees. The contract also exposes query endpoints for configuration, state, and batch status, and generates schema definitions for the contract's interface.

cosmwasm/lst/src · high confidence

The \voyager-vm\ library has been added, providing a queue-based message processing system and high-level virtual machine. It introduces an \Engine\ that processes messages from a queue, supporting both in-memory and external queue backends. The system features an \InterestFilter\ to route messages to either a main processing queue or an optimization queue based on message tags. It also defines a set of opcodes (\Call\, \Data\, \Promise\, \Seq\, \Conc\, \Defer\) that allow for complex program structures, including sequential and concurrent execution of operations.

lib/voyager-vm · high confidence

The \ts-sdk-cosmos\ directory is added to the repository, introducing the \@unionlabs/sdk-cosmos\ package. This new module provides a concrete \ZkgmClient\ implementation for the Cosmos ecosystem, including \Cosmos\ and \CosmosZkgmClient\ modules that handle public and signing clients via \@cosmjs/cosmwasm-stargate\. The package includes source files for client logic, context layers for chain configuration, and example scripts demonstrating cross-chain calls and fund transfers. It also adds a Nix build configuration (\ts-sdk-cosmos.nix\) and TypeScript configuration files to support building, testing, and documentation generation for the new SDK component.

ts-sdk-cosmos · high confidence

A new \cosmos-sdk-event\ library has been added to the codebase, providing a \CosmosSdkEvent\ struct that parses raw ABCI events into strongly-typed Rust structs using \serde\ instead of custom macros. This change allows developers to define custom event types with adjacently tagged serde representations, enabling automatic extraction of well-known attributes like \msg\_index\, \event\_index\, \tx\_index\, and \\_contract\_address\ during deserialization. The library includes comprehensive tests demonstrating how to map raw blockchain events to specific Rust enums and structs, simplifying the handling of Cosmos SDK module events in Voyager.

lib/cosmos-sdk-event · high confidence

A new \upgradable\ module has been added to the CosmWasm integration, providing a reusable \execute\ function and associated message types that allow contracts to trigger their own upgrades. This helper constructs the necessary \WasmMsg::Migrate\ message to switch to a new code ID and forwards a provided message to the contract's \Migrate\ entry point, while also emitting an \Upgrade\ event to track the transition.

cosmwasm/upgradable · high confidence

The zkgm-dev frontend is introduced, featuring a video background that plays on user interaction, an animated header bar, and a glitch-effect title. The page includes a component that renders four animated characters (Omar, Lukas, Ben, Cor) that move horizontally and bounce off the container edges and each other. The layout also includes a footer with the animated characters. The site is configured with Tailwind CSS, SvelteKit, and Vite, and includes static assets like a favicon, logo, and agent images.

zkgm-dev · high confidence

Added a new Svelte store (state.svelte.ts) that manages the user's ceremony state, including queue position, contribution status, and client state. The store implements polling intervals to periodically check the user's allowance, waitlist position, and contribution progress, ensuring the UI reflects the current state of the ceremony.

ceremony/src/lib/stores · high confidence

The application now implements OpenTelemetry for structured logging, metrics, and distributed tracing. In development, it logs to the console; in staging and production, it sends logs, traces, and metrics to an OpenTelemetry-compatible endpoint using gRPC/HTTP protocols with gzip compression. A custom span processor is used to manage batch sizes based on byte count, ensuring efficient transmission of trace data. This change enables better observability and debugging capabilities across all environments.

app2/src/lib/logging · high confidence

The \lib/cosmos-client\ library now supports pluggable gas fillers to handle transaction fees. A new \GasFillerT\ trait and \TxClient\ integration allow users to choose between fixed gas pricing, dynamic feemarket-based pricing, or Osmosis-specific EIP-1559 fee estimation. This change enables more accurate fee estimation for transactions on Cosmos-based chains, addressing previous rounding errors and supporting diverse fee markets.

lib/cosmos-client · high confidence

The app2/src/lib directory now contains a new set of shared utilities and configuration files. A runtime module (runtime.ts) provides a managed Effect runtime that dynamically loads either test or live service layers, exposing execution helpers like runFork and runPromise. A themes module (themes.ts) defines a Theme interface and pre-configured themes for 'btc' and 'app' editions, each specifying colors and media assets. Additionally, the lib folder includes constants for environment detection and mobile breakpoints, copy templates for error messages, type helpers for Effect and Exit transformations, and a markdown-to-HTML converter that automatically opens external links in new tabs.

app2/src/lib · high confidence

The \lib/macros\ crate is added, providing a new \\#\[apply\]\ attribute macro and a \\#\[derive(Debug)\]\ implementation that supports custom formatting and field-level control via attributes. This allows users to generate custom debug output and apply transformations to code blocks, enhancing the developer experience for debugging and code generation.

lib/macros · high confidence

The Voyager SDK now provides dedicated hook implementations for handling \FetchUpdateHeaders\ and \SubmitTx\ messages, allowing plugins to intercept and process these specific message types via a visitor pattern. Additionally, the SDK exposes a shared \VoyagerClient\ type and extension traits to simplify client access within RPC contexts, alongside utility functions for value serialization and null-checking.

lib/voyager-sdk · high confidence

The \state-lens-ics23-ics23-light-client-types\ library now defines the \ClientState\ and \ConsensusState\ structures for the state-lens light client, including versioned \Extra\ data and \ethabi\ serialization logic. Additionally, the \unionlabs-encoding\ crate introduces generic \Encode\ and \Decode\ traits that allow types to be serialized into various formats (such as SSZ and JSON) through a unified interface.

lib/state-lens-ics23-ics23-light-client-types · high confidence

A new \errors\ module has been added to \app2/src/lib/transfer/shared/\, defining a set of tagged error classes (e.g., \MissingTransferFieldsError\, \InsufficientFundsError\, \BalanceLookupError\) using the \effect\ library. These errors provide specific, typed contexts for various transfer and balance-related failures, improving error handling and user-facing feedback for these flows.

app2/src/lib/transfer/shared/errors · high confidence

The \unionlabs\ crate now includes structured Rust types for Cosmos SDK modules, including \cosmos::auth::BaseAccount\, \cosmos::bank::MsgSend\, and \cosmos::base\ types like \Coin\ and \GasInfo\. Additionally, the library introduces a comprehensive set of types for ICS-23 (proofs and verification), supporting both standard and compressed batch proofs. These additions provide a unified, type-safe interface for encoding and decoding these standard blockchain data structures.

lib/unionlabs · high confidence

The app now features a new 'Mad Yaps' section, introducing a public leaderboard and rewards program for 'yappers' across two seasons. Users can view top-ranked participants on a podium, browse a paginated table of all yappers with search and filtering, and access a detailed 'About' modal explaining the program's mechanics, including the 1% token supply allocation and the redistribution of team member mindshare to the community pool. The page also includes a hero video, a countdown timer to the season start, and a team member eligibility modal.

app2/src/routes/yaps · high confidence

The \galois-rpc\ library now provides a manual implementation of the Galois RPC client, introducing new modules for handling proof requests, responses, and zero-knowledge proof data. This includes the \Client\ struct for connecting to the Galois service and serializing/deserializing request and response types such as \PollRequest\, \ProveRequest\, and \ZeroKnowledgeProof\. The change enables direct communication with the Galois API v3 for proving and polling operations.

lib/galois-rpc · high confidence

The multisig transfer feature is now functional, introducing new services for creating and filling multisig transactions. The \create-multisig.ts\ file generates the necessary transaction messages, including allowance updates and instruction encoding via the \@unionlabs/sdk\ package. The \filling.ts\ file implements the state machine for the transfer flow, handling validation, context creation, balance and allowance checks, and message generation.

app2/src/lib/transfer/multisig/services · high confidence

A new page for multisig transfers has been added, integrating the Transfer component in multisig mode and including a video tutorial popup to guide users through the process.

app2/src/routes/transfer/multisig · high confidence

Introduced a new CosmWasm contract that wraps IBC-Union fungible CW20 instances, enabling token factory integration. The contract implements the full CW20 standard, including transfers, burns, mints, and allowance management (increase/decrease/transfer-from). It also provides enumeration queries for allowances and a migration path for existing balances.

cosmwasm/cw20-wrapped-tokenfactory · high confidence

The app2 GraphQL layer has been replaced with a new implementation that supports a configurable GraphQL endpoint (defaulting to production, staging, or development URLs) and introduces client-side caching with a Time-To-Live (TTL) strategy derived from GraphQL directives. The new service includes a custom \GraphQLError\ class for better error handling and uses \sessionStorage\ for cache persistence.

app2/src/lib/graphql · high confidence

The lib/voyager-primitives crate now defines a comprehensive set of IBC interface and client type constants, enabling the system to recognize and interact with a wider range of blockchain networks. New client types include support for Optimism, Base, Bob, Sui, Parlia, Gno, and attested light clients, alongside existing types like Tendermint, Ethereum, and Arbitrum. Additionally, the library introduces an IbcInterface enum to represent different IBC stack implementations (e.g., ibc-go v8, solidity, cosmwasm, aptos move, sui move, cairo, and gno), allowing the Voyager system to route messages and verify states across diverse consensus mechanisms and execution environments.

lib/voyager-primitives · high confidence

The ceremony now guides users through an interactive terminal-based installation process. Users are first prompted to select their operating system (Linux or macOS) via a new SelectOS component. Depending on the selection, the user receives tailored instructions: Linux users are directed to install and run Docker, while macOS users are instructed to install OrbStack. Both paths provide a copyable command to start the MPC client, with a warning about browser compatibility and ad-blocker interference.

ceremony/src/lib/components/Terminal/Install · high confidence

The Orbital Explorer route now provides a comprehensive, real-time dashboard for monitoring network activity. Users can view live transfer statistics, track popular routes, and monitor node health through a suite of interactive charts. A dynamic network visualizer displays node activity and transfer flows on a canvas, while a terminal-style log and audio notifications provide additional layers of real-time feedback.

app2/src/routes/explorer/orbital · high confidence

A new Rust library at lib/ucs03-solvable/src/lib.rs introduces Solvable and CwTokenOrderV2 structs to define the structure of an order to be solved, including packet details, token amounts, and relayer information. It also adds a SolverQuery enum to check if a contract is a solver and whether market makers are allowed.

lib/ucs03-solvable · medium confidence

The \consensus-primitives\ library now provides \Timestamp\ and \Duration\ types, each normalized to nanoseconds. These newtypes offer explicit constructors and accessors for seconds, milliseconds, and nanoseconds, along with utility methods like \plus\_duration\ and \is\_zero\. This standardizes how time is handled across different consensus mechanisms, reducing confusion from varying timestamp storage formats.

lib/consensus-primitives · high confidence

A new set of reusable UI components has been introduced to the app2 codebase, including Button, Card, Modal, Tooltip, Input, and various layout and status indicators. These components provide a consistent design system for the application's user interface.

app2/src/lib/components/ui · high confidence

The app2 component library introduces several new UI elements: a robust AddressInput component that validates addresses across multiple chains (EVM, Cosmos, Sui, Aptos) using the Union SDK and Effect; a SettingsModal for configuring general app settings, LST parameters, and developer options; and new empty-state components (NoWalletConnected, WalletConnectedNoTransfers) that guide users to connect wallets or perform transfers. Additionally, a DevInfo component displays build metadata, and a Seo component manages social media meta tags.

app2/src/lib/components · high confidence

The Voyager system now includes dedicated client modules for Arbitrum, Attested, Base, Bob, CometBLS, Ethereum, Ethermint, Gno, Movement, Parlia, and Proof-Lens. Each module implements the \ClientModule\ and \ClientModuleServer\ traits, enabling the Voyager framework to interact with these specific light clients and consensus mechanisms. These modules handle the encoding and decoding of client states, consensus states, headers, and proofs using various serialization formats like Bincode and EthAbi, allowing Voyager to verify and query state across these networks.

voyager/modules/client · high confidence

A new Rust library, lib/ucs03-zkgmable, has been added to the codebase, introducing two new message types: OnZkgm and OnIntentZkgm. These types define the structure for handling cross-chain messages, including fields for caller, path, channel IDs, sender, message, and specific relayer or market maker details. This change enables the system to process and route these specific types of inter-chain communications.

lib/ucs03-zkgmable · high confidence

A new AddressForm component has been added to the ceremony flow, allowing users to input and validate a Bech32-format wallet address. The form validates the address format, saves the wallet data to the database, and updates the terminal with status messages. Users can also choose to skip the step, which records a 'SKIPPED' state. This component introduces the UI and validation logic for capturing wallet addresses during the ceremony.

ceremony/src/lib/components/address · high confidence

The app2 codebase now includes a new \app2/src/lib/constants\ directory containing several configuration files that define application behavior and appearance. A \chain-logos.ts\ file maps UniversalChainIds to SVG logo paths for chains like Aptos, Arbitrum, Base, and others. A \disabled-chains.ts\ file explicitly disables the BSC chain. A \settlement-times.ts\ file defines settlement and finality delays for chains such as Base, Bob, Corn, and Arbitrum. Additionally, new constants define token blacklists, faucet URLs, spender addresses, and retry schedules for balance fetching.

app2/src/lib/constants · high confidence

A new attested light client has been added to the CosmWasm module, enabling verification of state via attested proofs. The implementation includes a new \AttestedLightClient\ that handles header verification, membership/non-membership proofs, and misbehavior detection. The contract exposes messages for submitting attestations, confirming them once a quorum is reached, and querying attested values, attestors, and quorum status. Storage structures manage pending and confirmed attestations, attestor sets, and height-to-timestamp mappings. Tests verify the full flow of attestation submission, quorum checking, and query responses.

cosmwasm/lightclient/attested · high confidence

A new +page.svelte component has been added at app2/src/routes/auth to display the results of authentication flows. The page handles three states: a loading spinner while the session is verified, a success message ('Account Updated!') when a session is detected, and an error state that maps Supabase errors into a user-friendly format, displaying the error message and cause before redirecting the user back to the dashboard or home page.

app2/src/routes/auth · high confidence

A new balances page has been added to app2, providing a centralized view of user balances across all supported chains. The page fetches and displays token balances for each chain, utilizing a new \sortedBalancesStore\ to manage and sort balance data. It includes error handling for failed balance fetches and displays loading states while data is being retrieved. The implementation uses the \@unionlabs/sdk\ for chain and token data, and integrates with the existing wallet and chain stores to provide a comprehensive overview of the user's multi-chain portfolio.

app2/src/routes/balances · high confidence

The transfer flow now uses a new set of Svelte components (ChainSelector, AssetSelector, RepresentationSelector, and their container) to manage selecting a source/destination chain, the specific asset, and token representations. The chain selector filters chains by signing mode, availability, and whitelist status, while the asset selector filters tokens by whitelist and balance, with special handling for testnets. The representation selector allows users to choose between multiple token representations on the destination chain.

app2/src/lib/transfer/shared/components/ChainAsset · high confidence

The Voyager client-update plugin system now includes dedicated update modules for Arbitrum, Base, Berachain, Bob, CometBLS, Ethereum, and Ethermint. Each plugin implements the \Plugin\ trait to fetch and process header updates for its respective chain, enabling the Voyager system to maintain light client state for these networks.

voyager/plugins/client-update · high confidence

A new page at /explorer/clients has been added to display a matrix of all client connections between chains. The dashboard fetches and displays client statuses, allowing users to see which chains have active clients. The view supports filtering between mainnet and testnet environments, and includes tooltips with detailed status information for each connection.

app2/src/routes/explorer/clients · high confidence

The dashboard module now includes a new \auth-guard.ts\ file that provides a generic authentication guard for SvelteKit load functions, redirecting unauthenticated users to a specified path. A new \client.ts\ file initializes the Supabase client using environment variables and the \effect\ library for error handling. Additionally, \errors.ts\ introduces a comprehensive set of custom error types (e.g., \SupabaseClientError\, \AuthenticationError\) and a helper function \mapSupabaseErrorToCustomError\ to map Supabase error codes to specific dashboard error classes. The \helpers.ts\ file adds utility functions for checking provider links, generating device fingerprints, and retrieving user IP addresses, all utilizing the \effect\ library for side-effect management.

app2/src/lib/dashboard · high confidence

The dashboard now includes several new Svelte components to enhance user interaction and visibility. A new account management flow allows users to view their email and ID, with a dedicated modal to confirm and execute account deletion. Achievement and mission tracking are introduced with dedicated stats cards and tabbed lists that display progress, XP, and completion rates. A new error handling system provides user-friendly messages and detailed error reports for various dashboard failures. Additionally, a new user welcome card guides new accounts through initial setup tasks.

app2/src/lib/dashboard/components · high confidence

The dashboard now uses a new layout component that enforces authentication before rendering. Users can now access dedicated pages for viewing rewards (with status-based sorting and role request functionality), achievements, missions, and wallet connections, each with their own Svelte components and data loading logic.

app2/src/routes/dashboard · high confidence

The dashboard's state management has been refactored into a set of dedicated Svelte stores (achievements, airdrop, check, errors, experience, leaderboard, missions, rewards, user, and wallets). Each store encapsulates data fetching, error handling, and automatic background polling (using the \effect\ library) to keep the dashboard UI in sync with the server. This change introduces a more robust and modular approach to managing dashboard data, ensuring that users see up-to-date information about their achievements, missions, rewards, and wallet status without manual refreshes.

app2/src/lib/dashboard/stores · high confidence

Added new Rust types in lib/deployments to represent deployed IBC contracts across different interfaces (CosmWasm, Solidity, and Sui/Move). The new lib.rs defines a Deployments map keyed by UniversalChainId, with a Deployment enum distinguishing between IbcCosmwasm, IbcSolidity, and IbcMoveSui variants, each carrying specific contract metadata like deployer addresses, contract maps, and commit hashes. Additionally, a new Cw20Ctx trait was added in lib/cw20-ctx to enforce minting permissions for CW20 tokens.

lib/deployments · high confidence

Users can now access a dedicated page to request UNO testnet tokens via the official Union faucet, which includes a wallet address display and a Cloudflare Turnstile protection notice. Additionally, a new 'Third-Party Faucets' section lists external faucet URLs for networks connected to Union testnet, with a disclaimer that Union provides no uptime guarantees for these third-party services.

app2/src/routes/faucet · high confidence

The app2 layout now includes a new Breadcrumbs component that dynamically generates a navigational trail based on the current URL path, a Copy Link button that copies the current page URL to the clipboard, and a mobile-optimized Menu component that slides in to display the main navigation and profile card on smaller screens.

app2/src/lib/components/layout/Header · high confidence

Added new Svelte icon components in app2/src/lib/components/icons, including AirdropIcon, AngleArrowIcon, ArrowDownLeft, BaselineCloseIcon, DiscordIcon, EscherLogo, EscherTextLogo, ExternalLinkIcon, FilledBookmarkIcon, GithubIcon, LoadingSpinnerIcon, MissionBoxIcon, MissionCompletedIcon, OutlineControlPointDuplicate, OutlinedBookmarkIcon, RestoreIcon, RotateLeftIcon, SharpArrowLeft, SharpBaselineArrowBackIcon, SharpCancelIcon, SharpChannelsIcon, SharpCheckIcon, SharpChevronDownIcon, SharpChevronLeftIcon, SharpClientsIcon, SharpConnectionsIcon, SharpContentCopyIcon, SharpDashboardIcon, SharpDoubleCheckIcon, SharpDownloadIcon, SharpErrorOutlineIcon, SharpGasIcon, SharpInfoIcon, SharpLinkOffIcon, SharpListIcon, SharpListRemoveIcon, SharpOpenInBrowserIcon, SharpPacketsIcon, SharpPlayCircleIcon, SharpPowerIcon, SharpRightArrowIcon, SharpSettingsIcon, SharpStakeIcon, SharpTransferIcon, SharpUpcomingIcon, SharpWalletIcon, SharpWarningIcon, SpinnerIcon, StakeIcon, and TwitterIcon.

app2/src/lib/components/icons · high confidence

Added new service files for the dashboard: add-cosmos-wallet.ts, add-evm-wallet.ts, and cache.ts. These introduce a local storage caching mechanism (with TTL and stale-while-revalidate logic) and implement the backend logic for verifying and adding Cosmos and EVM wallets, including chain switching, message signing, and Supabase integration.

app2/src/lib/dashboard/services · high confidence

The app2 interface now features a suite of new UI components in the model directory, including AddressComponent, BarChart, BlockHashComponent, BlockHeightComponent, ChainComponent, DustWithdrawalListItemComponent, ErrorComponent, HeightComponent, MultisigMessage, PacketComponent, PacketHashComponent, PacketListItemComponent, PacketListItemComponentSkeleton, PacketTracesComponent, and StakingListItemComponent. These components provide structured displays for blockchain data such as addresses, block heights, packet traces, and staking information, enhancing the user's ability to view and interact with detailed on-chain information.

app2/src/lib/components/model · high confidence

Added new Svelte components (FillingStep, MessageStep) and TypeScript types (Steps, Filling, CheckMessage) to handle the multisig transfer flow. The FillingStep manages user input for sender, receiver, and asset details, while the MessageStep allows users to view, copy, or export the generated message. These components are exported via a new index file and define the step types for the transfer process.

app2/src/lib/transfer/multisig/steps · high confidence

The layout area now includes a new Navigation.svelte component that renders the main site navigation, including a 'More Union' section with social icons and links to the Privacy Policy and Terms of Service pages. Additionally, a YapAd.svelte component was added to display an advertisement for 'Yaps', though it is currently commented out in the navigation template.

app2/src/lib/components/layout · high confidence

The \networks\ directory now includes structured configuration files for managing different network environments. This includes a new README explaining the structure (devnet, testnet, mainnet), Nix build definitions for \atomone\ and \babylon\ nodes, and comprehensive genesis files for \union-testnet-2\ and \union-testnet-10\, along with associated \gentx\ files for validators. Additionally, new files are added for \devnet-eth\ configuration, including genesis and key files, supporting the local simulation of Ethereum-based networks.

networks · high confidence

A new route has been added at /explorer/packets/\[packet\_hash\] to display detailed information about a specific packet. The page loads the packet hash from the URL, validates it using the @unionlabs/sdk schema, and renders the PacketComponent within a Card. If the hash is invalid, the user is redirected to the main packets list.

_app2/src/routes/explorer/packets/\[packet\hash\] · high confidence

A new packet-filter plugin has been added to Voyager, enabling users to filter IBC events (connections, channels, and packets) using configurable field-based criteria. The plugin exposes a configuration schema with specific filters for chain IDs, client IDs, port IDs, channel versions, and other event attributes, allowing users to selectively process or ignore specific IBC messages based on these fields.

voyager/plugins/packet-filter · high confidence

The app2 frontend now includes a dedicated services layer that fetches staking incentive data (inflation, staking pool, distribution params, validators) from the Union REST API, retrieves finalized block heights from the Voyager RPC endpoint, and resolves favicons via DuckDuckGo or Google. These services use the Effect library for error handling and configuration, providing the UI with the data needed to display staking rewards and chain status.

app2/src/lib/services · high confidence

Introduced a new sign-in page at /auth/sign-in that allows users to log in via Twitter (X), GitHub, or Discord. The page includes a redirect to the dashboard if the user is already authenticated, and each provider button can be disabled (e.g., during an outage) or while a login request is in progress.

app2/src/routes/auth/sign-in · high confidence

The staking route now features a comprehensive UI for managing staking activities, including bonding, unbonding, and withdrawing assets. The page integrates components for balance cards, staking history, and stats, while fetching real-time data on bonds, unbonds, and withdrawals from the indexer. It also displays incentive information and staking rates, providing users with a centralized hub for all staking operations.

app2/src/routes/stake · high confidence

The staking section has been rebuilt with a new UI, introducing a 'Dust' tab in the BalanceCard to recover small eU balances from proxy contracts, alongside a dedicated ProxyDustRecovery component for the withdrawal flow. Users can now view staking, unbonding, and withdrawal history in a single, filterable table, and track total position value, staked amount, and net rewards in the StakingRewardsDisplay. The interface also includes a SlippageSelector for transactions and a QuickAmountButtons component for faster input.

app2/src/lib/components/stake · high confidence

A new tokens explorer page has been added at /explorer/tokens. It displays a list of chains and, for each chain, shows multiple tokens in a responsive grid layout. The page fetches token data for each chain's universal chain ID and handles loading and empty states.

app2/src/routes/explorer/tokens · high confidence

A new Rust binary at tools/update-deployments has been added to automate the synchronization of deployment metadata. The tool reads existing deployment files and updates contract addresses, heights, and commit hashes for both CosmWasm and EVM-based contracts, including support for IBC light clients and specific token minters.

tools/update-deployments · high confidence

The Voyager transaction plugin architecture has been expanded to include dedicated transaction plugins for Aptos, Cosmos, EVM, Gno, and Sui. Each plugin is responsible for constructing and submitting the appropriate blockchain transactions (such as IBC packets, client updates, and channel handshakes) for its respective chain. The Sui plugin additionally includes a Move-based token denomination module to handle token metadata on the Sui network.

voyager/plugins/transaction · high confidence

The transfer interface now includes three new shared components: Amount, which handles balance display and input validation; FeeDetails, which displays gas and network fees with a collapsible breakdown; and Receiver, which manages address input, recent history, and bookmarks. These components replace previous implementations, introducing stricter validation for manual receiver input, transparent fee calculations, and persistent address storage in localStorage.

app2/src/lib/transfer/shared/components · medium confidence

The transfer form state is now managed by a new \RawTransferDataSvelte\ class that synchronizes form fields (source, destination, asset, receiver, sender, amount, quoteToken) with URL parameters using debounced updates. A corresponding \TransferData\ class computes derived state such as filtered chains, base/quote tokens, and solver metadata. Additionally, a new \validation.ts\ module introduces strict schema-based validation for transfer submissions, returning structured field errors for both EVM and Cosmos transfer types.

app2/src/lib/transfer/shared/data · high confidence

The transfer details page has been rebuilt to provide a more comprehensive view of transfer status, including specific states like 'Received', 'In Progress', 'Timeout Pending', and 'Failed'. The page now supports toggling packet details, displays finality and settlement delays, and includes functionality to suggest tokens to Keplr and Leap wallets. It also features improved trace visualization and error handling.

_app2/src/routes/explorer/transfers/\[packet\hash\] · high confidence

The app2 transfer flow now includes five new Svelte components—ApprovalStep, CheckReceiverStep, FillingStep, IndexStep, and SubmitStep—along with their TypeScript type definitions. These components handle the distinct stages of a transfer: configuring details (Filling), verifying the receiver address (CheckReceiver), obtaining token approvals (Approval), submitting the transaction (Submit), and waiting for indexer confirmation (Index).

app2/src/lib/transfer/normal/steps · high confidence

A new transfer page has been added at app2/src/routes/transfer/+page.svelte. It integrates the existing Transfer component and implements logic to fetch token and balance data from the source chain, using the @unionlabs/sdk for address conversion and the balancesStore to retrieve user funds.

app2/src/routes/transfer · high confidence

The transfer service now includes new files for checking token allowances, checking account balances, validating transfer state, and creating the transfer context. This introduces structured validation for EVM, Cosmos, and Sui chains, with specific handling for fee intents and multi-chain routing.

app2/src/lib/transfer/shared/services/filling · high confidence

The app now includes new Svelte components for wallet connectivity, introducing a unified connection interface for Cosmos, EVM, and Sui chains. The \connection.svelte\ component renders a connected wallet card with copy-to-clipboard functionality and a list of available wallets, handling status states and error conditions. A new \metamask-mobile-alert.svelte\ component displays a modal warning about MetaMask's 'smart transactions' feature incompatibility, guiding users to disable it. The \index.ts\ file exports the necessary types for these components.

app2/src/lib/components/ui/Wallet/connect · high confidence

The transfers route in app2 now renders a personalized list of transfers for all connected wallets. The page displays a list of transfer items, handles pagination (previous/next page navigation), and shows appropriate states: a 'no wallet connected' message, a 'no transfers' message for wallets with no history, loading skeletons, and error states. It integrates with the new Effect runtime for managing concurrent data fetching and cancellation of previous requests.

app2/src/routes/transfers · high confidence

The \lib/ssz\ directory now contains a complete Rust implementation of the SimpleSerialize (SSZ) format, including encoding and decoding logic, Merkleization utilities, and type definitions for vectors, lists, and bitfields. This adds the core serialization primitives required for Ethereum 2.0-style data structures.

lib/ssz · high confidence

The site has been migrated from a dynamic Contentful CMS to a fully static build. All content, including blog posts, team pages, and assets, is now stored directly in the repository under \site/src/content/\ and \site/src/content-data/\. A complete export of the previous Contentful data has been preserved in \site/content/archive/contentful/\ for reference, but the live site no longer requires a network call to a CMS to render pages.

site · high confidence

The \tendermint-verifier\ library has been introduced to handle Tendermint light client verification. This includes a comprehensive error handling system (\error.rs\) defining specific failure states such as header expiration, chain ID mismatches, and signature verification failures. The implementation provides core verification logic (\verify.rs\), Merkle tree calculations (\merkle.rs\), and supporting types and utilities. Additionally, a suite of JSON test fixtures (e.g., \288.json\, \291.json\) has been added to validate the verification process against real-world header and validator set data.

lib/tendermint-verifier · high confidence

The wallet UI component has been replaced with a new modal that provides a unified interface for connecting to EVM, Cosmos, and Sui blockchains. Users can now switch between different wallet types via tabs, with each tab displaying the relevant connection status and options. The component integrates with existing store modules for each chain, allowing users to connect, view, and manage their wallets across multiple networks from a single location.

app2/src/lib/components/ui/Wallet · high confidence

The TypeScript SDK has been restructured into a new v2 architecture, introducing comprehensive support for cross-chain asset transfers via the UCS03 protocol. Developers can now construct and submit FungibleAssetOrders for EVM, Cosmos, and Aptos chains, with specific examples demonstrating transfers between Babylon, Bob, Holesky, and Xion. The SDK also adds robust token query functions—including balance, metadata, and allowance checks—for ERC20, CW20, and Aptos Fungible Assets. Additionally, the SDK now supports reading contract state at specific block heights and includes new utilities for predicting quote tokens and managing batched instructions.

ts-sdk · high confidence

The \voyager-core\ library now includes a new caching layer (\cache.rs\) that stores state, client info, and latest height/timestamp data with configurable TTL and LRU eviction, exposing OpenTelemetry metrics for cache hits, misses, and size. Additionally, the core now supports equivalent chain IDs (\equivalent\_chain\_ids.rs\) to handle chains with multiple identifiers, and implements interest-based filtering (\filter.rs\) using the \jaq\ query language to determine which plugins should process specific operations. The \Context\ and \Server\ modules have been restructured to manage these new capabilities, providing a more modular and observable core for the Voyager system.

lib/voyager-core · medium confidence

Voyager has been refactored into a message-based system where every chain query, transaction submission, and data representation is modeled as a state within a PostgreSQL-backed queue, ensuring transactional integrity and fast startup times. This update introduces a new configuration schema (\configSchema.nix\) and a \config.jsonc\ template that defines modules (state, proof, consensus, client, client\_bootstrap) and plugins. The CLI (\cli.rs\) and configuration structures (\config.rs\) have been updated to support this new architecture, including support for JSONC config files and new queue management subcommands.

voyager · high confidence

The \u\ CLI tool now includes new subcommands for interacting with various blockchain networks and utilities. Users can query Arbitrum (v1 and v2) for node numbers and finalized L2 blocks, interact with Base L1/L2 block mappings, and fetch Gno light client headers and RPC data. Additional commands allow parsing Parlia extra data, computing Solidity storage slots, generating vanity addresses, and calculating packet hashes. These additions expand the CLI's capabilities for debugging, deployment, and protocol-specific queries.

tools/u · high confidence

The ceremony site now includes a new Tailwind CSS configuration file that imports base, components, and utilities, and defines custom font faces for 'tt-supermolot-neue' and 'jetbrains-mono' (including italic variants). This change enables the use of Tailwind utility classes and specific web fonts within the ceremony component's styling.

ceremony/src/styles · medium confidence

The \cometbls-light-client-types\ library now supports bincode serialization for all light client types, including \ChainId\, \ClientState\, \ConsensusState\, \Header\, \LightHeader\, and \Misbehaviour\. This enables efficient binary encoding for these types, alongside existing support for JSON, Protocol Buffers, and EthAbi. The changes include new type definitions, serialization implementations, and corresponding tests to ensure codec isomorphism.

lib/cometbls-light-client-types · high confidence

A new spline asset file (water-blob.splinecode) has been added to the ceremony library's assets, likely to support a new visual element or animation in the ceremony site.

ceremony/src/lib/assets · medium confidence

A new migration script and data file have been added to the \cosmwasm/migrations/zkgm/v1\_to\_v2\ directory. The \v1tov2.sh\ script processes chain data to generate v1 and v2 wrapped migration records for the Babylon (\babylon.bbn-1\) chain, facilitating the upgrade from zkgm v1 to v2.

cosmwasm/migrations · medium confidence

The query layer in app2 has been rewritten to use the v2 GraphQL schema and the Effect runtime. This introduces new queries for banners, chains, channels, clients, packets, statistics, tokens, and transfers, all utilizing the \@unionlabs/sdk\ types and the \effect\ library for data fetching and state management. The changes include fetching data from new endpoints (e.g., \v2\_chains\, \v2\_packets\, \v2\_transfers\) and updating the data stores to reflect the new structure.

app2/src/lib/queries · high confidence

The EVM service layer has been restructured to use the Effect library for managing public and wallet clients, introducing explicit error types for missing chain configurations and client creation failures. Balance fetching now distinguishes between native gas tokens and ERC20 tokens, applying a configurable retry schedule to both. The implementation relies on viem for RPC interactions and integrates with the SDK's schema and constants for chain and token definitions.

app2/src/lib/services/evm · medium confidence

The EVM wallet logic in app2 has been restructured into new Svelte components (\config.svelte.ts\, \wagmi-config.svelte.ts\, and \index.ts\). This introduces a reactive \SepoliaStore\ class that manages wallet connections, disconnections, and reconnection of the last used wallet via \@wagmi/core\ and \viem\. The configuration now explicitly supports multiple chains (including Base, Sei, BSC, Arbitrum, and various testnets) with fallback RPCs from Chain Kitchen and other providers. Users will experience improved wallet state management, automatic reconnection to the previously used wallet, and more robust handling of chain switching and account status updates.

app2/src/lib/wallet/evm · medium confidence

The @cosmjs libraries are patched to support the Bn254 public key algorithm, enabling compatibility with newer cryptographic standards. Additionally, the @effect/docgen tooling is updated to generate richer documentation by including direct source code anchors for every exported item, adding Twoslash annotations to code examples, and updating the generated site's navigation metadata.

patches · medium confidence

The application now uses the Effect library to manage runtime dependencies through dedicated layer configurations for live and test environments. This change introduces a structured approach to dependency injection, including the integration of the PriceOracle, Supabase client, GasPriceMap, GraphQL service, and tracing/logging mechanisms in the live layer, while providing simplified test layers with mocked or minimal dependencies.

app2/src/lib/layers · medium confidence

The shared services layer in app2 has been refactored to use the Effect runtime for asynchronous operations. New modules have been added to handle address derivation (supporting Bech32, EVM, and Movement hex formats), amount parsing with decimal precision, and quote token retrieval for transfers. These changes replace previous synchronous or error-throwing patterns with robust, composable Effect computations that handle validation and retry logic, improving reliability for user-facing transfer flows.

app2/src/lib/services/shared · high confidence

The transfer module now supports multisig transactions alongside the existing single-signer flow. A new signing mode store tracks whether the user is in 'single' or 'multi' mode, and the transfer index component conditionally renders either the Normal or Multisig sub-components based on this mode. A new tabbed transfer view was also added.

app2/src/lib/transfer · medium confidence

Added new service files, write-cosmos.ts and write-evm.ts, which implement a finite state machine (FSM) to manage the lifecycle of transfer transactions. For Cosmos, the flow handles chain switching and contract execution with retry logic. For EVM, the flow adds support for Safe wallets (resolving safe transaction hashes) and waits for transaction receipts. These changes replace ad-hoc transaction handling with a structured, observable state progression, improving error handling and user feedback during transfers.

app2/src/lib/transfer/shared/services · high confidence

The uniond application now includes upgrade handlers for versions 1.1.0, 1.2.0, and 1.3.0. The v1.2.0 upgrade removes the 'poa' (Proof of Authority) module from the chain's state, while the v1.3.0 upgrade adjusts validator states and burns specific legacy tokens (muno, upoa, ugas) on testnet and mainnet networks. These changes ensure the chain can smoothly transition between these specific versions during network upgrades.

uniond · high confidence

The lib/voyager-rpc library now defines a new \RpcError\ type and associated error codes (Fatal, Unprocessable, MissingState, Retryable) to replace previous error handling, providing more granular control over JSON-RPC error responses. Additionally, new response types such as \InfoResponse\, \StateModuleInfo\, \ProofModuleInfo\, \FinalityModuleInfo\, and \ClientModuleInfo\ are introduced to structure RPC data, enabling clients to query state, proof, consensus, and client information in a standardized format.

lib/voyager-rpc · high confidence

The move-bindgen tool has been updated to properly support generics in its code generation process. This change allows the tool to correctly handle and generate code for generic types, improving the tool's capability to process complex Move smart contract structures. This is a behavioral change to the code generation logic within the move-bindgen tool.

tools/move-bindgen · medium confidence

The transfer interface has been refactored into a new Svelte component that manages a multi-step state machine for transfers. This change introduces a structured flow with distinct steps (Filling, CheckReceiver, ApprovalRequired, SubmitInstruction, WaitForIndex) and handles navigation between them. The component integrates with the 'effect' runtime library to manage asynchronous operations and state transitions, while also incorporating keyboard shortcuts and fee intent creation logic.

app2/src/lib/transfer/normal · high confidence

The Cosmos transfer service in app2 has been refactored to use the Effect runtime for managing asynchronous operations and error handling. This introduces a new state machine (machine.ts, state.ts) that orchestrates the transfer lifecycle (SwitchChain, ApprovalSubmit, TransferSubmit) and provides structured, typed errors (errors.ts) for better debugging and user feedback. The change also includes specific fixes for Cosmos offline signing error marshalling and chain switching, ensuring that errors are properly extracted and presented to the user rather than throwing unhandled exceptions.

app2/src/lib/services/transfer-ucs03-cosmos · high confidence

The transfer service in app2 has been refactored to use a new state machine (machine.ts) that manages the lifecycle of a transfer through distinct phases: switching chains, submitting transactions, and waiting for receipts. This introduces a structured approach to handling EVM and Cosmos chain interactions, utilizing the 'effect' library for managing asynchronous operations and errors. Custom error classes (errors.ts) provide specific error types for different failure points, and the chain switching logic (chain.ts) is now encapsulated. The state definitions (state.ts) clearly define the transitions between states, improving the reliability and observability of the transfer process.

app2/src/lib/services/transfer · high confidence

The Rust protobuf bindings in \generated/rust/protos\ have been regenerated to include new message types for the AtomOne coredaos and gov modules, the AtomOne photon module, and the Babylon btccheckpoint, btclightclient, and btcstaking modules. This update adds support for new governance and staking-related messages, including proposal annotation, endorsement, and vetoing in AtomOne, as well as BTC checkpoint and header management for Babylon.

generated/rust/protos · high confidence

The \tendermint-light-client-types\ library has added Bincode encoding support to its core data structures, including \ClientState\, \ConsensusState\, \Header\, and \Fraction\. This change enables more efficient binary serialization for these types, alongside existing support for JSON and Protocol Buffers. The update includes comprehensive codec tests to ensure data integrity across all supported serialization formats.

lib/tendermint-light-client-types · high confidence

The GraphQL schema and TypeScript types for App 2 have been updated to reflect the latest backend changes. This includes new query fields such as \v2\_bonds\, \v2\_chains\, \v2\_transfers\, and various \v2\_stats\ endpoints, alongside updated argument structures for existing queries. Users of App 2 will benefit from the latest data models and query capabilities as the application synchronizes with the current API contract.

app2/src/generated · high confidence

The wallet configuration file has been updated to include detailed chain information for the Union mainnet and testnet, as well as the Babylon Genesis mainnet. This includes RPC and REST endpoints, currency details (such as 'U' and 'BABY' tokens), gas price steps, and visual theme settings. These changes ensure the application correctly identifies and interacts with these specific blockchain networks.

app2/src/lib/config/wallets · high confidence

The Voyager plugin library now integrates OpenTelemetry for distributed tracing and metrics, initializing tracing with OTLP exporters and configuring trace propagation. Additionally, the library defines new Rust traits (Plugin, StateModule, ProofModule, FinalityModule, ClientModule) that standardize how plugins and modules are initialized, configured, and run, replacing previous ad-hoc implementations with a consistent, structured approach to plugin lifecycle management.

lib/voyager-plugin · high confidence

The IBC-Union core contract in \cosmwasm/core\ now correctly emits events for connection and channel lifecycle states. Specifically, the contract emits the proper events for \connection\_open\_confirm\ and \channel\_open\_try\ operations, ensuring that external observers and downstream systems receive accurate state change notifications. This fix addresses previous issues where incorrect or missing events were emitted, which could have caused synchronization problems for clients relying on these state transitions.

cosmwasm/core · high confidence

The ceremony module now includes a new constants file that defines an Axiom key and a Docker-based command for the MPC client. The command pulls the mpc-client Docker image (version v1.2) and runs it to set up the ceremony environment, indicating an update to the ceremony's operational configuration.

ceremony/src/lib/constants · medium confidence

Add e2e test harness for the access manager; Add e2e test to verify block production on Union and Sepolia; Added Cairo IBC contract tests; Added Cairo tests for Zkgm encoding/decoding; Added comprehensive tests for the LST contract; Expanded test coverage for EVM IBC clients, channels, and cross-chain vaults.

Updated dependencies across the repository, including upgrading the TypeScript SDK to version 1.7.0 and the Sui TypeScript SDK to version 0.0.45. Additionally, the \jaq\ dependency was upgraded from version 1 to 2.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 26 → 42 (+16.3)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 61 → 59 (-2.1)
• Architecture 62 (new)
• Maturity 72 → 71 (-1.2)
• Readiness 8 → 33 (+25.4)
• Security 25 → 40 (+15.1)
• Domain Modelling 100 (new)
• Accessibility 49 (new)

• Change coupling: BalanceCard.svelte ↔ +page.svelte (app2/src/lib/components/stake/BalanceCard.svelte)
• Change coupling: Linux.svelte ↔ MacOS.svelte (ceremony/src/lib/components/Terminal/Install/Linux.svelte)
• Change coupling: SettingsModal.svelte ↔ settings.svelte.ts (app2/src/lib/components/SettingsModal.svelte)
• Change coupling: astro.config.ts ↔ ec.config.mjs (docs/astro.config.ts)
• Change coupling: astro.config.ts ↔ markdown.config.ts (docs/astro.config.ts)
• Change coupling: channel-balance.ts ↔ cw20.ts (ts-sdk/src/cosmos/channel-balance.ts)
• Change coupling: client.ts ↔ transfer.ts (typescript-sdk/src/evm/client.ts)
• Change coupling: statistics.svelte.ts ↔ +page.svelte (app2/src/lib/queries/statistics.svelte.ts)
• Change coupling: sui.ts ↔ zkgmClient.ts (ts-sdk-sui/src/internal/sui.ts)
• Change coupling: transfer-list-item.ts ↔ transfer-list.svelte.ts (app2/src/lib/queries/fragments/transfer-list-item.ts)
• Dimension evaluation failed
• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 86 more

• App.prepForZeroHeightGenesis (cognitive 39) (uniond/app/export.go)
• App.prepForZeroHeightGenesis (cyclomatic 32) (uniond/app/export.go)
• Boundary-crossing change coupling: call.rs ↔ main.rs (lib/voyager-message/src/call.rs)
• Boundary-crossing change coupling: client_state.rs ↔ main.rs (lib/state-lens-ics23-ics23-light-client-types/src/client_state.rs)
• Boundary-crossing change coupling: client_state.rs ↔ main.rs (lib/state-lens-ics23-mpt-light-client-types/src/client_state.rs)
• Boundary-crossing change coupling: client_state.rs ↔ main.rs (lib/state-lens-ics23-mpt-light-client-types/src/client_state.rs)
• Boundary-crossing change coupling: lib.rs ↔ main.rs (lib/arbitrum-verifier/src/lib.rs)
• Boundary-crossing change coupling: server.rs ↔ main.rs (lib/voyager-core/src/server.rs)
• CI installs an unverified third-party binary (.github/workflows/release-component.yml)
• CI installs an unverified third-party binary (.github/workflows/release-component.yml)
• Change coupling: client.ts ↔ tenderly.ts (typescript-sdk/src/evm/client.ts)
• Change coupling: contract.rs ↔ client.rs (cosmwasm/core/src/contract.rs)
• Change coupling: contract.rs ↔ error.rs (cosmwasm/app/ucs03-zkgm/src/contract.rs)
• Change coupling: index.svelte ↔ check-filling.ts (app2/src/lib/transfer/normal/index.svelte)
• Change coupling: index.ts ↔ FeeDetails.svelte (app2/src/lib/gasprice/index.ts)
• Change coupling: index.ts ↔ index.ts (ceremony/src/lib/client/index.ts)
• Change coupling: index.ts ↔ queries.ts (ceremony/src/lib/supabase/index.ts)
• Change coupling: lightclient.rs ↔ client.rs (cosmwasm/core/msg/src/lightclient.rs)
• Change coupling: module.rs ↔ lib.rs (cosmwasm/core/msg/src/module.rs)
• Change coupling: msg.rs ↔ query.rs (cosmwasm/core/msg/src/msg.rs)
• …and 2589 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

unionlabs/union was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.