Funções Integradas

Referência completa de todas as funções integradas disponíveis em políticas

Apenas as seguintes funções integradas estão habilitadas nas políticas. Funções não listadas aqui estão desabilitadas por motivos de segurança. Consulte Restrições para detalhes sobre funções desabilitadas.

Funções de String

Funções para manipular e inspecionar valores de string. Essenciais para trabalhar com endereços, nomes de métodos e outros campos de texto.

contains

Verifica se uma string contém uma substring. Retorna true se encontrado, false caso contrário.

Exemplo

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

startswith

Verifica se uma string começa com um prefixo. Útil para combinar categorias de métodos ou padrões de endereço.

Exemplo

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

endswith

Verifica se uma string termina com um sufixo.

Exemplo

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

lower

Converte uma string para minúsculas. Essencial para comparação de endereços sem distinção entre maiúsculas e minúsculas, já que os endereços podem ter maiúsculas e minúsculas mistas.

Exemplo

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

upper

Converte uma string para maiúsculas.

Exemplo

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

concat

Une um array de strings com um delimitador.

Exemplo

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

split

Divide uma string em um array usando um delimitador.

Exemplo

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

replace

Substitui todas as ocorrências de uma substring por outra string.

Exemplo

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

substring

Extrai uma porção de uma string por posição inicial e comprimento.

Exemplo

# 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

Formata uma string com marcadores de posição. Útil para criar valores dinâmicos.

PlaceholderType
%sString
%dInteger
%fFloat
%vAny value

Exemplo

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

trim

Remove caracteres especificados de ambas as extremidades de uma string.

Exemplo

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

trim_space

Remove espaços em branco de ambas as extremidades de uma string.

Exemplo

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

trim_prefix

Remove um prefixo de uma string se presente.

Exemplo

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

trim_suffix

Remove um sufixo de uma string se presente.

Exemplo

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

indexof

Encontra o índice da primeira ocorrência de uma substring. Retorna -1 se não encontrado.

Exemplo

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

Funções de Regex

Funções para correspondência de padrões usando expressões regulares. Mais poderosas que funções de string para padrões complexos.

regex.match

Verifica se uma string corresponde a um padrão de expressão regular. Retorna true ou false.

Exemplo

# 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

Substitui todas as correspondências de um padrão por uma string de substituição.

Exemplo

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

regex.split

Divide uma string por um padrão regex.

Exemplo

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

regex.find_n

Encontra até n correspondências de um padrão em uma string.

Exemplo

# 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
}

Funções de Tempo

Funções para trabalhar com tempo. Todos os valores de tempo estão em nanossegundos desde a época Unix.

time.now_ns

Obtém o tempo atual em nanossegundos. Use isso como base para políticas baseadas em tempo.

Exemplo

# 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

Extrai hora, minuto e segundo de um timestamp. Retorna [hour, minute, second].

Exemplo

# 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

Obtém o dia da semana de um timestamp. Retorna 0 (domingo) até 6 (sábado).

Exemplo

# 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

Extrai ano, mês e dia de um timestamp. Retorna [year, month, day].

Exemplo

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

time.parse_rfc3339_ns

Analisa uma string de timestamp formatada em RFC3339 em nanossegundos.

Exemplo

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

time.add_date

Adiciona anos, meses e dias a um timestamp.

Exemplo

# 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

Calcula a diferença entre dois timestamps. Retorna [years, months, days, hours, minutes, seconds].

Exemplo

# 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
}

Funções de Agregação

Funções para trabalhar com coleções de valores.

count

Conta o número de elementos em um array, conjunto ou objeto.

Exemplo

# 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

Calcula a soma de números em um array.

Exemplo

# 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

Encontra o valor máximo em um array.

Exemplo

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

min

Encontra o valor mínimo em um array.

Exemplo

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

sort

Ordena um array em ordem crescente.

Exemplo

# 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

Calcula o produto de números em um array.

Exemplo

# 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
}

Funções de Tipo

Funções para verificar e trabalhar com tipos de dados. Úteis para lidar com campos anuláveis com segurança.

is_null

Verifica se um valor é null. Essencial para lidar com campos de entrada opcionais.

Exemplo

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

is_number

Verifica se um valor é um número.

Exemplo

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

is_string

Verifica se um valor é uma string.

Exemplo

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

is_array

Verifica se um valor é um array.

Exemplo

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

is_boolean

Verifica se um valor é um booleano (true ou false).

Exemplo

# 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

Verifica se um valor é um conjunto.

Exemplo

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

is_object

Verifica se um valor é um objeto (mapa chave-valor).

Exemplo

# 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

Obtém o nome do tipo de um valor como uma string.

Exemplo

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

Funções Numéricas

Funções para operações numéricas.

abs

Obtém o valor absoluto de um número.

Exemplo

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

round

Arredonda um número para o inteiro mais próximo.

Exemplo

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

ceil

Arredonda um número para cima até o próximo inteiro.

Exemplo

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

floor

Arredonda um número para baixo até o inteiro anterior.

Exemplo

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

to_number

Converte uma string em um número. Útil para valores de string hexadecimal.

Exemplo

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

numbers.range

Gera um array de números do início ao fim (inclusivo).

Exemplo

# 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
}

Funções de Objeto

Funções para trabalhar com objetos (mapas chave-valor).

object.get

Obtém com segurança um valor de um objeto com um padrão se a chave não existir.

Exemplo

# 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

Obtém todas as chaves de um objeto como um array.

Exemplo

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

object.remove

Cria um novo objeto com as chaves especificadas removidas.

Exemplo

# 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

Mescla dois objetos. Os valores do segundo objeto sobrescrevem o primeiro.

Exemplo

# 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
}

Funções de Array

Funções para manipulação de arrays.

array.concat

Concatena dois arrays em um.

Exemplo

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

array.slice

Extrai uma porção de um array por índice inicial e final.

Exemplo

# 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

Inverte a ordem dos elementos em um array.

Exemplo

# 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")
}

Funções de Conjunto

Funções para operações de conjunto.

intersection

Obtém elementos que existem em ambos os conjuntos.

Exemplo

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

union

Combina dois conjuntos em um com todos os elementos únicos.

Exemplo

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

Funções de Codificação

Funções para codificar e decodificar dados.

base64.encode

Codifica uma string para o formato Base64.

Exemplo

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

base64.decode

Decodifica uma string Base64 de volta para texto simples.

Exemplo

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

base64url.encode

Codifica uma string para o formato Base64 seguro para URL. Usa - e _ em vez de + e /.

Exemplo

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

base64url.decode

Decodifica uma string Base64 segura para URL de volta para texto simples.

Exemplo

# 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

Codifica uma string para o formato hexadecimal.

Exemplo

# 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

Decodifica uma string hexadecimal de volta para texto simples.

Exemplo

# 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")
}
Funções Integradas | 256 Blocks