@aastar/core 0.16.7

package/dist/networks.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Blockchain Network Configuration
+ */
+export declare const NETWORKS: {
+    readonly sepolia: {
+        readonly chainId: 11155111;
+        readonly name: "Sepolia";
+        readonly rpcUrl: "https://rpc.sepolia.org";
+        readonly blockExplorer: "https://sepolia.etherscan.io";
+        readonly nativeCurrency: {
+            readonly name: "Sepolia ETH";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+    };
+    readonly anvil: {
+        readonly chainId: 31337;
+        readonly name: "Anvil";
+        readonly rpcUrl: "http://127.0.0.1:8545";
+        readonly blockExplorer: "";
+        readonly nativeCurrency: {
+            readonly name: "ETH";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+    };
+};
+export type SupportedNetwork = keyof typeof NETWORKS;
+/**
+ * Get network configuration
+ *
+ * @param network - Network name
+ * @returns Network configuration
+ *
+ * @example
+ * ```ts
+ * const network = getNetwork('sepolia');
+ * console.log(network.chainId); // 11155111
+ * ```
+ */
+export declare function getNetwork(network: SupportedNetwork): {
+    readonly chainId: 11155111;
+    readonly name: "Sepolia";
+    readonly rpcUrl: "https://rpc.sepolia.org";
+    readonly blockExplorer: "https://sepolia.etherscan.io";
+    readonly nativeCurrency: {
+        readonly name: "Sepolia ETH";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+} | {
+    readonly chainId: 31337;
+    readonly name: "Anvil";
+    readonly rpcUrl: "http://127.0.0.1:8545";
+    readonly blockExplorer: "";
+    readonly nativeCurrency: {
+        readonly name: "ETH";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+};
+/**
+ * Get RPC URL for a network
+ *
+ * @param network - Network name
+ * @returns Public RPC URL
+ *
+ * @example
+ * ```ts
+ * const rpcUrl = getRpcUrl('sepolia');
+ * ```
+ */
+export declare function getRpcUrl(network: SupportedNetwork): "https://rpc.sepolia.org" | "http://127.0.0.1:8545";
+/**
+ * Get block explorer URL
+ *
+ * @param network - Network name
+ * @returns Block explorer base URL
+ *
+ * @example
+ * ```ts
+ * const explorer = getBlockExplorer('sepolia');
+ * // 'https://sepolia.etherscan.io'
+ * ```
+ */
+export declare function getBlockExplorer(network: SupportedNetwork): "" | "https://sepolia.etherscan.io";
+/**
+ * Get transaction URL on block explorer
+ *
+ * @param network - Network name
+ * @param txHash - Transaction hash
+ * @returns Full transaction URL
+ *
+ * @example
+ * ```ts
+ * const url = getTxUrl('sepolia', '0x123...');
+ * // 'https://sepolia.etherscan.io/tx/0x123...'
+ * ```
+ */
+export declare function getTxUrl(network: SupportedNetwork, txHash: string): string;
+/**
+ * Get address URL on block explorer
+ *
+ * @param network - Network name
+ * @param address - Contract or wallet address
+ * @returns Full address URL
+ *
+ * @example
+ * ```ts
+ * const url = getAddressUrl('sepolia', '0xabc...');
+ * // 'https://sepolia.etherscan.io/address/0xabc...'
+ * ```
+ */
+export declare function getAddressUrl(network: SupportedNetwork, address: string): string;
+/**
+ * Get chain ID for a network
+ *
+ * @param network - Network name
+ * @returns Chain ID number
+ *
+ * @example
+ * ```ts
+ * const chainId = getChainId('sepolia');
+ * // 11155111
+ * ```
+ */
+export declare function getChainId(network: SupportedNetwork): number;

package/dist/networks.js

@@ -0,0 +1,118 @@
+/**
+ * Blockchain Network Configuration
+ */
+export const NETWORKS = {
+    sepolia: {
+        chainId: 11155111,
+        name: 'Sepolia',
+        rpcUrl: 'https://rpc.sepolia.org',
+        blockExplorer: 'https://sepolia.etherscan.io',
+        nativeCurrency: {
+            name: 'Sepolia ETH',
+            symbol: 'ETH',
+            decimals: 18,
+        },
+    },
+    anvil: {
+        chainId: 31337,
+        name: 'Anvil',
+        rpcUrl: 'http://127.0.0.1:8545',
+        blockExplorer: '',
+        nativeCurrency: {
+            name: 'ETH',
+            symbol: 'ETH',
+            decimals: 18,
+        },
+    },
+};
+/**
+ * Get network configuration
+ *
+ * @param network - Network name
+ * @returns Network configuration
+ *
+ * @example
+ * ```ts
+ * const network = getNetwork('sepolia');
+ * console.log(network.chainId); // 11155111
+ * ```
+ */
+export function getNetwork(network) {
+    return NETWORKS[network];
+}
+/**
+ * Get RPC URL for a network
+ *
+ * @param network - Network name
+ * @returns Public RPC URL
+ *
+ * @example
+ * ```ts
+ * const rpcUrl = getRpcUrl('sepolia');
+ * ```
+ */
+export function getRpcUrl(network) {
+    return NETWORKS[network].rpcUrl;
+}
+/**
+ * Get block explorer URL
+ *
+ * @param network - Network name
+ * @returns Block explorer base URL
+ *
+ * @example
+ * ```ts
+ * const explorer = getBlockExplorer('sepolia');
+ * // 'https://sepolia.etherscan.io'
+ * ```
+ */
+export function getBlockExplorer(network) {
+    return NETWORKS[network].blockExplorer;
+}
+/**
+ * Get transaction URL on block explorer
+ *
+ * @param network - Network name
+ * @param txHash - Transaction hash
+ * @returns Full transaction URL
+ *
+ * @example
+ * ```ts
+ * const url = getTxUrl('sepolia', '0x123...');
+ * // 'https://sepolia.etherscan.io/tx/0x123...'
+ * ```
+ */
+export function getTxUrl(network, txHash) {
+    return `${getBlockExplorer(network)}/tx/${txHash}`;
+}
+/**
+ * Get address URL on block explorer
+ *
+ * @param network - Network name
+ * @param address - Contract or wallet address
+ * @returns Full address URL
+ *
+ * @example
+ * ```ts
+ * const url = getAddressUrl('sepolia', '0xabc...');
+ * // 'https://sepolia.etherscan.io/address/0xabc...'
+ * ```
+ */
+export function getAddressUrl(network, address) {
+    return `${getBlockExplorer(network)}/address/${address}`;
+}
+/**
+ * Get chain ID for a network
+ *
+ * @param network - Network name
+ * @returns Chain ID number
+ *
+ * @example
+ * ```ts
+ * const chainId = getChainId('sepolia');
+ * // 11155111
+ * ```
+ */
+export function getChainId(network) {
+    return NETWORKS[network].chainId;
+}

package/dist/requirementChecker.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Unified requirement checker for role registration
+ * Provides centralized validation for GToken, aPNTs, MySBT, and role permissions
+ */
+import { Address, PublicClient } from 'viem';
+import type { RoleRequirement } from './roles.js';
+/**
+ * Requirement Checker Utility
+ *
+ * Centralized validation for all role requirements
+ */
+export declare class RequirementChecker {
+    private publicClient;
+    private addresses?;
+    constructor(publicClient: PublicClient, addresses?: {
+        registry?: Address;
+        gtoken?: Address;
+        apnts?: Address;
+        mysbt?: Address;
+    } | undefined);
+    checkRequirements(params: {
+        address: Address;
+        roleId?: `0x${string}`;
+        requiredGToken?: bigint;
+        requiredAPNTs?: bigint;
+        requireSBT?: boolean;
+    }): Promise<RoleRequirement>;
+    checkGTokenBalance(address: Address, required: bigint): Promise<{
+        balance: bigint;
+        hasEnough: boolean;
+    }>;
+    checkAPNTsBalance(address: Address, required: bigint): Promise<{
+        balance: bigint;
+        hasEnough: boolean;
+    }>;
+    checkHasSBT(address: Address): Promise<boolean>;
+    checkHasRole(roleId: `0x${string}`, address: Address): Promise<boolean>;
+}

package/dist/requirementChecker.js

@@ -0,0 +1,139 @@
+/**
+ * Unified requirement checker for role registration
+ * Provides centralized validation for GToken, aPNTs, MySBT, and role permissions
+ */
+import { parseAbi } from 'viem';
+const ERC20_ABI = parseAbi([
+    'function balanceOf(address) view returns (uint256)'
+]);
+const REGISTRY_ABI = parseAbi([
+    'function hasRole(bytes32, address) view returns (bool)',
+    'function roleStakes(bytes32, address) view returns (uint256)'
+]);
+const MYSBT_ABI = parseAbi([
+    'function balanceOf(address) view returns (uint256)'
+]);
+/**
+ * Requirement Checker Utility
+ *
+ * Centralized validation for all role requirements
+ */
+export class RequirementChecker {
+    publicClient;
+    addresses;
+    constructor(publicClient, addresses) {
+        this.publicClient = publicClient;
+        this.addresses = addresses;
+    }
+    async checkRequirements(params) {
+        const { address, roleId, requiredGToken = 0n, requiredAPNTs = 0n, requireSBT = false } = params;
+        const missingRequirements = [];
+        let hasRole = false;
+        if (roleId) {
+            const { CORE_ADDRESSES } = await import('./contract-addresses.js');
+            hasRole = await this.publicClient.readContract({
+                address: this.addresses?.registry || CORE_ADDRESSES.registry,
+                abi: REGISTRY_ABI,
+                functionName: 'hasRole',
+                args: [roleId, address]
+            });
+            if (!hasRole && params.roleId) {
+                missingRequirements.push(`Does not have required role`);
+            }
+        }
+        let hasEnoughGToken = true;
+        if (requiredGToken > 0n) {
+            const { CORE_ADDRESSES } = await import('./contract-addresses.js');
+            const gtokenBalance = await this.publicClient.readContract({
+                address: this.addresses?.gtoken || CORE_ADDRESSES.gToken,
+                abi: ERC20_ABI,
+                functionName: 'balanceOf',
+                args: [address]
+            });
+            hasEnoughGToken = gtokenBalance >= requiredGToken;
+            if (!hasEnoughGToken) {
+                missingRequirements.push(`Need ${requiredGToken.toString()} GToken, have ${gtokenBalance.toString()}`);
+            }
+        }
+        let hasEnoughAPNTs = true;
+        if (requiredAPNTs > 0n) {
+            const { CORE_ADDRESSES } = await import('./contract-addresses.js');
+            const apntsBalance = await this.publicClient.readContract({
+                address: this.addresses?.apnts || CORE_ADDRESSES.aPNTs,
+                abi: ERC20_ABI,
+                functionName: 'balanceOf',
+                args: [address]
+            });
+            hasEnoughAPNTs = apntsBalance >= requiredAPNTs;
+            if (!hasEnoughAPNTs) {
+                missingRequirements.push(`Need ${requiredAPNTs.toString()} aPNTs, have ${apntsBalance.toString()}`);
+            }
+        }
+        let hasSBT = false;
+        if (requireSBT) {
+            const { CORE_ADDRESSES } = await import('./contract-addresses.js');
+            const sbtBalance = await this.publicClient.readContract({
+                address: this.addresses?.mysbt || CORE_ADDRESSES.mySBT,
+                abi: MYSBT_ABI,
+                functionName: 'balanceOf',
+                args: [address]
+            });
+            hasSBT = sbtBalance > 0n;
+            if (!hasSBT) {
+                missingRequirements.push('Must hold at least one MySBT');
+            }
+        }
+        return {
+            hasRole,
+            hasEnoughGToken,
+            hasEnoughAPNTs,
+            hasSBT,
+            missingRequirements
+        };
+    }
+    async checkGTokenBalance(address, required) {
+        const { CORE_ADDRESSES } = await import('./contract-addresses.js');
+        const balance = await this.publicClient.readContract({
+            address: this.addresses?.gtoken || CORE_ADDRESSES.gToken,
+            abi: ERC20_ABI,
+            functionName: 'balanceOf',
+            args: [address]
+        });
+        return {
+            balance,
+            hasEnough: balance >= required
+        };
+    }
+    async checkAPNTsBalance(address, required) {
+        const { CORE_ADDRESSES } = await import('./contract-addresses.js');
+        const balance = await this.publicClient.readContract({
+            address: this.addresses?.apnts || CORE_ADDRESSES.aPNTs,
+            abi: ERC20_ABI,
+            functionName: 'balanceOf',
+            args: [address]
+        });
+        return {
+            balance,
+            hasEnough: balance >= required
+        };
+    }
+    async checkHasSBT(address) {
+        const { CORE_ADDRESSES } = await import('./contract-addresses.js');
+        const balance = await this.publicClient.readContract({
+            address: this.addresses?.mysbt || CORE_ADDRESSES.mySBT,
+            abi: MYSBT_ABI,
+            functionName: 'balanceOf',
+            args: [address]
+        });
+        return balance > 0n;
+    }
+    async checkHasRole(roleId, address) {
+        const { CORE_ADDRESSES } = await import('./contract-addresses.js');
+        return await this.publicClient.readContract({
+            address: this.addresses?.registry || CORE_ADDRESSES.registry,
+            abi: REGISTRY_ABI,
+            functionName: 'hasRole',
+            args: [roleId, address]
+        });
+    }
+}

package/dist/requirementChecker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/requirementChecker.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RequirementChecker } from './requirementChecker.js';
+describe('RequirementChecker', () => {
+    const MOCK_ADDR = '0x1111111111111111111111111111111111111111';
+    let mockPublicClient;
+    let checker;
+    beforeEach(() => {
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        checker = new RequirementChecker(mockPublicClient);
+    });
+    it('should check full requirements successfully', async () => {
+        mockPublicClient.readContract
+            .mockResolvedValueOnce(true) // hasRole
+            .mockResolvedValueOnce(1000n) // GToken balance
+            .mockResolvedValueOnce(500n) // aPNTs balance
+            .mockResolvedValueOnce(1n); // SBT balance
+        const result = await checker.checkRequirements({
+            address: MOCK_ADDR,
+            roleId: '0x1',
+            requiredGToken: 500n,
+            requiredAPNTs: 200n,
+            requireSBT: true
+        });
+        expect(result.hasRole).toBe(true);
+        expect(result.hasEnoughGToken).toBe(true);
+        expect(result.hasEnoughAPNTs).toBe(true);
+        expect(result.hasSBT).toBe(true);
+        expect(result.missingRequirements.length).toBe(0);
+    });
+    it('should identify missing requirements', async () => {
+        mockPublicClient.readContract
+            .mockResolvedValueOnce(false) // hasRole
+            .mockResolvedValueOnce(10n) // GToken balance
+            .mockResolvedValueOnce(0n) // aPNTs balance
+            .mockResolvedValueOnce(0n); // SBT balance
+        const result = await checker.checkRequirements({
+            address: MOCK_ADDR,
+            roleId: '0x1',
+            requiredGToken: 500n,
+            requiredAPNTs: 200n,
+            requireSBT: true
+        });
+        expect(result.hasRole).toBe(false);
+        expect(result.hasEnoughGToken).toBe(false);
+        expect(result.missingRequirements.length).toBe(4);
+    });
+    it('should check GToken balance shortcut', async () => {
+        mockPublicClient.readContract.mockResolvedValue(100n);
+        const result = await checker.checkGTokenBalance(MOCK_ADDR, 50n);
+        expect(result.hasEnough).toBe(true);
+        expect(result.balance).toBe(100n);
+    });
+    it('should check hasSBT shortcut', async () => {
+        mockPublicClient.readContract.mockResolvedValue(1n);
+        const hasSBT = await checker.checkHasSBT(MOCK_ADDR);
+        expect(hasSBT).toBe(true);
+    });
+});

package/dist/roles.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Role constants and utilities for AAstar SDK
+ * @remarks
+ * All role hashes and configurations match exactly with Registry.sol v3.0.0
+ *
+ * **Source**: /contracts/src/core/Registry.sol
+ */
+import { type Hash } from 'viem';
+/**
+ * Default Admin Role (OpenZeppelin AccessControl)
+ * @remarks
+ * - **Description**: Highest privilege, can grant/revoke all roles
+ * - **Permission**: Protocol governance only
+ * - **Source**: OpenZeppelin AccessControl DEFAULT_ADMIN_ROLE
+ */
+export declare const DEFAULT_ADMIN_ROLE: Hash;
+/**
+ * Community Role
+ * @remarks
+ * - **Description**: Community administrator, can issue xPNTs, configure SBT rules
+ * - **Permission**: Community-level governance
+ * - **Requirement**: minStake: 30 GT, entryBurn: 3 GT (line 99)
+ * - **Exit Fee**: 5% (500 basis points), min 1 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 32: ROLE_COMMUNITY = keccak256("COMMUNITY")
+ */
+export declare const ROLE_COMMUNITY: Hash;
+/**
+ * End User Role
+ * @remarks
+ * - **Description**: Community member, can participate and use gasless transactions
+ * - **Permission**: Basic user level
+ * - **Requirement**: minStake: 0.3 GT, entryBurn: 0.05 GT (line 100)
+ * - **Additional Requirement**: Must hold MySBT from community
+ * - **Exit Fee**: 10% (1000 basis points), min 0.05 GT
+ * - **Lock Duration**: 7 days
+ * - **Source**: Registry.sol line 33: ROLE_ENDUSER = keccak256("ENDUSER")
+ */
+export declare const ROLE_ENDUSER: Hash;
+/**
+ * Paymaster AOA Role (Account Ownership Authentication)
+ * @remarks
+ * - **Description**: Basic Paymaster node operator with account-based auth
+ * - **Permission**: Infrastructure operator
+ * - **Requirement**: minStake: 30 GT, entryBurn: 3 GT (line 92)
+ * - **Exit Fee**: 10% (1000 basis points), min 1 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 34: ROLE_PAYMASTER_AOA = keccak256("PAYMASTER_AOA")
+ */
+export declare const ROLE_PAYMASTER_AOA: Hash;
+/**
+ * Paymaster Super Role
+ * @remarks
+ * - **Description**: Advanced Paymaster operator, can use SuperPaymaster with aPNTs collateral
+ * - **Permission**: Infrastructure operator (higher tier)
+ * - **Requirement**: minStake: 50 GT, entryBurn: 5 GT (line 93)
+ * - **Additional Requirement**: aPNTs collateral in SuperPaymaster contract
+ * - **Exit Fee**: 10% (1000 basis points), min 2 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 35: ROLE_PAYMASTER_SUPER = keccak256("PAYMASTER_SUPER")
+ */
+export declare const ROLE_PAYMASTER_SUPER: Hash;
+/**
+ * DVT Role (Distributed Validator Technology)
+ * @remarks
+ * - **Description**: DVT node operator for consensus validation
+ * - **Permission**: Infrastructure operator
+ * - **Requirement**: minStake: 30 GT, entryBurn: 3 GT (line 94)
+ * - **Exit Fee**: 10% (1000 basis points), min 1 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 36: ROLE_DVT = keccak256("DVT")
+ */
+export declare const ROLE_DVT: Hash;
+/**
+ * ANODE Role (Anonymous Node)
+ * @remarks
+ * - **Description**: Anonymous infrastructure node operator
+ * - **Permission**: Infrastructure operator
+ * - **Requirement**: minStake: 20 GT, entryBurn: 2 GT (line 95)
+ * - **Exit Fee**: 10% (1000 basis points), min 1 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 37: ROLE_ANODE = keccak256("ANODE")
+ */
+export declare const ROLE_ANODE: Hash;
+/**
+ * KMS Role (Key Management Service)
+ * @remarks
+ * - **Description**: KMS operator for secure key storage and management
+ * - **Permission**: Infrastructure operator (highest stake)
+ * - **Requirement**: minStake: 100 GT, entryBurn: 10 GT (line 98)
+ * - **Exit Fee**: 10% (1000 basis points), min 5 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 38: ROLE_KMS = keccak256("KMS")
+ */
+export declare const ROLE_KMS: Hash;
+/**
+ * Role configuration structure (matches Registry.sol RoleConfig struct)
+ */
+export interface RoleConfig {
+    minStake: bigint;
+    entryBurn: bigint;
+    slashThreshold: number;
+    slashBase: number;
+    slashIncrement: number;
+    slashMax: number;
+    exitFeePercent: bigint;
+    minExitFee: bigint;
+    isActive: boolean;
+    description: string;
+}
+/**
+ * Role requirement check result
+ */
+export interface RoleRequirement {
+    hasRole: boolean;
+    hasEnoughGToken: boolean;
+    hasEnoughAPNTs: boolean;
+    hasSBT: boolean;
+    missingRequirements: string[];
+}
+export declare const ROLE_NAMES: Record<string, string>;
+/**
+ * Get human-readable role name
+ */
+export declare function getRoleName(roleHash: Hash): string;
+/**
+ * Role permission levels (for UI sorting/filtering)
+ */
+export declare enum RolePermissionLevel {
+    PROTOCOL = 100,// Default Admin
+    KMS = 80,// Key Management (highest stake)
+    OPERATOR = 50,// Infrastructure Operators
+    COMMUNITY = 30,// Community Admin
+    USER = 10
+}
+export declare const ROLE_PERMISSION_LEVELS: Record<string, RolePermissionLevel>;
+/**
+ * Exact stake requirements from Registry.sol constructor (lines 92-100)
+ * @remarks
+ * **Warning**: These are initial values, always query contract for current configuration
+ */
+export declare const INITIAL_ROLE_STAKES: {
+    readonly [x: string]: {
+        readonly minStake: "30 GT";
+        readonly entryBurn: "3 GT";
+        readonly exitFeePercent: "10%";
+        readonly minExitFee: "1 GT";
+        readonly lockDuration: "30 days";
+        readonly line: 92;
+        readonly additionalRequirement?: undefined;
+    } | {
+        readonly minStake: "50 GT";
+        readonly entryBurn: "5 GT";
+        readonly exitFeePercent: "10%";
+        readonly minExitFee: "2 GT";
+        readonly lockDuration: "30 days";
+        readonly additionalRequirement: "aPNTs collateral in SuperPaymaster";
+        readonly line: 93;
+    } | {
+        readonly minStake: "30 GT";
+        readonly entryBurn: "3 GT";
+        readonly exitFeePercent: "10%";
+        readonly minExitFee: "1 GT";
+        readonly lockDuration: "30 days";
+        readonly line: 94;
+        readonly additionalRequirement?: undefined;
+    } | {
+        readonly minStake: "20 GT";
+        readonly entryBurn: "2 GT";
+        readonly exitFeePercent: "10%";
+        readonly minExitFee: "1 GT";
+        readonly lockDuration: "30 days";
+        readonly line: 95;
+        readonly additionalRequirement?: undefined;
+    } | {
+        readonly minStake: "100 GT";
+        readonly entryBurn: "10 GT";
+        readonly exitFeePercent: "10%";
+        readonly minExitFee: "5 GT";
+        readonly lockDuration: "30 days";
+        readonly line: 98;
+        readonly additionalRequirement?: undefined;
+    } | {
+        readonly minStake: "30 GT";
+        readonly entryBurn: "3 GT";
+        readonly exitFeePercent: "5%";
+        readonly minExitFee: "1 GT";
+        readonly lockDuration: "30 days";
+        readonly line: 99;
+        readonly additionalRequirement?: undefined;
+    } | {
+        readonly minStake: "0.3 GT";
+        readonly entryBurn: "0.05 GT";
+        readonly exitFeePercent: "10%";
+        readonly minExitFee: "0.05 GT";
+        readonly lockDuration: "7 days";
+        readonly additionalRequirement: "Must hold MySBT from community";
+        readonly line: 100;
+    };
+};
+/**
+ * All defined roles array (for iteration)
+ */
+export declare const ALL_ROLES: readonly [`0x${string}`, `0x${string}`, `0x${string}`, `0x${string}`, `0x${string}`, `0x${string}`, `0x${string}`];