How Bizantine Labs Built Varangian Guard, a Transaction Safety Layer on Portals Foresight

Bizantine is a crypto asset manager operating two arms, Bizantine Capital, a hedge fund, and Bizantine Labs, its DeFi vault-curation team. Bizantine Labs curates large on-chain vaults, including Flare-based vaults launching on Superform.

In vault curation, every privileged transaction carries real operational risk. Proposing strategy hooks, moving funds, and updating configurations all require a multisig approval.

Before any signer approves a transaction, the team needs to know exactly what it will do. That review process needs to be fast, accurate, and legible to every operator on the team.

To solve this, Bizantine Labs built Varangian Guard, an internal transaction-review dashboard, directly on top of the Portals Foresight API.

The Challenge

Vault curation at scale introduces a specific operational problem. Privileged transactions arrive in a queue. Signers need to understand what each transaction will do before they approve it.

Without a simulation layer, the review process relies on manual calldata decoding, which is slow, error-prone, and inaccessible to non-technical team members.

Off-the-shelf security suites exist, but they bundle capabilities that a vault-curation team does not need. Their pricing reflects the full bundle. More importantly, most of these platforms do not support the networks Bizantine actually operates on, including Flare.

Bizantine needed a simulation and trace primitive they could embed directly into their own tooling, on their own networks, without adopting an entire external platform.

The Solution: Varangian Guard, Built on Portals Foresight

Varangian Guard is a pending-transaction console built for vault operators. The system pulls queued transactions from the team's Fordefi MPC wallet, runs each one through the Portals Foresight API. Lastly, it renders the full result on a single screen alongside a configurable security-policy panel.

Before any signer approves a transaction, the operator sees the human readable simulation verdict, a plain-language decode of what the contract call does. This includes specific risk flags, net asset inflows and outflows, and a full execution trace.

Foresight provides the simulation engine. The review workflow, the policy layer, and the interface are entirely Bizantine's own.

Three Use Cases That Drove the Build

1) Execution visibility before signing

Foresight returns the full decoded outcome of a transaction without requiring a signature, and without the wallet needing to hold the tokens or fund the account first.

A curator reviews exactly what a call does before the multisig signers are gathered. This eliminates the need for pre-approvals or sourcing assets up front. The same capability extends to ERC-20 permits, EIP-4337 UserOps, and EIP-7702 delegated calls.

2) Pre-flight multi-step flows

A withdraw, swap, and supply sequence can be simulated as a single batch. The operator confirms the entire chain lands at the correct amounts before it reaches the multisig.

3) Post-transaction record keeping

A Foresight trace produces a decoded, permanent record of what a transaction did. The risk team uses these traces for internal write-ups and compliance documentation after execution.

How Foresight Shows Up in Varangian Guard

Every element of Varangian Guard's review screen is a Foresight output, surfaced inside Bizantine's own interface.

• Simulation verdict: A clear safe/unsafe result with the count of blocks and warnings, plus the specific checks that passed (transfer value within limit, gas cost within limit, no blocklisted addresses).

• Plain-language decode: A "what this transaction does" summary that translates a raw contract call (e.g. proposeStrategyHooksRoot ) into a sentence a human can read.

• Risk analysis: Foresight flags risk signals directly, for example, marking a call to an unverified contract where no ABI could be resolved for full decoding, so the operator knows what they can and can't see.
• Asset in/out and touched addresses: A safety report showing outflow, inflow, gas cost, and which addresses the transaction touches.
• Decoded execution trace: The full call tree with inputs and emitted events, plus a shareable Trace ID.

Varangian Guard runs on Flare today, following Portals adding Foresight support for Flare in June 2026. When a transaction is set to revert, Foresight flags it before signing, preventing wasted gas and failed operations.

The Stack

Varangian Guard sits on top of two infrastructure pieces. Fordefi provides the MPC wallet and the transaction queue. Portals Foresight provides the simulation and trace layer.

Foresight integrates cleanly with Fordefi, so Bizantine wired the two together and built their review interface over the combined output.

In this stack, Foresight answers one focused question: what will this transaction do, and what did it do.

Results

Bizantine Labs now simulates and decodes almost every privileged vault transaction through Foresight before execution. The team achieved this without adopting a full security suite.

Specifically, the implementation delivered the following outcomes. Every privileged vault transaction is simulated, decoded, and policy-checked on a single screen before it reaches the multisig.

Varangian Guard runs live against Bizantine's Flare vault operations, covering a network that most simulation tools do not support. The team paid for the exact primitive they needed and built the rest themselves.

"Almost all transactions our team initiates get simulated and decoded through Foresight before execution, giving us a clear description and visibility into each operation. The reliability, ease of integration, and multi-network support allows us to focus on reducing our operational risk across every vault we curate." Pavel Sinelnikov, Bizantine Labs

Build on Portals Foresight

Bizantine Labs built Varangian Guard by composing the Portals Foresight API into their own tooling. If you are building transaction-safety or operator tooling for vault operations, you can access the same simulation and trace API.