Fonctions Intégrées

Référence complète de toutes les fonctions intégrées disponibles dans les politiques

Seules les fonctions intégrées suivantes sont activées dans les politiques. Les fonctions non répertoriées ici sont désactivées pour des raisons de sécurité. Voir Restrictions pour plus de détails sur les fonctions désactivées.

Fonctions de Chaîne

Fonctions pour manipuler et inspecter les valeurs de chaîne. Essentielles pour travailler avec les adresses, les noms de méthodes et autres champs de texte.

contains

Vérifie si une chaîne contient une sous-chaîne. Renvoie true si trouvée, false sinon.

Exemple

# Block any method containing "sign"
deny if {
    contains(input.rpc_method, "sign")
}

startswith

Vérifie si une chaîne commence par un préfixe. Utile pour faire correspondre les catégories de méthodes ou les modèles d'adresse.

Exemple

# Block debug methods
deny if {
    startswith(input.rpc_method, "debug_")
}
 
# Block addresses starting with many zeros
deny if {
    startswith(input.to_address, "0x00000000")
}

endswith

Vérifie si une chaîne se termine par un suffixe.

Exemple

# Block addresses ending with specific pattern
deny if {
    endswith(lower(input.to_address), "dead")
}

lower

Convertit une chaîne en minuscules. Essentiel pour la comparaison d'adresses insensible à la casse car les adresses peuvent avoir une casse mixte.

Exemple

# Case-insensitive address check
blocked_addresses := {
    "0x000000000000000000000000000000000000dead"
}
 
deny if {
    lower(input.to_address) in blocked_addresses
}

upper

Convertit une chaîne en majuscules.

Exemple

# Normalize method names that might have inconsistent casing
deny if {
    upper(input.rpc_method) == "ETH_SENDTRANSACTION"
    input.usd_value > 10000
}

concat

Joint un tableau de chaînes avec un délimiteur.

Exemple

# Join values for logging or comparison
message := concat(", ", ["chain:", input.chain, "method:", input.rpc_method])

split

Divise une chaîne en un tableau en utilisant un délimiteur.

Exemple

# Parse a method name
parts := split(input.rpc_method, "_")
 
deny if {
    parts[0] == "debug"
}

replace

Remplace toutes les occurrences d'une sous-chaîne par une autre chaîne.

Exemple

# Normalize address format
normalized := replace(input.to_address, "0X", "0x")

substring

Extrait une portion d'une chaîne par position de départ et longueur.

Exemple

# Get method prefix (first 4 characters after "eth_")
deny if {
    startswith(input.rpc_method, "eth_")
    method_action := substring(input.rpc_method, 4, 4)
    method_action == "send"
}

sprintf

Formate une chaîne avec des espaces réservés. Utile pour créer des valeurs dynamiques.

PlaceholderType
%sString
%dInteger
%fFloat
%vAny value

Exemple

# Create formatted message
threshold := 10000
message := sprintf("Value %d exceeds limit of %d", [input.usd_value, threshold])

trim

Supprime les caractères spécifiés des deux extrémités d'une chaîne.

Exemple

# Remove specific characters from both ends
cleaned := trim(input.rpc_method, "_")

trim_space

Supprime les espaces des deux extrémités d'une chaîne.

Exemple

# Clean up input with extra spaces
clean_method := trim_space(input.rpc_method)

trim_prefix

Supprime un préfixe d'une chaîne s'il est présent.

Exemple

# Remove common prefix to get the action name
method_name := trim_prefix(input.rpc_method, "eth_")
 
deny if {
    method_name == "sendTransaction"
}

trim_suffix

Supprime un suffixe d'une chaîne s'il est présent.

Exemple

# Remove suffix for comparison
base_method := trim_suffix(input.rpc_method, "_v2")

indexof

Trouve l'index de la première occurrence d'une sous-chaîne. Renvoie -1 si non trouvée.

Exemple

# Check if underscore exists
deny if {
    indexof(input.rpc_method, "_") == -1
}

Fonctions Regex

Fonctions pour la correspondance de modèles utilisant des expressions régulières. Plus puissantes que les fonctions de chaîne pour les modèles complexes.

regex.match

Vérifie si une chaîne correspond à un modèle d'expression régulière. Renvoie true ou false.

Exemple

# Block methods starting with debug_, admin_, or personal_
deny if {
    regex.match("^(debug_|admin_|personal_)", input.rpc_method)
}
 
# Block addresses with many leading zeros
deny if {
    regex.match("^0x0{10,}", input.to_address)
}

regex.replace

Remplace toutes les correspondances d'un modèle par une chaîne de remplacement.

Exemple

# Remove all non-alphanumeric characters
cleaned := regex.replace(input.rpc_method, "[^a-zA-Z0-9]", "")

regex.split

Divise une chaîne par un modèle regex.

Exemple

# Split by multiple delimiters
parts := regex.split("[_.]", input.rpc_method)

regex.find_n

Trouve jusqu'à n correspondances d'un modèle dans une chaîne.

Exemple

# Find all hex sequences
hex_matches := regex.find_n("0x[a-fA-F0-9]+", input.raw_params[0].data, 10)
 
deny if {
    count(hex_matches) > 5
}

Fonctions de Temps

Fonctions pour travailler avec le temps. Toutes les valeurs de temps sont en nanosecondes depuis l'époque Unix.

time.now_ns

Obtient l'heure actuelle en nanosecondes. Utilisez ceci comme base pour les politiques basées sur le temps.

Exemple

# Block high-value transactions during volatile market hours
deny if {
    current := time.now_ns()
    [hour, _, _] := time.clock(current)
    hour >= 14  # After 2 PM UTC (US market open)
    hour < 21   # Before 9 PM UTC (US market close)
    input.usd_value > 50000
}

time.clock

Extrait l'heure, la minute et la seconde d'un horodatage. Renvoie [hour, minute, second].

Exemple

# Block outside business hours (9 AM - 5 PM UTC)
deny if {
    [hour, _, _] := time.clock(time.now_ns())
    hour < 9
}
 
deny if {
    [hour, _, _] := time.clock(time.now_ns())
    hour >= 17
}

time.weekday

Obtient le jour de la semaine à partir d'un horodatage. Renvoie 0 (dimanche) à 6 (samedi).

Exemple

# Block on weekends
deny if {
    day := time.weekday(time.now_ns())
    day == 0  # Sunday
}
 
deny if {
    day := time.weekday(time.now_ns())
    day == 6  # Saturday
}

time.date

Extrait l'année, le mois et le jour d'un horodatage. Renvoie [year, month, day].

Exemple

# Block on specific dates
deny if {
    [year, month, day] := time.date(time.now_ns())
    month == 12
    day == 25  # Christmas
}

time.parse_rfc3339_ns

Analyse une chaîne d'horodatage au format RFC3339 en nanosecondes.

Exemple

# Compare against a specific date
cutoff := time.parse_rfc3339_ns("2024-12-31T23:59:59Z")
 
deny if {
    time.now_ns() > cutoff
}

time.add_date

Ajoute des années, des mois et des jours à un horodatage.

Exemple

# Block transactions if we're within 7 days of year end
deny if {
    year_end := time.parse_rfc3339_ns("2024-12-31T23:59:59Z")
    week_before := time.add_date(year_end, 0, 0, -7)
    time.now_ns() > week_before
    input.usd_value > 10000
}

time.diff

Calcule la différence entre deux horodatages. Renvoie [years, months, days, hours, minutes, seconds].

Exemple

# Check if more than 1 hour has passed
start := time.parse_rfc3339_ns("2024-01-01T00:00:00Z")
[_, _, _, hours, _, _] := time.diff(time.now_ns(), start)
 
deny if {
    hours > 1
}

Fonctions d'Agrégation

Fonctions pour travailler avec des collections de valeurs.

count

Compte le nombre d'éléments dans un tableau, un ensemble ou un objet.

Exemple

# Limit number of contracts in a request
deny if {
    count(input.contract_addresses) > 5
}
 
# Ensure at least one address
deny if {
    count(input.contract_addresses) == 0
}

sum

Calcule la somme des nombres dans un tableau.

Exemple

# Block if total gas across params exceeds limit
deny if {
    gas_values := [to_number(p.gas) | some p in input.raw_params; p.gas != null]
    sum(gas_values) > 5000000
}

max

Trouve la valeur maximale dans un tableau.

Exemple

# Check against maximum in a set of thresholds
thresholds := [1000, 5000, 10000]
 
deny if {
    input.usd_value > max(thresholds)
}

min

Trouve la valeur minimale dans un tableau.

Exemple

# Ensure value meets minimum threshold
thresholds := [100, 500, 1000]
 
deny if {
    input.usd_value < min(thresholds)
}

sort

Trie un tableau par ordre croissant.

Exemple

# Check if smallest contract address looks suspicious (many leading zeros)
deny if {
    count(input.contract_addresses) > 0
    sorted_addrs := sort(input.contract_addresses)
    startswith(sorted_addrs[0], "0x00000000")
}

product

Calcule le produit des nombres dans un tableau.

Exemple

# Calculate combined risk score from multiple factors
deny if {
    risk_factors := [2, 3]  # High-value = 2x, Unknown sender = 3x
    combined_risk := product(risk_factors)
    combined_risk > 5
}

Fonctions de Type

Fonctions pour vérifier et travailler avec les types de données. Utiles pour gérer les champs nullables en toute sécurité.

is_null

Vérifie si une valeur est null. Essentiel pour gérer les champs d'entrée optionnels.

Exemple

# Safely check nullable field
deny if {
    not is_null(input.usd_value)
    input.usd_value > 10000
}

is_number

Vérifie si une valeur est un nombre.

Exemple

# Validate before numeric comparison
deny if {
    is_number(input.usd_value)
    input.usd_value > 10000
}

is_string

Vérifie si une valeur est une chaîne.

Exemple

# Validate input type
deny if {
    is_string(input.to_address)
    startswith(input.to_address, "0x0000")
}

is_array

Vérifie si une valeur est un tableau.

Exemple

# Check before iterating
deny if {
    is_array(input.contract_addresses)
    count(input.contract_addresses) > 10
}

is_boolean

Vérifie si une valeur est un booléen (true ou false).

Exemple

# Verify a flag is actually a boolean before using it
deny if {
    is_boolean(input.raw_params[0].enabled)
    input.raw_params[0].enabled == false
}

is_set

Vérifie si une valeur est un ensemble.

Exemple

# Validate collection type
deny if {
    is_set(input.raw_params[0].addresses)
    count(input.raw_params[0].addresses) > 100
}

is_object

Vérifie si une valeur est un objet (carte clé-valeur).

Exemple

# Ensure params is an object before accessing fields
deny if {
    is_object(input.raw_params[0])
    object.get(input.raw_params[0], "dangerous", false) == true
}

type_name

Obtient le nom du type d'une valeur sous forme de chaîne.

Exemple

# Block if usd_value is not a number (unexpected type)
deny if {
    input.usd_value != null
    type_name(input.usd_value) != "number"
}

Fonctions Numériques

Fonctions pour les opérations numériques.

abs

Obtient la valeur absolue d'un nombre.

Exemple

# Check magnitude regardless of sign
deny if {
    abs(input.usd_value) > 10000
}

round

Arrondit un nombre à l'entier le plus proche.

Exemple

# Round for comparison
deny if {
    round(input.usd_value) > 10000
}

ceil

Arrondit un nombre vers le haut à l'entier suivant.

Exemple

# Round up for conservative limit checking
deny if {
    ceil(input.usd_value) > 10000
}

floor

Arrondit un nombre vers le bas à l'entier précédent.

Exemple

# Block transactions over $10,000 (ignoring cents)
deny if {
    floor(input.usd_value) >= 10000
}

to_number

Convertit une chaîne en nombre. Utile pour les valeurs de chaîne hexadécimale.

Exemple

# Convert hex gas values
deny if {
    input.gas_limit != null
    to_number(input.gas_limit) > 1000000
}

numbers.range

Génère un tableau de nombres du début à la fin (inclus).

Exemple

# Allow transactions only during business hours (9 AM - 5 PM)
deny if {
    [hour, _, _] := time.clock(time.now_ns())
    business_hours := numbers.range(9, 17)
    not hour in business_hours
}

Fonctions d'Objet

Fonctions pour travailler avec des objets (cartes clé-valeur).

object.get

Obtient en toute sécurité une valeur d'un objet avec une valeur par défaut si la clé n'existe pas.

Exemple

# Safely access nested data
deny if {
    params := input.raw_params[0]
    data := object.get(params, "data", "0x")
    startswith(data, "0xa9059cbb")  # ERC-20 transfer
}

object.keys

Obtient toutes les clés d'un objet sous forme de tableau.

Exemple

# Check which fields are present
params := input.raw_params[0]
keys := object.keys(params)
 
deny if {
    "data" in keys
    "value" in keys
}

object.remove

Crée un nouvel objet avec les clés spécifiées supprimées.

Exemple

# Block if params contain unexpected fields after removing known safe ones
deny if {
    safe_fields := ["to", "from", "value", "gas", "data"]
    remaining := object.remove(input.raw_params[0], safe_fields)
    count(object.keys(remaining)) > 0
}

object.union

Fusionne deux objets. Les valeurs du deuxième objet écrasent le premier.

Exemple

# Apply safe defaults and check resulting gas limit
deny if {
    defaults := {"gas": "0x5208"}
    params := object.union(defaults, input.raw_params[0])
    to_number(params.gas) > 1000000
}

Fonctions de Tableau

Fonctions pour la manipulation de tableaux.

array.concat

Concatène deux tableaux en un seul.

Exemple

# Combine address lists
all_addresses := array.concat(
    input.contract_addresses,
    [input.to_address]
)

array.slice

Extrait une portion d'un tableau par index de début et de fin.

Exemple

# Only check first 5 contract addresses for blocked list
deny if {
    first_five := array.slice(input.contract_addresses, 0, 5)
    some addr in first_five
    addr in {"0xbanned1...", "0xbanned2..."}
}

array.reverse

Inverse l'ordre des éléments dans un tableau.

Exemple

# Check last contract address (most recent) for suspicious patterns
deny if {
    count(input.contract_addresses) > 0
    reversed := array.reverse(input.contract_addresses)
    startswith(reversed[0], "0x00000000")
}

Fonctions d'Ensemble

Fonctions pour les opérations sur les ensembles.

intersection

Obtient les éléments qui existent dans les deux ensembles.

Exemple

# Check for any blocked address
blocked := {"0xdead...", "0xbad..."}
request_addrs := {lower(input.to_address)}
 
deny if {
    count(intersection(blocked, request_addrs)) > 0
}

union

Combine deux ensembles en un avec tous les éléments uniques.

Exemple

# Combine multiple blocklists
blocked_countries := union(
    {"KP", "IR", "CU"},
    {"SY", "RU"}
)
 
deny if {
    input.source_country in blocked_countries
}

Fonctions de Codage

Fonctions pour encoder et décoder des données.

base64.encode

Encode une chaîne au format Base64.

Exemple

# Check if method matches an encoded pattern
deny if {
    encoded_method := base64.encode(input.rpc_method)
    encoded_method == "ZXRoX3NlbmRUcmFuc2FjdGlvbg=="  # eth_sendTransaction
}

base64.decode

Décode une chaîne Base64 en texte brut.

Exemple

# Decode base64 data from request
decoded := base64.decode("aGVsbG8=")  # "hello"
 
deny if {
    contains(decoded, "dangerous")
}

base64url.encode

Encode une chaîne au format Base64 sécurisé pour les URL. Utilise - et _ au lieu de + et /.

Exemple

# Create URL-safe identifier from address for comparison
deny if {
    encoded_addr := base64url.encode(input.to_address)
    encoded_addr in {"MHhkZWFk...", "MHhiYWQ..."}
}

base64url.decode

Décode une chaîne Base64 sécurisée pour les URL en texte brut.

Exemple

# Decode and check URL-safe encoded data in params
deny if {
    encoded_data := object.get(input.raw_params[0], "encoded", "")
    decoded := base64url.decode(encoded_data)
    contains(decoded, "malicious")
}

hex.encode

Encode une chaîne au format hexadécimal.

Exemple

# Encode method name to hex for pattern matching
deny if {
    method_hex := hex.encode(input.rpc_method)
    startswith(method_hex, "657468")  # "eth" in hex
}

hex.decode

Décode une chaîne hexadécimale en texte brut.

Exemple

# Decode hex-encoded data field and check contents
deny if {
    data := object.get(input.raw_params[0], "data", "")
    startswith(data, "0x")
    decoded := hex.decode(substring(data, 2, 8))
    contains(decoded, "admin")
}
Fonctions Intégrées | 256 Blocks