redbellynetwork/sevm-local repository overview

docker pull redbellynetwork/sevm-local:latest

docker run --rm -p 8547:8547 --name sevm-local redbellynetwork/sevm-local:latest

docker exec sevm-local tx check-rpc
docker exec sevm-local tx get-balance

docker pull redbellynetwork/sevm-local:latest
docker pull redbellynetwork/sevm-local:bin-v1.3.17-core-v0.47.2-id-v1.2.13
docker pull redbellynetwork/sevm-local@sha256:<digest>

docker image inspect --format='{{index .RepoDigests 0}}' \
  redbellynetwork/sevm-local:bin-v1.3.17-core-v0.47.2-id-v1.2.13

docker run --rm -p 8547:8547 --name sevm-local redbellynetwork/sevm-local:latest

docker run -d --name sevm-local -p 8547:8547 redbellynetwork/sevm-local:latest
docker logs -f sevm-local

docker run --rm -p 8547:8547 \
  -v sevm-local-data:/data \
  --name sevm-local \
  redbellynetwork/sevm-local:latest

docker run --rm -p 18547:8547 --name sevm-local redbellynetwork/sevm-local:latest
# RPC → http://127.0.0.1:18547

docker run --rm redbellynetwork/sevm-local:latest help

docker exec sevm-local tx <command>

# Health
docker exec sevm-local tx check-rpc

# Transfers (AMOUNT_WEI or AMOUNT_RBNT required)
docker exec -e TO=0xYourAddress -e AMOUNT_RBNT=1.5 -e WAIT_FOR_RECEIPT=true \
  sevm-local tx send-funds
docker exec -e TO=0xYourAddress -e AMOUNT_WEI=500000000000000000 -e WAIT_FOR_RECEIPT=true \
  sevm-local tx send-funds
docker exec -e WALLET_PRIVATE_KEY=<hex> -e FROM=0xSender -e TO=0xRecipient -e AMOUNT_RBNT=1 \
  sevm-local tx transfer-funds

# Balances & permissions
docker exec sevm-local tx get-balance
docker exec -e ADDRESS=0xYourAddress sevm-local tx get-balance
docker exec -e ADDRESS=0xYourAddress sevm-local tx check-permission
# Builds a sample-IDP verifiable credential and calls Permission.request
docker exec -e ADDRESS=0xYourAddress -e WALLET_PRIVATE_KEY=<hex-matching-address> \
  sevm-local tx request-permission

# Bootstrap reads & writes
docker exec sevm-local tx read-gas-fees
docker exec -e BASE_GAS_FEE=10000 -e WAIT_FOR_RECEIPT=true sevm-local tx set-gas-fees
docker exec sevm-local tx read-price-feed
docker exec sevm-local tx read-price-decimals
docker exec -e PRICE=2000000 -e WAIT_FOR_RECEIPT=true sevm-local tx set-price
docker exec sevm-local tx read-network-config
docker exec sevm-local tx read-product-contracts

# ---------------------------------------------------------------------------
# Full KYB flow (docker exec)
# ---------------------------------------------------------------------------
# Roles:
#   - IDP admin  = default funded account (SIGNER / AUTH_SIGNER below)
#   - Business wallet = owner wallet passed to deploy-business; after deploy it
#                       is also an authorised representative
#   - Authorised representative = can add/remove delegates (and gets network permission)
#   - Authorised delegate = gets network permission via the business permission path
#
# 1) Deploy BusinessIdentifier for the business wallet and register it
docker exec \
  -e BUSINESS_WALLET=0xBusinessOwner \
  -e COMPANY_NAME="Acme Pty Ltd" \
  -e INCORPORATED_NAME="Acme Pty Ltd" \
  -e IDENTIFIER_TYPE=ABN \
  -e IDENTIFIER=12345678901 \
  -e BUSINESS_ADDRESS="1 Test St" \
  -e IS_BENEFICIAL_OWNER=true \
  sevm-local tx deploy-business
# → prints BI_ADDRESS; business wallet is already an authorised representative

# 2) IDP admin adds another authorised representative (grants network permission)
docker exec \
  -e BI_ADDRESS=0xBiAddress \
  -e ADDRESSES=0xNewRep \
  -e AUTH_SIGNER=c8744d99f848ce750f47e75779c4a817009de9b20e56a321ec68cc7bbb33e473 \
  sevm-local tx add-representative
docker exec -e ADDRESS=0xNewRep sevm-local tx check-permission

# 3a) Add a delegate as IDP admin
docker exec \
  -e BI_ADDRESS=0xBiAddress \
  -e ADDRESSES=0xDelegateViaIdp \
  -e AUTH_SIGNER=c8744d99f848ce750f47e75779c4a817009de9b20e56a321ec68cc7bbb33e473 \
  sevm-local tx add-delegate
docker exec -e ADDRESS=0xDelegateViaIdp sevm-local tx check-permission

# 3b) Add a delegate as the business owner (authorised representative key)
#     Fund the business wallet first if it will sign txs.
docker exec -e TO=0xBusinessOwner -e AMOUNT_RBNT=1 sevm-local tx send-funds
docker exec \
  -e BI_ADDRESS=0xBiAddress \
  -e ADDRESSES=0xDelegateViaOwner \
  -e AUTH_SIGNER=<business-owner-private-key> \
  sevm-local tx add-delegate
# Confirm BI role + network permission on the delegate
docker exec -e BI_ADDRESS=0xBiAddress -e ADDRESS=0xDelegateViaOwner sevm-local tx get-business
docker exec -e ADDRESS=0xDelegateViaOwner sevm-local tx check-permission

# 3c) Same as 3b, but AUTH_SIGNER is another authorised representative (not the owner)
docker exec \
  -e BI_ADDRESS=0xBiAddress \
  -e ADDRESSES=0xDelegateViaRep \
  -e AUTH_SIGNER=<authorised-representative-private-key> \
  sevm-local tx add-delegate
docker exec -e ADDRESS=0xDelegateViaRep sevm-local tx check-permission

# 4) Remove roles (mirrors who may add them)
docker exec \
  -e BI_ADDRESS=0xBiAddress \
  -e ADDRESSES=0xDelegateViaOwner \
  -e AUTH_SIGNER=<business-owner-or-rep-private-key> \
  sevm-local tx remove-delegate
docker exec \
  -e BI_ADDRESS=0xBiAddress \
  -e ADDRESSES=0xNewRep \
  -e AUTH_SIGNER=c8744d99f848ce750f47e75779c4a817009de9b20e56a321ec68cc7bbb33e473 \
  sevm-local tx remove-representative

import { Contract, JsonRpcProvider, Wallet, formatEther, parseEther } from "ethers";

const RPC = "http://127.0.0.1:8547";
const CHAIN_ID = 161;
const BOOTSTRAP_REGISTRY = "0xDAFEA492D9c6733ae3d56b7Ed1ADB60692c98Bc5";
const FUNDED_PK = "c8744d99f848ce750f47e75779c4a817009de9b20e56a321ec68cc7bbb33e473";
const FUNDED = "0xd846B0bA0a0D99FA7449eD42e65760F4a0e617cb";
const IDP_DID = "did:key:z6MkjeGCfcWj8skMsyAx9qkZNStUX8crPHdaFaj8enbYcLC6";

const REGISTRY_ABI = ["function registry(string) view returns (address)"];
const GAS_FEES_ABI = [
  "function getBaseGasFee() view returns (uint256, string, uint8)",
  "function updateGasFee(uint256 baseGasFee)",
];
const PRICE_FEED_ABI = [
  "function getLatestPrice() view returns (int256, uint256, bool)",
  "function thresholdForNextUpdate() view returns (uint256)",
  "function decimals() view returns (uint8)",
  "function setPrice(uint256 newPrice)",
];
const NETWORK_CONFIG_ABI = [
  "function getNetworkSize() view returns (uint256)",
  "function getBootNodeAddresses() view returns (address[])",
];
const PERMISSION_ABI = [
  "function isAllowed(address) view returns (bool)",
  "function isPermissionedAccessEnabled() view returns (bool)",
  "function enablePermissionedAccess()",
  "function request(string issuerDid, string vcs, string proofSignature)",
];
const FACTORY_ABI = [
  "function deployContract(address,string,string,string,string,string,bool)",
  "function businessContracts(address) view returns (address)",
];
const ALLOWED_LIST_ABI = [
  "function registerBusiness(address)",
  "function isBusinessIdentifierValid(address) view returns (bool)",
];
const BI_ABI = [
  "function AUTHORISED_REPRESENTATIVE_ROLE() view returns (bytes32)",
  "function AUTHORISED_DELEGATE_ROLE() view returns (bytes32)",
  "function hasRole(bytes32,address) view returns (bool)",
  "function addAuthorisedRepresentative(address[])",
  "function removeAuthorisedRepresentative(address[])",
  "function addAuthorisedDelegate(address[])",
  "function removeAuthorisedDelegate(address[])",
];

const provider = new JsonRpcProvider(RPC, CHAIN_ID);
const wallet = new Wallet(FUNDED_PK, provider); // IDP admin / funded account
const registry = new Contract(BOOTSTRAP_REGISTRY, REGISTRY_ABI, provider);

docker exec sevm-local cat /opt/sevm/network-config.json

{
  "chainId": 161,
  "redbellyRegistry": "0x...",
  "allowedList": "0x...",
  "businessIdentifierFactory": "0x..."
}

console.log("chainId", (await provider.getNetwork()).chainId);
console.log("balance RBNT", formatEther(await provider.getBalance(FUNDED)));

const tx = await wallet.sendTransaction({
  to: "0xYourAddress",
  value: parseEther("1.5"),
});
console.log("tx", tx.hash);
await tx.wait();

const permission = new Contract(
  await registry.registry("permission"),
  PERMISSION_ABI,
  provider,
);
console.log("permissioned access enabled", await permission.isPermissionedAccessEnabled());
console.log("isAllowed(FUNDED)", await permission.isAllowed(FUNDED));
console.log("isAllowed(0xYourAddress)", await permission.isAllowed("0xYourAddress"));

docker exec -e ADDRESS=0xYourAddress -e WALLET_PRIVATE_KEY=<matching-hex> \
  sevm-local tx request-permission

const grantee = new Wallet("<grantee-private-key>", provider);
const permissionAsGrantee = new Contract(
  await registry.registry("permission"),
  PERMISSION_ABI,
  grantee,
);
const requestTx = await permissionAsGrantee.request(IDP_DID, vcCanonical, proofCanonical);
await requestTx.wait();
console.log("isAllowed", await permissionAsGrantee.isAllowed(grantee.address));

const gasFees = new Contract(await registry.registry("gasfees"), GAS_FEES_ABI, wallet);
const [base, currency, decimals] = await gasFees.getBaseGasFee();
console.log({ base: base.toString(), currency, decimals });

const updateGasTx = await gasFees.updateGasFee(10_000n);
await updateGasTx.wait();

const priceFeed = new Contract(await registry.registry("pricefeed"), PRICE_FEED_ABI, wallet);
const [price, updatedAt, valid] = await priceFeed.getLatestPrice();
console.log({
  price: price.toString(),
  updatedAt: updatedAt.toString(),
  valid,
  threshold: (await priceFeed.thresholdForNextUpdate()).toString(),
  decimals: await priceFeed.decimals(), // typically 6
});

const updatePriceTx = await priceFeed.setPrice(2_000_000n);
await updatePriceTx.wait();

docker exec sevm-local tx read-price-decimals

const networkConfig = new Contract(
  await registry.registry("networkconfiguration"),
  NETWORK_CONFIG_ABI,
  provider,
);
console.log("network size", (await networkConfig.getNetworkSize()).toString());
console.log("boot nodes", await networkConfig.getBootNodeAddresses());

const { allowedList: ALLOWED_LIST, businessIdentifierFactory: FACTORY } = {
  allowedList: "0x...",
  businessIdentifierFactory: "0x...",
};

const businessOwner = Wallet.createRandom().connect(provider);
const otherRep = Wallet.createRandom().connect(provider);
const delegateViaIdp = Wallet.createRandom().connect(provider);
const delegateViaOwner = Wallet.createRandom().connect(provider);
const delegateViaRep = Wallet.createRandom().connect(provider);

// Fund wallets that will send txs
for (const addr of [businessOwner.address, otherRep.address]) {
  await (await wallet.sendTransaction({ to: addr, value: parseEther("1") })).wait();
}

const idpAdmin = wallet; // DEFAULT_ADMIN on BusinessIdentifier for local image
const factory = new Contract(FACTORY, FACTORY_ABI, idpAdmin);
const allowedList = new Contract(ALLOWED_LIST, ALLOWED_LIST_ABI, idpAdmin);

// 1) Deploy + register (IDP admin)
await (await factory.deployContract(
  businessOwner.address,
  "Acme Pty Ltd",
  "Acme Pty Ltd",
  "ABN",
  "12345678901",
  "1 Test St",
  true,
)).wait();
const biAddress = await factory.businessContracts(businessOwner.address);
await (await allowedList.registerBusiness(biAddress)).wait();

// Make business owner an authorised representative (IDP admin only)
const biAsIdp = new Contract(biAddress, BI_ABI, idpAdmin);
await (await biAsIdp.addAuthorisedRepresentative([businessOwner.address])).wait();

const permission = new Contract(await registry.registry("permission"), PERMISSION_ABI, provider);
const repRole = await biAsIdp.AUTHORISED_REPRESENTATIVE_ROLE();
const delegateRole = await biAsIdp.AUTHORISED_DELEGATE_ROLE();

// 2) IDP admin adds another representative (also grants network permission)
await (await biAsIdp.addAuthorisedRepresentative([otherRep.address])).wait();
console.log("otherRep is rep", await biAsIdp.hasRole(repRole, otherRep.address));
console.log("otherRep isAllowed", await permission.isAllowed(otherRep.address));

// 3a) IDP admin adds a delegate
await (await biAsIdp.addAuthorisedDelegate([delegateViaIdp.address])).wait();
console.log("delegateViaIdp role", await biAsIdp.hasRole(delegateRole, delegateViaIdp.address));
console.log("delegateViaIdp isAllowed", await permission.isAllowed(delegateViaIdp.address));

// 3b) Business owner (authorised representative) adds a delegate
const biAsOwner = new Contract(biAddress, BI_ABI, businessOwner);
await (await biAsOwner.addAuthorisedDelegate([delegateViaOwner.address])).wait();
console.log("delegateViaOwner role", await biAsOwner.hasRole(delegateRole, delegateViaOwner.address));
console.log("delegateViaOwner isAllowed", await permission.isAllowed(delegateViaOwner.address));

// 3c) Other authorised representative adds a delegate
const biAsRep = new Contract(biAddress, BI_ABI, otherRep);
await (await biAsRep.addAuthorisedDelegate([delegateViaRep.address])).wait();
console.log("delegateViaRep role", await biAsRep.hasRole(delegateRole, delegateViaRep.address));
console.log("delegateViaRep isAllowed", await permission.isAllowed(delegateViaRep.address));

// 4) Remove (same callers as add)
await (await biAsOwner.removeAuthorisedDelegate([delegateViaOwner.address])).wait();
await (await biAsIdp.removeAuthorisedRepresentative([otherRep.address])).wait();
console.log("removed delegate role", await biAsOwner.hasRole(delegateRole, delegateViaOwner.address));
console.log("removed rep role", await biAsIdp.hasRole(repRole, otherRep.address));