Struct TangleClient 

pub struct TangleClient {
    pub config: TangleClientConfig,
    /* private fields */
}

Tangle Client for interacting with Tangle v2 contracts

Fields

config: TangleClientConfig

Client configuration

Implementations

impl TangleClient

pub async fn new(config: TangleClientConfig) -> Result<Self>

Create a new Tangle client from configuration

Arguments

• config - Client configuration

Errors

Returns error if keystore initialization fails or RPC connection fails

pub async fn with_keystore( config: TangleClientConfig, keystore: Keystore, ) -> Result<Self>

Create a new Tangle client with an existing keystore

Arguments

• config - Client configuration
• keystore - Keystore instance

Errors

Returns error if RPC connection fails

pub fn tangle_contract(&self) -> ITangleInstance<Arc<TangleProvider>>

Get the Tangle contract instance

pub fn staking_contract( &self, ) -> IMultiAssetDelegationInstance<Arc<TangleProvider>>

Get the MultiAssetDelegation contract instance

pub fn status_registry_contract( &self, ) -> IOperatorStatusRegistryInstance<Arc<TangleProvider>>

Get the operator status registry contract instance

pub fn account(&self) -> Address

Get the operator’s account address

pub fn keystore(&self) -> &Arc<Keystore>

Get the keystore

pub fn provider(&self) -> &Arc<TangleProvider>

Get the provider

pub fn tangle_address(&self) -> Address

Get the Tangle contract address

pub fn ecdsa_signing_key(&self) -> Result<K256SigningKey>

Get the ECDSA signing key from the keystore

Errors

Returns error if the key is not found in the keystore

pub fn wallet(&self) -> Result<EthereumWallet>

Get an Ethereum wallet for signing transactions

Errors

Returns error if the key is not found or wallet creation fails

pub async fn block_number(&self) -> Result<u64>

Get the current block number

pub async fn get_block(&self, number: BlockNumberOrTag) -> Result<Option<Block>>

Get a block by number

pub async fn get_logs(&self, filter: &Filter) -> Result<Vec<Log>>

Get logs matching a filter

pub async fn next_event(&self) -> Option<TangleEvent>

Get the next event (polls for new blocks)

On the first call, scans a small recent window to catch up on any near-realtime events while staying compatible with hosted RPC plans that cap eth_getLogs block ranges. Older active services are still discovered by the manager’s contract-state fallback during initialize. Subsequent calls only scan new blocks.

pub async fn latest_event(&self) -> Option<TangleEvent>

Get the latest observed event

pub async fn now(&self) -> Option<B256>

Get the current block hash

pub async fn get_blueprint(&self, blueprint_id: u64) -> Result<Blueprint>

Get blueprint information

pub async fn get_raw_blueprint_definition( &self, blueprint_id: u64, ) -> Result<Vec<u8>>

Fetch the raw ABI-encoded blueprint definition bytes.

pub async fn get_blueprint_config( &self, blueprint_id: u64, ) -> Result<BlueprintConfig>

Get blueprint configuration

pub async fn get_blueprint_definition( &self, blueprint_id: u64, ) -> Result<BlueprintDefinition>

Get the full blueprint definition.

pub async fn create_blueprint( &self, encoded_definition: Vec<u8>, ) -> Result<(TransactionResult, u64)>

Create a new blueprint from an encoded definition.

pub async fn is_operator_registered( &self, blueprint_id: u64, operator: Address, ) -> Result<bool>

Check if operator is registered for blueprint

pub async fn get_service(&self, service_id: u64) -> Result<Service>

Get service information

pub async fn get_service_operators( &self, service_id: u64, ) -> Result<Vec<Address>>

Get service operators

pub async fn is_service_operator( &self, service_id: u64, operator: Address, ) -> Result<bool>

Check if address is a service operator

pub async fn get_service_operator( &self, service_id: u64, operator: Address, ) -> Result<ServiceOperator>

Get service operator info including exposure

Returns the ServiceOperator struct which contains exposureBps.

pub async fn get_service_total_exposure(&self, service_id: u64) -> Result<U256>

Get total exposure for a service

Returns the sum of all operator exposureBps values.

pub async fn get_service_operator_weights( &self, service_id: u64, ) -> Result<BTreeMap<Address, u16>>

Get operator weights (exposureBps) for all operators in a service

Returns a map of operator address to their exposure in basis points. This is useful for stake-weighted BLS signature threshold calculations.

pub async fn register_operator( &self, blueprint_id: u64, rpc_endpoint: impl Into<String>, registration_inputs: Option<Bytes>, ) -> Result<TransactionResult>

Register the current operator for a blueprint.

pub async fn unregister_operator( &self, blueprint_id: u64, ) -> Result<TransactionResult>

Unregister the current operator from a blueprint.

pub async fn blueprint_count(&self) -> Result<u64>

Get the number of registered blueprints.

pub async fn service_count(&self) -> Result<u64>

Get the number of registered services.

pub async fn get_service_request( &self, request_id: u64, ) -> Result<ServiceRequest>

Get a service request by ID.

pub async fn service_request_count(&self) -> Result<u64>

Get the total number of service requests ever created.

pub async fn get_job_call( &self, service_id: u64, call_id: u64, ) -> Result<JobCall>

Fetch metadata recorded for a specific job call.

pub async fn get_operator_metadata( &self, blueprint_id: u64, operator: Address, ) -> Result<OperatorMetadata>

Fetch operator metadata (ECDSA public key + RPC endpoint) for a blueprint.

pub async fn request_service( &self, params: ServiceRequestParams, ) -> Result<(TransactionResult, u64)>

Submit a service request.

pub async fn join_service( &self, service_id: u64, exposure_bps: u16, ) -> Result<TransactionResult>

Join a dynamic service with the requested exposure.

pub async fn join_service_with_commitments( &self, service_id: u64, exposure_bps: u16, commitments: Vec<AssetSecurityCommitment>, ) -> Result<TransactionResult>

Join a dynamic service with the requested exposure and explicit security commitments.

Use this method when the service has security requirements that mandate operators provide asset commitments when joining.

pub async fn leave_service(&self, service_id: u64) -> Result<TransactionResult>

Leave a dynamic service using the legacy immediate exit helper.

Note: This only works when exitQueueDuration == 0. For services with an exit queue (default 7 days), use the exit queue workflow:

1. schedule_exit() - Enter the exit queue
2. Wait for exit queue duration
3. execute_exit() - Complete the exit

pub async fn schedule_exit(&self, service_id: u64) -> Result<TransactionResult>

Schedule an exit from a dynamic service.

This enters the operator into the exit queue. After the exit queue duration has passed (default 7 days), call execute_exit() to complete the exit.

Requires that the operator has fulfilled the minimum commitment duration since joining the service.

pub async fn execute_exit(&self, service_id: u64) -> Result<TransactionResult>

Execute a previously scheduled exit from a dynamic service.

This completes the exit after the exit queue duration has passed. Must be called after schedule_exit() and waiting for the queue duration.

pub async fn cancel_exit(&self, service_id: u64) -> Result<TransactionResult>

Cancel a previously scheduled exit from a dynamic service.

This cancels the exit and keeps the operator in the service. Can only be called before execute_exit().

pub async fn approve_service( &self, request_id: u64, restaking_percent: u8, ) -> Result<TransactionResult>

Approve a pending service request with a simple restaking percentage.

pub async fn approve_service_with_commitments( &self, request_id: u64, commitments: Vec<AssetSecurityCommitment>, ) -> Result<TransactionResult>

Approve a service request with explicit security commitments.

pub async fn reject_service(&self, request_id: u64) -> Result<TransactionResult>

Reject a pending service request.

pub async fn is_operator(&self, operator: Address) -> Result<bool>

Check if address is a registered operator

pub async fn is_operator_active(&self, operator: Address) -> Result<bool>

Check if operator is active

pub async fn get_operator_stake(&self, operator: Address) -> Result<U256>

Get operator’s total stake

pub async fn min_operator_stake(&self) -> Result<U256>

Get minimum operator stake requirement

pub async fn operator_status( &self, service_id: u64, operator: Address, ) -> Result<OperatorStatusSnapshot>

Fetch status registry metadata for an operator/service pair.

pub async fn get_restaking_metadata( &self, operator: Address, ) -> Result<RestakingMetadata>

Fetch restaking metadata for an operator.

pub async fn get_operator_self_stake(&self, operator: Address) -> Result<U256>

Get operator self stake from MultiAssetDelegation.

pub async fn get_operator_delegated_stake( &self, operator: Address, ) -> Result<U256>

Get operator delegated stake from MultiAssetDelegation.

pub async fn get_operator_delegators( &self, operator: Address, ) -> Result<Vec<Address>>

Get delegators for the operator.

pub async fn get_operator_delegator_count( &self, operator: Address, ) -> Result<u64>

Get delegator count for the operator.

pub async fn restaking_round(&self) -> Result<u64>

Get current restaking round.

pub async fn operator_commission_bps(&self) -> Result<u16>

Get operator commission (basis points).

pub async fn get_delegation_mode( &self, operator: Address, ) -> Result<DelegationMode>

Get operator’s delegation mode.

Returns the delegation policy for the operator:

• Disabled: Only operator can self-stake
• Whitelist: Only approved addresses can delegate
• Open: Anyone can delegate

pub async fn is_delegator_whitelisted( &self, operator: Address, delegator: Address, ) -> Result<bool>

Check if delegator is whitelisted for operator.

pub async fn can_delegate( &self, operator: Address, delegator: Address, ) -> Result<bool>

Check if delegator can delegate to operator.

This checks the operator’s delegation mode and whitelist status.

pub async fn set_delegation_mode( &self, mode: DelegationMode, ) -> Result<TransactionResult>

Set delegation mode for the calling operator.

Changes take effect immediately for NEW delegations only. Existing delegations remain valid regardless of mode change.

Arguments

• mode - Delegation mode: Disabled (0), Whitelist (1), or Open (2)

pub async fn set_delegation_whitelist( &self, delegators: Vec<Address>, approved: bool, ) -> Result<TransactionResult>

Update delegation whitelist for the calling operator.

Whitelist only applies when delegation mode is set to Whitelist. Can be called regardless of current mode to pre-configure.

Arguments

• delegators - Array of delegator addresses to update
• approved - True to approve for delegation, false to revoke

pub async fn erc20_allowance( &self, token: Address, owner: Address, spender: Address, ) -> Result<U256>

Fetch ERC20 allowance for an owner/spender pair.

pub async fn erc20_balance( &self, token: Address, owner: Address, ) -> Result<U256>

Fetch ERC20 balance for an owner.

pub async fn erc20_approve( &self, token: Address, spender: Address, amount: U256, ) -> Result<TransactionResult>

Approve ERC20 spending for the given spender.

pub async fn get_deposit_info( &self, delegator: Address, token: Address, ) -> Result<DepositInfo>

Fetch delegator deposit info for a token.

pub async fn get_locks( &self, delegator: Address, token: Address, ) -> Result<Vec<LockInfo>>

Fetch lock info for a token.

pub async fn get_delegations( &self, delegator: Address, ) -> Result<Vec<DelegationInfo>>

Fetch delegations for a delegator.

pub async fn get_delegations_with_blueprints( &self, delegator: Address, ) -> Result<Vec<DelegationRecord>>

Fetch delegations with blueprint selections attached.

pub async fn get_delegation_blueprints( &self, delegator: Address, index: u64, ) -> Result<Vec<u64>>

Fetch blueprint IDs for a fixed delegation.

pub async fn get_pending_unstakes( &self, delegator: Address, ) -> Result<Vec<PendingUnstake>>

Fetch pending delegator unstakes.

pub async fn get_pending_withdrawals( &self, delegator: Address, ) -> Result<Vec<PendingWithdrawal>>

Fetch pending delegator withdrawals.

pub async fn deposit_and_delegate_with_options( &self, operator: Address, token: Address, amount: U256, selection_mode: BlueprintSelectionMode, blueprint_ids: Vec<u64>, ) -> Result<TransactionResult>

Deposit and delegate in a single call.

pub async fn delegate_with_options( &self, operator: Address, token: Address, amount: U256, selection_mode: BlueprintSelectionMode, blueprint_ids: Vec<u64>, ) -> Result<TransactionResult>

Delegate existing deposits with explicit selection.

pub async fn schedule_delegator_unstake( &self, operator: Address, token: Address, amount: U256, ) -> Result<TransactionResult>

Schedule a delegator unstake (bond-less).

pub async fn execute_delegator_unstake(&self) -> Result<TransactionResult>

Execute any matured delegator unstake requests.

pub async fn execute_delegator_unstake_and_withdraw( &self, operator: Address, token: Address, shares: U256, requested_round: u64, receiver: Address, ) -> Result<TransactionResult>

Execute a specific delegator unstake and withdraw.

pub async fn schedule_withdraw( &self, token: Address, amount: U256, ) -> Result<TransactionResult>

Schedule a withdrawal for a token.

pub async fn execute_withdraw(&self) -> Result<TransactionResult>

Execute any matured withdrawal requests.

pub async fn schedule_operator_unstake( &self, amount: U256, ) -> Result<TransactionResult>

Schedule an operator unstake.

pub async fn execute_operator_unstake(&self) -> Result<TransactionResult>

Execute an operator unstake.

pub async fn start_leaving(&self) -> Result<TransactionResult>

Start leaving the operator set.

pub async fn complete_leaving(&self) -> Result<TransactionResult>

Complete leaving after delay.

pub async fn operator_bond_token(&self) -> Result<Address>

Get the operator bond token address.

Returns Address::ZERO if native ETH is used for operator bonds, otherwise returns the ERC20 token address (e.g., TNT).

pub async fn register_operator_restaking( &self, stake_amount: U256, ) -> Result<TransactionResult>

Register as an operator on the restaking layer.

Automatically uses the configured bond token (native ETH or ERC20 like TNT). For ERC20 tokens, automatically approves the staking contract first.

pub async fn increase_stake(&self, amount: U256) -> Result<TransactionResult>

Increase operator stake.

Automatically uses the configured bond token (native ETH or ERC20 like TNT). For ERC20 tokens, automatically approves the staking contract first.

pub async fn deposit_native(&self, amount: U256) -> Result<TransactionResult>

Deposit native ETH without delegating.

Use this to pre-fund your account before delegating.

pub async fn deposit_erc20( &self, token: Address, amount: U256, ) -> Result<TransactionResult>

Deposit ERC20 tokens without delegating.

Use this to pre-fund your account before delegating.

pub async fn get_blueprint_manager( &self, service_id: u64, ) -> Result<Option<Address>>

Get the blueprint manager address for a service

pub async fn requires_aggregation( &self, service_id: u64, job_index: u8, ) -> Result<bool>

Check if a job requires BLS aggregation

Queries the blueprint’s service manager contract to determine if the specified job index requires aggregated BLS signatures instead of individual results.

pub async fn get_aggregation_threshold( &self, service_id: u64, job_index: u8, ) -> Result<(u16, u8)>

Get the aggregation threshold configuration for a job

Returns (threshold_bps, threshold_type) where:

• threshold_bps: Threshold in basis points (e.g., 6700 = 67%)
• threshold_type: 0 = CountBased (% of operators), 1 = StakeWeighted (% of stake)

pub async fn get_aggregation_config( &self, service_id: u64, job_index: u8, ) -> Result<AggregationConfig>

Get the aggregation configuration for a specific job

Returns the full aggregation config including whether it’s required and threshold settings

pub async fn submit_job( &self, service_id: u64, job_index: u8, inputs: Bytes, ) -> Result<JobSubmissionResult>

Submit a job invocation to the Tangle contract.

pub async fn submit_job_with_value( &self, service_id: u64, job_index: u8, inputs: Bytes, value: U256, ) -> Result<JobSubmissionResult>

Submit a job invocation with native token payment.

For EventDriven services the caller should send event_rate as value. For free jobs or services that don’t charge per-event, pass U256::ZERO.

pub async fn submit_job_from_quote( &self, service_id: u64, job_index: u8, inputs: Bytes, quotes: Vec<SignedJobQuote>, ) -> Result<JobSubmissionResult>

Submit a job from operator-signed quotes with payment.

Calls the on-chain submitJobFromQuote function. The total quoted price is sent as native value with the transaction.

pub async fn submit_result( &self, service_id: u64, call_id: u64, output: Bytes, ) -> Result<TransactionResult>

Submit a job result to the Tangle contract

This sends a signed transaction to submit a single operator’s result.

Arguments

• service_id - The service ID
• call_id - The call/job ID
• output - The encoded result output

Returns

The transaction hash and receipt on success

pub async fn submit_aggregated_result( &self, service_id: u64, call_id: u64, output: Bytes, signer_bitmap: U256, aggregated_signature: [U256; 2], aggregated_pubkey: [U256; 4], ) -> Result<TransactionResult>

Submit an aggregated BLS signature result to the Tangle contract

This sends a signed transaction to submit an aggregated result with BLS signature.

Arguments

• service_id - The service ID
• call_id - The call/job ID
• output - The encoded result output
• signer_bitmap - Bitmap indicating which operators signed
• aggregated_signature - The aggregated BLS signature [2]
• aggregated_pubkey - The aggregated BLS public key [4]

Returns

The transaction hash and receipt on success

impl TangleClient

Extension trait for service-related operations on TangleClient

pub async fn get_service_info(&self, service_id: u64) -> Result<ServiceInfo>

Get full service information

pub async fn get_blueprint_info( &self, blueprint_id: u64, ) -> Result<BlueprintInfo>

Get full blueprint information

pub async fn get_blueprint_config_info( &self, blueprint_id: u64, ) -> Result<BlueprintConfig>

Get full blueprint configuration

pub async fn get_operator_services(&self, operator: Address) -> Result<Vec<u64>>

Get services for an operator

Queries all services and filters for those where the operator is active

pub async fn is_registered_for_blueprint(&self) -> Result<bool>

Check if current operator is registered for the configured blueprint

pub async fn is_operator_active_in_restaking(&self) -> Result<bool>

Check if current operator is active in the restaking system

pub async fn get_own_stake(&self) -> Result<U256>

Get current operator’s stake

pub async fn list_blueprints(&self) -> Result<Vec<(u64, BlueprintInfo)>>

Fetch all blueprint summaries.

pub async fn list_services(&self) -> Result<Vec<(u64, ServiceInfo)>>

Fetch all services registered on-chain.

pub async fn get_service_request_info( &self, request_id: u64, ) -> Result<ServiceRequestInfo>

Fetch a single service request.

pub async fn list_service_requests(&self) -> Result<Vec<ServiceRequestInfo>>

List all service requests ever recorded on-chain.

impl TangleClient

pub async fn get_service_operators_with_exposure( &self, service_id: u64, ) -> Result<Vec<OperatorSecurityCommitment>>

Get operators with their security commitments for a service

Trait Implementations

impl BlueprintServicesClient for TangleClient

async fn get_operators( &self, ) -> Result<OperatorSet<Self::PublicAccountIdentity, Self::PublicApplicationIdentity>, Self::Error>

Get all operators for the current service with their ECDSA keys

async fn operator_id( &self, ) -> Result<Self::PublicApplicationIdentity, Self::Error>

Get the current operator’s ECDSA public key

async fn blueprint_id(&self) -> Result<Self::Id, Self::Error>

Get the current blueprint ID

type PublicApplicationIdentity = [u8; 65]

The ID of for operators at the blueprint/application layer. Typically a cryptograpgic key in the form of a point on some elliptic curve, e.g., an ECDSA public key (point). However, this is not required.

type PublicAccountIdentity = Address

The ID of the operator’s account, not necessarily associated with the PublicApplicationIdentity, but may be cryptographically related thereto. E.g., AccountId32

type Id = u64

A generalized ID that distinguishes the current blueprint from others

type Error = Error

async fn get_operators_and_operator_id( &self, ) -> Result<(BTreeMap<usize, Self::PublicApplicationIdentity>, usize), Self::Error>

Returns an operator set with the index of the current operator within that set

async fn get_operator_index(&self) -> Result<usize, Self::Error>

Returns the index of the current operator in the operator set

impl Clone for TangleClient

fn clone(&self) -> TangleClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TangleClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EventsClient<TangleEvent> for TangleClient

async fn next_event(&self) -> Option<TangleEvent>

Get the next event

async fn latest_event(&self) -> Option<TangleEvent>

Get the latest event