
Understanding the four Legion Score pillars
What each score represents, how it is calculated, and what it takes to reach the top

Concrete Vaults: the most accessible path to real yield in DeFi
A beginner-friendly introduction to automated DeFi strategies powered by Concrete.

Deploying your first Solidity Contract on Arc Testnet
Deploying your first Solidity Contract on Arc Testnet



Understanding the four Legion Score pillars
What each score represents, how it is calculated, and what it takes to reach the top

Concrete Vaults: the most accessible path to real yield in DeFi
A beginner-friendly introduction to automated DeFi strategies powered by Concrete.

Deploying your first Solidity Contract on Arc Testnet
Deploying your first Solidity Contract on Arc Testnet

Subscribe to Colliseum

Subscribe to Colliseum
Hi everyone, my name is Heorhii. Over the past year I’ve been diving deep into Aleo, exploring how zero-knowledge applications can move from theory to production. With the Aleo mainnet now live, one of the most exciting areas is cross-chain interoperability: bringing assets and data into the Aleo ecosystem in a way that is both private and compliant.
This is where Predicate comes in. Predicate is a blockchain company focused on simplifying compliance and risk management. Their integration with Aleo introduces a standardized framework for secure bridges, following the ARC-100 standard introduced by the Aleo Network Foundation. In this guide, I’ll walk you through what Predicate offers and how developers can integrate it into their own applications.
https://aleo.org/post/arc-100-sets-best-practices-for-cross-chain-operations/
Why compliance matters for Aleo Bridges. Cross-chain bridges are historically one of the weakest points in Web3. Hacks and exploits in bridge smart contracts have drained billions in user funds. At the same time, Aleo’s mission is to make privacy programmable and sustainable, which means privacy must coexist with compliance.
ARC-100 was created to ensure Aleo bridges respect both regulatory and security requirements. Predicate implements ARC-100 directly in its framework, so as a developer you don’t have to reinvent these protections yourself.
The first live integration is the Verulink bridge from Ethereum to Aleo, now running Predicate policies.
https://aleo.org/post/aleo-launches-secure-bridge-framework-with-predicate/
How Predicate works. Predicate enforces compliance using pre-transaction logic. Instead of blindly executing transactions, Predicate first validates them against policies.
Each transaction is checked by trusted operators like Figment, Nethermind, and Pier Two.
Validation happens off-chain but is proven on-chain using attestations.
The process is fast: O(1) verification complexity with sub-second latency.
Privacy is preserved using zero-knowledge circuits.
For Developers: Integrating Predicate. Predicate’s integration can be broken down into three steps:
Onchain Integration. Add compliance checks directly into your smart contracts using the provided PredicateClient.
Application Onboarding. Configure your organization and policies through the Predicate Dashboard.
Offchain Integration. Fetch attestations via the Predicate API and embed them into user transactions.
Let’s go through these steps with examples.
Step 1. Onchain Integration. Install Predicate contracts into your project:
npm i @predicate/contracts
Import and inherit PredicateClient in your Solidity contract. Here’s a minimal example:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import {PredicateClient} from "../lib/predicate-contracts/src/mixins/PredicateClient.sol";
import {PredicateMessage} from "../lib/predicate-contracts/src/interfaces/IPredicateClient.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
contract MetaCoin is PredicateClient, Ownable {
mapping(address => uint256) public balances;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor(address owner, address predicateManager, string memory policyID)
Ownable(owner)
{
balances[owner] = 10_000_000_000_000;
_initPredicateClient(predicateManager, policyID);
}
function sendCoin(address receiver, uint256 amount, PredicateMessage calldata message) external payable {
bytes memory encoded = abi.encodeWithSignature("_sendCoin(address,uint256)", receiver, amount);
require(
_authorizeTransaction(message, encoded, msg.sender, msg.value),
"MetaCoin: unauthorized transaction"
);
_sendCoin(receiver, amount);
}
function _sendCoin(address receiver, uint256 amount) internal {
require(balances[msg.sender] >= amount, "MetaCoin: insufficient balance");
balances[msg.sender] -= amount;
balances[receiver] += amount;
emit Transfer(msg.sender, receiver, amount);
}
function setPolicy(string memory policyID) external onlyOwner {
_setPolicy(policyID);
}
function setPredicateManager(address predicateManager) external onlyOwner {
_setPredicateManager(predicateManager);
}
}
Deploy with constructor arguments:
_predicateManager: ServiceManager address for your target chain
_policyID: A policy identifier (for testing you can use x-test-random)
Step 2. Predicate Dashboard. After deploying, go to the Predicate Dashboard and set up:
Sign up and create your organization
Add the deployed contract address
Set your policy (linked to your PolicyID)
Generate an API key
Test your setup with a simple request:
curl --location 'https://api.predicate.io/v1/task' \
--header 'x-api-key: {PREDICATE_API_KEY}' \
--header 'Content-Type: application/json' \
--data '{
"from": "{WALLET_ADDRESS}",
"to": "{DEPLOYED_CONTRACT}",
"data": "0x",
"msg_value": "0",
"chain_id": {CHAIN_ID}
}'
If successful, you’ll get a JSON response with is_compliant: true.
Step 3. Offchain Integration. Your backend fetches Predicate attestations and injects them into transactions.
Example Node.js backend proxy:
import {PredicateClient, PredicateRequest, packFunctionArgs, signaturesToBytes} from '@predicate/core';
const predicateClient = new PredicateClient({
apiUrl: 'https://api.predicate.io',
apiKey: process.env.PREDICATE_API_KEY!
});
app.post('/api/predicate/evaluate', async (req, res) => {
const { from, to, functionArgs, chainId } = req.body;
const data = packFunctionArgs("sendCoin(address,uint256)", functionArgs);
const request: PredicateRequest = {
from,
to,
data,
msg_value: '0',
chain_id: chainId
};
const result = await predicateClient.evaluatePolicy(request);
if (!result.is_compliant) {
return res.status(400).json({ error: 'Transaction not compliant' });
}
const predicateMessage = signaturesToBytes(result);
res.json({ predicateMessage });
});
And on the frontend:
const response = await fetch('/api/predicate/evaluate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
from: userAddress,
to: contractAddress,
functionArgs: [receiverAddress, amount]
})
});
const { predicateMessage } = await response.json();
const tx = await contract.sendCoin(
receiverAddress,
amount,
[
predicateMessage.taskId,
predicateMessage.expireByBlockNumber,
predicateMessage.signerAddresses,
predicateMessage.signatures
]
);
Why this matters. Predicate fills one of the biggest gaps in Aleo’s ecosystem: how to build bridges that are both private and compliant. Developers now have a framework that is:
Private: Transactions validated through zero-knowledge proofs
Secure: Policy-driven checks enforced before execution
Scalable: O(1) complexity with sub-second verification
Compliant: Meets ARC-100 standards for regulatory alignment
More info you can find here:
https://docs.predicate.io/developers/overview
Closing thoughts. Bridges are essential for any L1 to thrive, and Aleo is no exception. With Predicate, developers can now create bridges that do not compromise between privacy and compliance. For me, this feels like a major step toward Aleo’s vision of making privacy not just a feature, but a foundation.
The tools are ready. The first bridge (Verulink) is live. Now it’s up to builders like us to take advantage of this framework and shape the future of private, interoperable applications.
To know more about Aleo, join now!
Aleo Twitter
Aleo Discord
Aleo Website
List of Aleo and Leo code and resourses
Prepared by Colliseum
Hi everyone, my name is Heorhii. Over the past year I’ve been diving deep into Aleo, exploring how zero-knowledge applications can move from theory to production. With the Aleo mainnet now live, one of the most exciting areas is cross-chain interoperability: bringing assets and data into the Aleo ecosystem in a way that is both private and compliant.
This is where Predicate comes in. Predicate is a blockchain company focused on simplifying compliance and risk management. Their integration with Aleo introduces a standardized framework for secure bridges, following the ARC-100 standard introduced by the Aleo Network Foundation. In this guide, I’ll walk you through what Predicate offers and how developers can integrate it into their own applications.
https://aleo.org/post/arc-100-sets-best-practices-for-cross-chain-operations/
Why compliance matters for Aleo Bridges. Cross-chain bridges are historically one of the weakest points in Web3. Hacks and exploits in bridge smart contracts have drained billions in user funds. At the same time, Aleo’s mission is to make privacy programmable and sustainable, which means privacy must coexist with compliance.
ARC-100 was created to ensure Aleo bridges respect both regulatory and security requirements. Predicate implements ARC-100 directly in its framework, so as a developer you don’t have to reinvent these protections yourself.
The first live integration is the Verulink bridge from Ethereum to Aleo, now running Predicate policies.
https://aleo.org/post/aleo-launches-secure-bridge-framework-with-predicate/
How Predicate works. Predicate enforces compliance using pre-transaction logic. Instead of blindly executing transactions, Predicate first validates them against policies.
Each transaction is checked by trusted operators like Figment, Nethermind, and Pier Two.
Validation happens off-chain but is proven on-chain using attestations.
The process is fast: O(1) verification complexity with sub-second latency.
Privacy is preserved using zero-knowledge circuits.
For Developers: Integrating Predicate. Predicate’s integration can be broken down into three steps:
Onchain Integration. Add compliance checks directly into your smart contracts using the provided PredicateClient.
Application Onboarding. Configure your organization and policies through the Predicate Dashboard.
Offchain Integration. Fetch attestations via the Predicate API and embed them into user transactions.
Let’s go through these steps with examples.
Step 1. Onchain Integration. Install Predicate contracts into your project:
npm i @predicate/contracts
Import and inherit PredicateClient in your Solidity contract. Here’s a minimal example:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import {PredicateClient} from "../lib/predicate-contracts/src/mixins/PredicateClient.sol";
import {PredicateMessage} from "../lib/predicate-contracts/src/interfaces/IPredicateClient.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
contract MetaCoin is PredicateClient, Ownable {
mapping(address => uint256) public balances;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor(address owner, address predicateManager, string memory policyID)
Ownable(owner)
{
balances[owner] = 10_000_000_000_000;
_initPredicateClient(predicateManager, policyID);
}
function sendCoin(address receiver, uint256 amount, PredicateMessage calldata message) external payable {
bytes memory encoded = abi.encodeWithSignature("_sendCoin(address,uint256)", receiver, amount);
require(
_authorizeTransaction(message, encoded, msg.sender, msg.value),
"MetaCoin: unauthorized transaction"
);
_sendCoin(receiver, amount);
}
function _sendCoin(address receiver, uint256 amount) internal {
require(balances[msg.sender] >= amount, "MetaCoin: insufficient balance");
balances[msg.sender] -= amount;
balances[receiver] += amount;
emit Transfer(msg.sender, receiver, amount);
}
function setPolicy(string memory policyID) external onlyOwner {
_setPolicy(policyID);
}
function setPredicateManager(address predicateManager) external onlyOwner {
_setPredicateManager(predicateManager);
}
}
Deploy with constructor arguments:
_predicateManager: ServiceManager address for your target chain
_policyID: A policy identifier (for testing you can use x-test-random)
Step 2. Predicate Dashboard. After deploying, go to the Predicate Dashboard and set up:
Sign up and create your organization
Add the deployed contract address
Set your policy (linked to your PolicyID)
Generate an API key
Test your setup with a simple request:
curl --location 'https://api.predicate.io/v1/task' \
--header 'x-api-key: {PREDICATE_API_KEY}' \
--header 'Content-Type: application/json' \
--data '{
"from": "{WALLET_ADDRESS}",
"to": "{DEPLOYED_CONTRACT}",
"data": "0x",
"msg_value": "0",
"chain_id": {CHAIN_ID}
}'
If successful, you’ll get a JSON response with is_compliant: true.
Step 3. Offchain Integration. Your backend fetches Predicate attestations and injects them into transactions.
Example Node.js backend proxy:
import {PredicateClient, PredicateRequest, packFunctionArgs, signaturesToBytes} from '@predicate/core';
const predicateClient = new PredicateClient({
apiUrl: 'https://api.predicate.io',
apiKey: process.env.PREDICATE_API_KEY!
});
app.post('/api/predicate/evaluate', async (req, res) => {
const { from, to, functionArgs, chainId } = req.body;
const data = packFunctionArgs("sendCoin(address,uint256)", functionArgs);
const request: PredicateRequest = {
from,
to,
data,
msg_value: '0',
chain_id: chainId
};
const result = await predicateClient.evaluatePolicy(request);
if (!result.is_compliant) {
return res.status(400).json({ error: 'Transaction not compliant' });
}
const predicateMessage = signaturesToBytes(result);
res.json({ predicateMessage });
});
And on the frontend:
const response = await fetch('/api/predicate/evaluate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
from: userAddress,
to: contractAddress,
functionArgs: [receiverAddress, amount]
})
});
const { predicateMessage } = await response.json();
const tx = await contract.sendCoin(
receiverAddress,
amount,
[
predicateMessage.taskId,
predicateMessage.expireByBlockNumber,
predicateMessage.signerAddresses,
predicateMessage.signatures
]
);
Why this matters. Predicate fills one of the biggest gaps in Aleo’s ecosystem: how to build bridges that are both private and compliant. Developers now have a framework that is:
Private: Transactions validated through zero-knowledge proofs
Secure: Policy-driven checks enforced before execution
Scalable: O(1) complexity with sub-second verification
Compliant: Meets ARC-100 standards for regulatory alignment
More info you can find here:
https://docs.predicate.io/developers/overview
Closing thoughts. Bridges are essential for any L1 to thrive, and Aleo is no exception. With Predicate, developers can now create bridges that do not compromise between privacy and compliance. For me, this feels like a major step toward Aleo’s vision of making privacy not just a feature, but a foundation.
The tools are ready. The first bridge (Verulink) is live. Now it’s up to builders like us to take advantage of this framework and shape the future of private, interoperable applications.
To know more about Aleo, join now!
Aleo Twitter
Aleo Discord
Aleo Website
List of Aleo and Leo code and resourses
Prepared by Colliseum
<100 subscribers
<100 subscribers
Share Dialog
Share Dialog
No activity yet