Private strategy execution.
Inside local Vela.

Private strategies. Verifiable execution.

Welcome to Layrs Lab. We are building a marketplace for private trading vaults, where strategy creators can demonstrate their results without publishing their trading rules. This video walks through our own strategy interpreter, packaged as WebAssembly, and a real end to end execution in the local Vela Docker environment. The example uses synthetic prices and test accounts. It does not place a live trade or move real funds.

Our logic, packaged as WASM

Our interpreter is written in Go and compiled with TinyGo for the Vela WebAssembly interface. The reusable interpreter is public; a user's strategy is supplied separately through an encrypted request. For this demonstration, we deliberately use a public example. A price above thirty thousand selects a one point five times long target. A price below twenty nine thousand selects a flat target. These are strategy decisions, not exchange fills.

A real local Vela stack

Here is the local environment used for the run. We started the official Vela starter kit with the executor, manager, authority service, local Anvil chain, and indexing services. Application endpoints are bound to loopback. The chain identifier is thirty one thousand, three hundred and thirty seven. This is software emulation, not an AWS Nitro enclave. It lets us verify the application workflow, but it does not provide hardware attestation or protection against the local machine administrator.

Deploy. Commit. Encrypt.

We upload the actual WebAssembly module to the authority service, then submit its deployment descriptor to the local processor contract. The descriptor binds the module hash and a salted strategy commitment. Once deployment completes, the client registers its encryption public key. The strategy and its salt are then encrypted on the client before submission. The transaction references and hashes shown here were captured from the successful local run, not invented for this presentation.

Encrypted input. Actual execution.

Next, the client submits a synthetic closed price bar at thirty one thousand. The manager forwards the request to the Vela executor, which loads our interpreter and evaluates the registered strategy. The owner decrypts the returned event. The result matches the entry rule: a long target at one point five times leverage, with a twenty five basis point slippage limit. We show this result because this particular example was created for public demonstration.

Exit verified. Retry verified.

A second synthetic bar, at twenty eight thousand, exercises the exit rule. The decrypted result is flat, with zero target leverage. We then resubmit the same semantic request with the same application sequence. The interpreter returns the same private receipt instead of evaluating it as a new strategy step. Our client asserts both expected decisions and receipt equality. This demonstrates stateful execution and application level retry handling; it is not a complete anti rollback or recovery certification.

From private logic to public vaults

In our vault creation architecture, a curator commits a strategy and its risk settings, pays a strategy deployment fee, and receives the results of a committed backtest and benchmark workflow. Approved aggregate results can support a public vault page while detailed strategy logic and execution records remain restricted. Separately, our repository contains evidence from a full annual Nitro and Vela backtest. That is supporting evidence, not the short two-bar execution shown in this video.

Built on evidence. Clear about boundaries.

The one pager linked below explains our integration architecture, privacy boundary, and onchain responsibilities. In this local demonstration, the chain records requests, commitments, encrypted events, and state updates. In the broader vault workflow, contracts handle deployment payments, report resolution, and vault creation. Production confidentiality depends on measured, attested execution and the complete custody design. Independent audit and further recovery qualification remain pre beta work. Thank you to the Horizen and Crecimiento teams for supporting Layrs Lab.