RulesEngine

Defined in: src/modules/rules-engine.ts:139

​

Methods

​

addAdminToPermissionList()

addAdminToPermissionList(foreignCallAddress, functionSelector, policyAdminToAdd): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:789 Adds a new address to the permission list for a foreign call.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

​

Throws

Will log an error to the console if the operation fails.

---

​

addClosedPolicySubscriber()

addClosedPolicySubscriber(policyId, subscriber): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:477 Adds a subscriber to the closed policy.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

---

​

addMultipleAdminsToPermissionList()

addMultipleAdminsToPermissionList(foreignCallAddress, functionSelector, policyAdminsToAdd): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:814 Adds multiple addresses to the permission list for a foreign call.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

​

Throws

Will log an error to the console if the operation fails.

---

​

appendPolicy()

appendPolicy(policyId, contractAddressForPolicy): void

Defined in: src/modules/rules-engine.ts:335 Appends a policy to the list of policies applied to a specific contract address.

​

Parameters

​

Returns

void

---

​

cementPolicy()

cementPolicy(policyId): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:1502 Cements a policy on the Rules Engine.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

---

​

closePolicy()

closePolicy(policyId): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:446 Closes a policy on the Rules Engine.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

---

​

confirmNewCallingContractAdmin()

confirmNewCallingContractAdmin(callingContractAddress): void

Defined in: src/modules/rules-engine.ts:1353 Confirm a new calling contract admin in the rules engine admin contract. This function confirms a new admin for a specific calling contract.

​

Parameters

​

Returns

void A promise that resolves to the result of the contract interaction, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

confirmNewForeignCallAdmin()

confirmNewForeignCallAdmin(foreignCallAddress, foreignCallSelector): void

Defined in: src/modules/rules-engine.ts:1436 Confirm a new foreign call admin in the rules engine admin contract. This function confirms a new admin for a specific foreign call.

​

Parameters

​

Returns

void A promise.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

confirmNewPolicyAdmin()

confirmNewPolicyAdmin(policyId): void

Defined in: src/modules/rules-engine.ts:1282 Confirm a new admin in the rules engine admin contract. This function confirms a new admin for a specific policy.

​

Parameters

​

Returns

void A promise that resolves to the result of the contract interaction, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

createCallingFunction()

createCallingFunction(policyId, callingFunction, name, encodedValues): Promise<{ functionId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:1148 Creates a calling function in the rules engine component contract. This function parses the provided calling function, maps its arguments to their respective types, and interacts with the smart contract to create the calling function. If the contract interaction fails, it retries with a delay until successful.

​

Parameters

​

Returns

Promise<{ functionId: number; transactionHash: `0x${string}`; }> A promise that resolves to object with functionId and transactionHash, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

createForeignCall()

createForeignCall(policyId, fcSyntax): Promise<{ foreignCallId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:643 Creates a foreign call in the rules engine component contract.

​

Parameters

​

Returns

Promise<{ foreignCallId: number; transactionHash: `0x${string}`; }> A promise that resolves to object with foreignCallId and transactionHash. Returns -1 if the operation fails.

​

Remarks

• The function retries the contract interaction in case of failure, with a delay of 1 second between attempts.
• The simulateContract function is used to simulate the contract interaction before writing to the blockchain.
• The writeContract function is used to execute the contract interaction on the blockchain.
• The function returns the foreignCallIndex for an updated foreign call or the result of the newly created foreign call.

​

Throws

Will throw an error if the JSON parsing of fcSyntax fails.

---

​

createMappedTracker()

createMappedTracker(policyId, mappedTrackerSyntax): Promise<{ trackerId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:984 Asynchronously creates a mapped tracker in the rules engine component contract.

​

Parameters

​

Returns

Promise<{ trackerId: number; transactionHash: `0x${string}`; }> Object with trackerId and transactionHash.

---

​

createNewRule()

createNewRule(policyId, ruleS, foreignCallNameToID, trackerNameToID): Promise<{ ruleId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:517 Asynchronously creates a new rule in the rules engine policy contract.

​

Parameters

​

Returns

Promise<{ ruleId: number; transactionHash: `0x${string}`; }> A promise that resolves to the result of the rule creation operation. Returns the rule ID if successful, or -1 if the operation fails.

​

Remarks

• The function parses the rule JSON string to build the rule and effect structures.
• It uses a retry mechanism with a delay to handle potential failures during contract simulation.

---

​

createPolicy()

createPolicy(policyJSON): Promise<{ callingFunctions: object[]; foreignCalls: object[]; policyId: number; rules: object[]; trackers: object[]; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:234 Creates a policy in the Rules Engine.

​

Parameters

​

Returns

Promise<{ callingFunctions: object[]; foreignCalls: object[]; policyId: number; rules: object[]; trackers: object[]; transactionHash: `0x${string}`; }> An object containing the policy ID, transaction hash, and individual transaction hashes for all created components.

---

​

createTracker()

createTracker(policyId, trSyntax): Promise<{ trackerId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:973 Asynchronously creates a tracker in the rules engine component contract.

​

Parameters

​

Returns

Promise<{ trackerId: number; transactionHash: `0x${string}`; }> A promise that resolves to object with trackerId and transactionHash.

​

Throws

Will retry indefinitely with a 1-second delay between attempts if an error occurs during the contract simulation. Ensure proper error handling or timeout mechanisms are implemented to avoid infinite loops.

---

​

deleteCallingFunction()

deleteCallingFunction(policyId, callingFunctionId): Promise<number>

Defined in: src/modules/rules-engine.ts:1205 Delete a calling function from the rules engine component contract.

​

Parameters

​

Returns

Promise<number> A promise that resolves to the result of the contract interaction, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

deleteForeignCall()

deleteForeignCall(policyId, foreignCallId): Promise<number>

Defined in: src/modules/rules-engine.ts:695 Deletes a foreign call associated with a specific policy in the rules engine component contract.

​

Parameters

​

Returns

Promise<number> A promise that resolves to a number: - 0 if the operation is successful. - -1 if an error occurs during the simulation of the contract interaction.

​

Throws

This function does not explicitly throw errors but will return -1 if an error occurs during the simulation phase.

---

​

deletePolicy()

deletePolicy(policyId): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:351 Deletes a policy from the Rules Engine.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

---

​

deleteRule()

deleteRule(policyId, ruleId): Promise<number>

Defined in: src/modules/rules-engine.ts:581 Deletes a rule from the rules engine component contract.

​

Parameters

​

Returns

Promise<number> A promise that resolves to a number: - 0 if the rule was successfully deleted. - -1 if an error occurred during the deletion process.

​

Throws

This function does not throw errors directly but returns -1 in case of an exception.

---

​

deleteTracker()

deleteTracker(policyId, trackerId): Promise<number>

Defined in: src/modules/rules-engine.ts:1046 Deletes a tracker associated with a specific policy in the rules engine component contract.

​

Parameters

​

Returns

Promise<number> A promise that resolves to a number: - 0 if the tracker was successfully deleted. - -1 if an error occurred during the simulation of the contract interaction.

​

Throws

This function does not explicitly throw errors but will return -1 if an error occurs during the simulation phase.

---

​

disablePolicy()

disablePolicy(policyId): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:426 Disable a policy on the Rules Engine.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

---

​

getAllForeignCalls()

getAllForeignCalls(policyId, blockParams?): Promise<Maybe<any[]>>

Defined in: src/modules/rules-engine.ts:728 Retrieves all foreign calls associated with a specific policy ID from the Rules Engine Component Contract.

​

Parameters

​

Returns

Promise<Maybe<any[]>> A promise that resolves to an array of foreign calls if successful, or null if an error occurs.

​

Throws

Will log an error to the console if the operation fails.

---

​

getAllRules()

getAllRules(policyId, blockParams?): Promise<Maybe<any[]>>

Defined in: src/modules/rules-engine.ts:624 Retrieves all rules associated with a specific policy ID from the Rules Engine Policy Contract.

​

Parameters

​

Returns

Promise<Maybe<any[]>> A promise that resolves to an array of rules if successful, or null if an error occurs.

​

Throws

Will log an error to the console if the operation fails.

---

​

getAllTrackers()

getAllTrackers(policyId, blockParams?): Promise<Maybe<any[]>>

Defined in: src/modules/rules-engine.ts:1093 Retrieves all trackers associated with a specific policy ID from the Rules Engine Component Contract.

​

Parameters

​

Returns

Promise<Maybe<any[]>> A promise that resolves to an array of trackers if successful, or null if an error occurs.

​

Throws

Will log an error to the console if the operation fails.

---

​

getAppliedPolicyIds()

getAppliedPolicyIds(address, blockParams?): Promise<number[]>

Defined in: src/modules/rules-engine.ts:396 Retrieves the IDs of all of the policies that have been applied to a contract address.

​

Parameters

​

Returns

Promise<number[]> array of all of the policy ids applied to the contract

---

​

getCallingFunctionMetadata()

getCallingFunctionMetadata(policyId, callingFunctionId, blockParams?): Promise<CallingFunctionHashMapping>

Defined in: src/modules/rules-engine.ts:1225 retrieves the metadata for a xscalling function from the rules engine component contract.

​

Parameters

​

Returns

Promise<CallingFunctionHashMapping> A promise that resolves to the result of the contract interaction.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

getCallingFunctions()

getCallingFunctions(policyId, blockParams?): Promise<CallingFunctionOnChain[]>

Defined in: src/modules/rules-engine.ts:1247 retrieves calling functions for a policy from the rules engine component contract.

​

Parameters

​

Returns

Promise<CallingFunctionOnChain[]> A promise that resolves to CallingFunctionHashMapping.

---

​

getForeignCall()

getForeignCall(policyId, foreignCallId, blockParams?): Promise<any>

Defined in: src/modules/rules-engine.ts:715 Retrieves the result of a foreign call from the rules engine component contract.

​

Parameters

​

Returns

Promise<any> A promise that resolves to the result of the foreign call, or null if an error occurs.

​

Throws

Will log an error to the console if the contract interaction fails.

---

​

getForeignCallMetadata()

getForeignCallMetadata(policyId, foreignCallId, blockParams?): Promise<any>

Defined in: src/modules/rules-engine.ts:741 Retrieves the metadata for a foreign call from the rules engine component contract.

​

Parameters

​

Returns

Promise<any> A promise that resolves to the result of the foreign call, or null if an error occurs.

​

Throws

Will log an error to the console if the contract interaction fails.

---

​

getForeignCallPermissionList()

getForeignCallPermissionList(foreignCallAddress, functionSelector, blockParams?): Promise<`0x${string}`[]>

Defined in: src/modules/rules-engine.ts:765 Retrieves the permission list for a permissioned foreign call.

​

Parameters

​

Returns

Promise<`0x${string}`[]> Array of addresses that make up the permission list

​

Throws

Will log an error to the console if the operation fails.

---

​

getMappedTrackerValue()

getMappedTrackerValue(policyId, index, key, blockParams?): Promise<any>

Defined in: src/modules/rules-engine.ts:1075 Retrieves a mapped tracker value from the Rules Engine Component Contract based on the provided policy ID, tracker ID, and key.

​

Parameters

​

Returns

Promise<any> A promise that resolves to the tracker result if successful, or null if an error occurs.

​

Throws

Will log an error to the console if the contract interaction fails.

---

​

getPermissionedForeignCallsForPolicy()

getPermissionedForeignCallsForPolicy(policyId, blockParams?): Promise<ForeignCallOnChain[]>

Defined in: src/modules/rules-engine.ts:882 Gets permissioned foreign calls for a specific policy ID.

​

Parameters

​

Returns

Promise<ForeignCallOnChain[]> A promise that resolves to ForeignCallOnChain[]:

​

Throws

Will log an error to the console if the operation fails.

---

​

getPolicy()

getPolicy(policyId, blockParams?): Promise<Maybe<PolicyJSON>>

Defined in: src/modules/rules-engine.ts:362 Retrieves the full policy, including rules, trackers, and foreign calls, as a JSON string.

​

Parameters

​

Returns

Promise<Maybe<PolicyJSON>> — A PolicyResult object containing both the policy object and JSON string, or an empty string if an error occurs.

---

​

getPolicyMetadata()

getPolicyMetadata(policyId, blockParams?): Promise<Maybe<PolicyMetadataStruct>>

Defined in: src/modules/rules-engine.ts:383 Retrieves the metadata for a policy from the Rules Engine Policy Contract based on the provided policy ID.

​

Parameters

​

Returns

Promise<Maybe<PolicyMetadataStruct>> A promise that resolves to the policy metadata result if successful, or null if an error occurs.

​

Throws

Will log an error to the console if the contract interaction fails.

---

​

getRule()

getRule(policyId, ruleId, blockParams?): Promise<Maybe<RuleOnChain>>

Defined in: src/modules/rules-engine.ts:593 Retrieves a specific rule from the Rules Engine.

​

Parameters

​

Returns

Promise<Maybe<RuleOnChain>> The retrieved rule as a RuleOnChain, or null if retrieval fails.

---

​

getRuleMetadata()

getRuleMetadata(policyId, ruleId, blockParams?): Promise<Maybe<RuleMetadataStruct>>

Defined in: src/modules/rules-engine.ts:607 Retrieves the metadata for a rule from the Rules Engine Rules Contract based on the provided policy ID and rule ID.

​

Parameters

​

Returns

Promise<Maybe<RuleMetadataStruct>> A promise that resolves to the rule metadata result if successful, or null if an error occurs.

​

Throws

Will log an error to the console if the contract interaction fails.

---

​

getRulesEngineComponentContract()

getRulesEngineComponentContract(): object

Defined in: src/modules/rules-engine.ts:191

​

Returns

object

abi

abi: ({ anonymous: undefined; inputs: ({ components: undefined; internalType: string; name: string; type: string; } | { components: object[]; internalType: string; name: string; type: string; })[]; name: string; outputs: object[]; stateMutability: string; type: string; } | { anonymous: undefined; inputs: object[]; name: string; outputs: object[]; stateMutability: string; type: string; } | { anonymous: boolean; inputs: object[]; name: string; outputs: undefined; stateMutability: undefined; type: string; })[]

address

address: `0x${string}`

---

​

getRulesEngineForeignCallContract()

getRulesEngineForeignCallContract(): object

Defined in: src/modules/rules-engine.ts:197

​

Returns

object

abi

abi: ({ anonymous: undefined; inputs: ({ components: undefined; internalType: string; name: string; type: string; } | { components: ({ components: undefined; internalType: string; name: string; type: string; } | { components: …[]; internalType: string; name: string; type: string; })[]; internalType: string; name: string; type: string; })[]; name: string; outputs: object[]; stateMutability: string; type: string; } | { anonymous: undefined; inputs: ({ components: undefined; internalType: string; name: string; type: string; } | { components: ({ components: undefined; internalType: string; name: string; type: string; } | { components: …[]; internalType: string; name: string; type: string; })[]; internalType: string; name: string; type: string; })[]; name: string; outputs: object[]; stateMutability: string; type: string; } | { anonymous: boolean; inputs: object[]; name: string; outputs: undefined; stateMutability: undefined; type: string; })[]

address

address: `0x${string}`

---

​

getRulesEnginePolicyContract()

getRulesEnginePolicyContract(): object

Defined in: src/modules/rules-engine.ts:188

​

Returns

object

abi

abi: ({ anonymous: undefined; inputs: object[]; name: string; outputs: object[]; stateMutability: string; type: string; } | { anonymous: undefined; inputs: object[]; name: string; outputs: object[]; stateMutability: string; type: string; } | { anonymous: boolean; inputs: object[]; name: string; outputs: undefined; stateMutability: undefined; type: string; })[]

address

address: `0x${string}`

---

​

getRulesEngineRulesContract()

getRulesEngineRulesContract(): object

Defined in: src/modules/rules-engine.ts:194

​

Returns

object

abi

abi: ({ anonymous: undefined; inputs: ({ components: undefined; internalType: string; name: string; type: string; } | { components: ({ components: undefined; internalType: string; name: string; type: string; } | { components: …[]; internalType: string; name: string; type: string; })[]; internalType: string; name: string; type: string; })[]; name: string; outputs: object[]; stateMutability: string; type: string; } | { anonymous: undefined; inputs: object[]; name: string; outputs: object[]; stateMutability: string; type: string; } | { anonymous: boolean; inputs: object[]; name: string; outputs: undefined; stateMutability: undefined; type: string; })[]

address

address: `0x${string}`

---

​

getRulesEngineVersion()

getRulesEngineVersion(): Promise<string>

Defined in: src/modules/rules-engine.ts:253

​

Returns

Promise<string>

---

​

getTracker()

getTracker(policyId, trackerId, blockParams?): Promise<any>

Defined in: src/modules/rules-engine.ts:1060 Retrieves a tracker from the Rules Engine Component Contract based on the provided policy ID and tracker ID.

​

Parameters

​

Returns

Promise<any> A promise that resolves to the tracker result if successful, or null if an error occurs.

​

Throws

Will log an error to the console if the contract interaction fails.

---

​

getTrackerMetadata()

getTrackerMetadata(policyId, trackerId, blockParams?): Promise<Maybe<TrackerMetadataStruct>>

Defined in: src/modules/rules-engine.ts:1107 Retrieves the metadata for a tracker from the Rules Engine Component Contract based on the provided policy ID and tracker ID.

​

Parameters

​

Returns

Promise<Maybe<TrackerMetadataStruct>> A promise that resolves to the tracker metadata result if successful, or null if an error occurs.

​

Throws

Will log an error to the console if the contract interaction fails.

---

​

getTrackerToRuleIds()

getTrackerToRuleIds(policyId, trackerId, blockParams?): Promise<Maybe<number[]>>

Defined in: src/modules/rules-engine.ts:1125 Retrieves the rule IDs associated with a specific tracker from the Rules Engine Component Contract based on the provided policy ID and tracker ID.

​

Parameters

​

Returns

Promise<Maybe<number[]>> A promise that resolves to an array of rule IDs if successful, or an empty array if an error occurs.

​

Throws

Will log an error to the console if the contract interaction fails.

---

​

getVersionCompatible()

getVersionCompatible(): Promise<boolean>

Defined in: src/modules/rules-engine.ts:257

​

Returns

Promise<boolean>

---

​

isCallingContractAdmin()

isCallingContractAdmin(callingContract, account, blockParams?): Promise<boolean>

Defined in: src/modules/rules-engine.ts:1394 Determine if address is the calling contract admin. This function determines whether or not an address is the admin for a specific calling contract.

​

Parameters

​

Returns

Promise<boolean> whether or not the address is the calling contract admin.

---

​

isCementedPolicy()

isCementedPolicy(policyId, blockParams?): Promise<boolean>

Defined in: src/modules/rules-engine.ts:1512 Retrieves whether a policy is cemented.

​

Parameters

​

Returns

Promise<boolean> True if the policy is cemented, false otherwise

---

​

isClosedPolicy()

isClosedPolicy(policyId, blockParams?): Promise<boolean>

Defined in: src/modules/rules-engine.ts:406 Retrieves whether a policy is open or closed.

​

Parameters

​

Returns

Promise<boolean> True if the policy is closed, false otherwise

---

​

isClosedPolicySubscriber()

isClosedPolicySubscriber(policyId, subscriber, blockParams?): Promise<boolean>

Defined in: src/modules/rules-engine.ts:457 Retrieves whether an address is a possible subscriber to the closed policy.

​

Parameters

​

Returns

Promise<boolean> True if the address is a subscriber to the closed policy, false otherwise

---

​

isDisabledPolicy()

isDisabledPolicy(policyId, blockParams?): Promise<boolean>

Defined in: src/modules/rules-engine.ts:416 Retrieves whether a policy is disabled.

​

Parameters

​

Returns

Promise<boolean> True if the policy is disabled, false otherwise

---

​

isForeignCallAdmin()

isForeignCallAdmin(foreignCallAddress, account, foreignCallSelector, blockParams?): Promise<boolean>

Defined in: src/modules/rules-engine.ts:1480 Determine if address is the foreign call admin. This function determines whether or not an address is the admin for a specific foreign call.

​

Parameters

​

Returns

Promise<boolean> whether or not the address is the foreign call admin.

---

​

isPermissionedAdmin()

isPermissionedAdmin(foreignCallAddress, signature, adminAddress, blockParams?): Promise<boolean>

Defined in: src/modules/rules-engine.ts:905 Determines if a user is a permissioned admin for a specific policy ID.

​

Parameters

​

Returns

Promise<boolean> A promise that resolves to a boolean indicating if the user is a permissioned admin.

​

Throws

Will log an error to the console if the operation fails.

---

​

isPolicyAdmin()

isPolicyAdmin(policyId, adminAddress, blockParams?): Promise<boolean>

Defined in: src/modules/rules-engine.ts:1318 Determine if address is policy admin. This function determines whether or not an address is the admin for a specific policy.

​

Parameters

​

Returns

Promise<boolean> whether or not the address is the policy admin.

---

​

openPolicy()

openPolicy(policyId): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:436 Opens a policy on the Rules Engine.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

---

​

policyExists()

policyExists(policyId): Promise<boolean>

Defined in: src/modules/rules-engine.ts:267 Checks if a policy exists in the Rules Engine.

​

Parameters

​

Returns

Promise<boolean> True if the policy exists, false otherwise.

---

​

proposeCallingContractAdmin()

proposeCallingContractAdmin(callingContractAddress, newAdminAddress): void

Defined in: src/modules/rules-engine.ts:1333 Propose a new calling contract admin in the rules engine admin contract. This function proposes a new admin for a specific calling contract.

​

Parameters

​

Returns

void A promise that resolves to the result of the contract interaction, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

proposeForeignCallAdmin()

proposeForeignCallAdmin(foreignCallAddress, newAdminAddress, foreignCallSelector): void

Defined in: src/modules/rules-engine.ts:1414 Propose a new foreign call admin in the rules engine admin contract. This function proposes a new admin for a specific foreign call.

​

Parameters

​

Returns

void A promise.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

proposeNewPolicyAdmin()

proposeNewPolicyAdmin(policyId, newAdminAddress): void

Defined in: src/modules/rules-engine.ts:1262 Propose a new admin in the rules engine admin contract. This function proposes a new admin for a specific policy.

​

Parameters

​

Returns

void A promise that resolves to the result of the contract interaction, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

removeAllFromPermissionList()

removeAllFromPermissionList(foreignCallAddress, functionSelector): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:863 Removes all addresses from the permission list for a foreign call.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

​

Throws

Will log an error to the console if the operation fails.

---

​

removeClosedPolicySubscriber()

removeClosedPolicySubscriber(policyId, subscriber): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:494 Removes a subscriber from the closed policy.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

---

​

removeForeignCallPermissions()

removeForeignCallPermissions(foreignCallAddress, signature): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:953 Removes all permissions for a specific foreign call.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

​

Throws

Will retry indefinitely with a 1-second delay between attempts if an error occurs during the contract simulation. Ensure proper error handling or timeout mechanisms are implemented to avoid infinite loops.

---

​

removeFromPermissionList()

removeFromPermissionList(foreignCallAddress, signature, adminAddress): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:932 Removes admin from the permission list for a specific foreign call.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

​

Throws

Will retry indefinitely with a 1-second delay between attempts if an error occurs during the contract simulation. Ensure proper error handling or timeout mechanisms are implemented to avoid infinite loops.

---

​

removeMultipleAdminsFromPermissionList()

removeMultipleAdminsFromPermissionList(foreignCallAddress, functionSelector, policyAdminsToRemove): Promise<{ result: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:839 Removes multiple addresses from the permission list for a foreign call.

​

Parameters

​

Returns

Promise<{ result: number; transactionHash: `0x${string}`; }> Object with result (0 if successful, -1 if error) and transactionHash.

​

Throws

Will log an error to the console if the operation fails.

---

​

renounceCallingContractAdminRoleInternal()

renounceCallingContractAdminRoleInternal(renounceAddress, callingContractAddress): Promise<void>

Defined in: src/modules/rules-engine.ts:1373 Renounce a calling contract admin in the rules engine admin contract. This function renounces the admin role for a specific calling contract.

​

Parameters

​

Returns

Promise<void> A promise that resolves to the result of the contract interaction, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

renounceForeignCallAdmin()

renounceForeignCallAdmin(foreignCallAddress, functionSignature, renounceAddress): void

Defined in: src/modules/rules-engine.ts:1457 Renounce foreign call admin in the rules engine admin contract. This function confirms a new admin for a specific foreign call.

​

Parameters

​

Returns

void A promise.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

renouncePolicyAdminRole()

renouncePolicyAdminRole(role, renounceAddress, policyId): void

Defined in: src/modules/rules-engine.ts:1296 Renounce an admin role in the rules engine admin contract. This function confirms a new admin for a specific policy.

​

Parameters

​

Returns

void A promise that resolves to the result of the contract interaction, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

setPolicies()

setPolicies(policyIds, contractAddressForPolicy): void

Defined in: src/modules/rules-engine.ts:303 Sets the policies appled to a specific contract address.

​

Parameters

​

Returns

void

---

​

unsetPolicies()

unsetPolicies(policyIds, contractAddressForPolicy): void

Defined in: src/modules/rules-engine.ts:319 Unsets the policies appled to a specific contract address.

​

Parameters

​

Returns

void

---

​

updateCallingFunction()

updateCallingFunction(policyId, callingFunction, name, encodedValues): Promise<{ functionId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:1179 Updates a Calling Function in the rules engine component contract.

​

Parameters

​

Returns

Promise<{ functionId: number; transactionHash: `0x${string}`; }> A promise that resolves to object with functionId and transactionHash, or -1 if unsuccessful.

​

Throws

Will retry indefinitely on contract interaction failure, with a delay between attempts.

---

​

updateForeignCall()

updateForeignCall(policyId, foreignCallId, fcSyntax): Promise<{ foreignCallId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:671 Updates a foreign call in the rules engine component contract.

​

Parameters

​

Returns

Promise<{ foreignCallId: number; transactionHash: `0x${string}`; }> A promise that resolves to object with foreignCallId and transactionHash. Returns -1 if the operation fails.

​

Remarks

• The function retries the contract interaction in case of failure, with a delay of 1 second between attempts.
• The simulateContract function is used to simulate the contract interaction before writing to the blockchain.
• The writeContract function is used to execute the contract interaction on the blockchain.
• The function returns the foreignCallIndex for an updated foreign call or the result of the newly created foreign call.

​

Throws

Will throw an error if the JSON parsing of fcSyntax fails.

---

​

updateMappedTracker()

updateMappedTracker(policyId, mappedTrackerId, mappedTrackerSyntax): Promise<{ trackerId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:1002 Asynchronously updates a mapped tracker in the rules engine component contract.

​

Parameters

​

Returns

Promise<{ trackerId: number; transactionHash: `0x${string}`; }> Object with trackerId and transactionHash.

---

​

updatePolicy()

updatePolicy(policySyntax, policyId): Promise<{ callingFunctions: object[]; foreignCalls: object[]; policyId: number; rules: object[]; trackers: object[]; }>

Defined in: src/modules/rules-engine.ts:278 Updates an existing policy in the Rules Engine.

​

Parameters

​

Returns

Promise<{ callingFunctions: object[]; foreignCalls: object[]; policyId: number; rules: object[]; trackers: object[]; }> The ID of the updated policy and the transaction hashes of the updated components.

---

​

updateRule()

updateRule(policyId, ruleId, ruleS, foreignCallNameToID, trackerNameToID): Promise<{ ruleId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:548 Updates an existing rule in the Rules Engine Policy Contract.

​

Parameters

​

Returns

Promise<{ ruleId: number; transactionHash: `0x${string}`; }> A promise that resolves to object with ruleId and transactionHash. Returns the ruleId if successful, or -1 if the operation fails.

---

​

updateTracker()

updateTracker(policyId, trackerId, trSyntax): Promise<{ trackerId: number; transactionHash: `0x${string}`; }>

Defined in: src/modules/rules-engine.ts:1024 Asynchronously updates a tracker in the rules engine component contract.

​

Parameters

​

Returns

Promise<{ trackerId: number; transactionHash: `0x${string}`; }> A promise that resolves to object with trackerId and transactionHash. Returns -1 if the operation fails.

​

Throws

Will retry indefinitely with a 1-second delay between attempts if an error occurs during the contract simulation. Ensure proper error handling or timeout mechanisms are implemented to avoid infinite loops.

---

​

create()

static create(rulesEngineAddress, localConfig, client, localConfirmationCount): Promise<Maybe<RulesEngine>>

Defined in: src/modules/rules-engine.ts:209 Creates a Rules Engine instance using the private constructor if the supplied rules engine address is compatible.

​

Parameters

​

Returns

Promise<Maybe<RulesEngine>>