website·Indexed 31 days ago
https://docs.bloomr.ioBloomr allows you to stream real-time data directly from the blockchain using JavaScript/TypeScript scripts. The platform provides tools for EVM interaction, including Solidity calls, ABI encoding/decoding, internal transaction traversal, and event log access. Data can be exported via Webhooks, Websockets, or polling. It features a compute-based pricing model using Compute Units (CUs) and supports custom script databases and address lists for tracking large numbers of contracts.
bloomr-script.d.ts file, which allows for type-safe development and autocompletion of the available runtime utilities.Calling a smart contract is done by sending a transaction to its address. A call can include a quantity of the native token (e.g., Ether) and calldata. The contract returns returndata and a boolean indicating success or failure (failed calls revert all state changes).
To call a specific Solidity function, the calldata must contain:
decodeCall() method. This is used to analyze calldata to determine which function is being called. It returns null if no match is found, or an object containing the method name, signature, and decoded args.const { MyInterface: { decodeCall } } = abi<MyAbi>`
interface MyInterface {
function myFn(uint256 fnArg) external returns (uint256);
}
`;
const result = decodeCall('0xc92e77d2000000000000000000000000000000000000000000000000000000000000002a');
// Result: { name: "myFn", signature: "myFn(uint256)", args: { fnArg : 42n } }abi tag and then instantiate it for a specific address using the .at() method to perform Solidity calls from within handlers.const { IERC20 } = abi<MyAbi>`
interface IERC20 {
function balanceOf(address owner) external view returns (uint256)
}
`;
onTx(tx => {
const token = IERC20.at(tx.to);
console.log('balance of sender', token.balanceOf(tx.from));
})
solidity tag to define a Solidity contract and interfaces directly within a Bloomr script. Bloomr dynamically compiles these contracts, making them usable as if they were deployed on all blockchains. This is particularly useful for creating helpers that fetch complex on-chain information in the context of the current block.const {
IERC20: { Transfer },
Main: { getTokenDetails },
} = solidity<GetTokenData>`
pragma solidity ^0.8.15;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
function decimals() external view returns (uint256);
function name() external view returns (string memory);
}
contract Main {
function getTokenDetails(IERC20 token) public view returns (uint256 decimals, string memory name) {
decimals = token.decimals();
name = token.name();
}
}
`
// The function getTokenDetails is now callable directly from JS
const details = getTokenDetails(tokenAddress);x-signature request header.// Define the public key (replace with the actual public key from your webhook settings)
const PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
THE KEY HERE
-----END PUBLIC KEY-----`;
import express from "express";
import { createVerify } from "crypto";
const app = express();
app.use(express.json()); // To parse requests
app.post("/", (req, res) => {
const signature = req.headers["x-signature"];
if (!signature || typeof signature !== "string") {
return res.status(400).send("Signature required");
}
const verifier = createVerify("sha256");
verifier.update(JSON.stringify(req.body));
const isVerified = verifier.verify(PUBLIC_KEY, signature, "base64");
if (isVerified) {
console.log("Verified");
// Process the webhook body
} else {
console.log("Verification failed");
return res.status(401).send("Invalid signature");
}
});
const port = 8080;
app.listen(port, () => {
console.log(`Server listening on port ${port}`);
});const myList = getAddressList('my list name');
onTx(tx => {
// Add an address to the list
myList.add(tx.to);
// Remove an address from the list
myList.delete(tx.to);
// Check if an address exists in the list (Free operation)
if (myList.has(tx.to)) {
// Execute logic
}
})