Hàm Tích Hợp | 256 Blocks

Tài liệu tham khảo đầy đủ cho tất cả các hàm tích hợp có sẵn trong chính sách

Chỉ các hàm tích hợp sau được kích hoạt trong chính sách. Các hàm không được liệt kê ở đây bị vô hiệu hóa vì lý do bảo mật. Xem Hạn chế để biết chi tiết về các hàm bị vô hiệu hóa.

Hàm Chuỗi

Các hàm để thao tác và kiểm tra giá trị chuỗi. Thiết yếu để làm việc với địa chỉ, tên phương thức và các trường văn bản khác.

`contains`

Kiểm tra xem chuỗi có chứa chuỗi con không. Trả về true nếu tìm thấy, false nếu không.

Ví dụ

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

`startswith`

Kiểm tra xem chuỗi có bắt đầu bằng tiền tố không. Hữu ích để khớp các danh mục phương thức hoặc mẫu địa chỉ.

Ví dụ

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

`endswith`

Kiểm tra xem chuỗi có kết thúc bằng hậu tố không.

Ví dụ

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

`lower`

Chuyển đổi chuỗi sang chữ thường. Thiết yếu cho so sánh địa chỉ không phân biệt chữ hoa chữ thường vì địa chỉ có thể có chữ hoa chữ thường hỗn hợp.

Ví dụ

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

`upper`

Chuyển đổi chuỗi sang chữ hoa.

Ví dụ

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

`concat`

Nối một mảng chuỗi với dấu phân cách.

Ví dụ

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

`split`

Tách chuỗi thành mảng bằng dấu phân cách.

Ví dụ

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

`replace`

Thay thế tất cả các lần xuất hiện của chuỗi con bằng chuỗi khác.

Ví dụ

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

`substring`

Trích xuất một phần của chuỗi theo vị trí bắt đầu và độ dài.

Ví dụ

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

Định dạng chuỗi với trình giữ chỗ. Hữu ích để tạo giá trị động.

Placeholder	Type
`%s`	String
`%d`	Integer
`%f`	Float
`%v`	Any value

Ví dụ

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

`trim`

Xóa các ký tự được chỉ định từ cả hai đầu của chuỗi.

Ví dụ

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

`trim_space`

Xóa khoảng trắng từ cả hai đầu của chuỗi.

Ví dụ

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

`trim_prefix`

Xóa tiền tố khỏi chuỗi nếu có.

Ví dụ

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

`trim_suffix`

Xóa hậu tố khỏi chuỗi nếu có.

Ví dụ

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

`indexof`

Tìm chỉ số của lần xuất hiện đầu tiên của chuỗi con. Trả về -1 nếu không tìm thấy.

Ví dụ

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

Hàm Regex

Các hàm để khớp mẫu bằng biểu thức chính quy. Mạnh mẽ hơn các hàm chuỗi cho các mẫu phức tạp.

`regex.match`

Kiểm tra xem chuỗi có khớp với mẫu biểu thức chính quy không. Trả về true hoặc false.

Ví dụ

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

Thay thế tất cả các kết quả khớp của mẫu bằng chuỗi thay thế.

Ví dụ

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

`regex.split`

Tách chuỗi theo mẫu regex.

Ví dụ

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

`regex.find_n`

Tìm tối đa n kết quả khớp của mẫu trong chuỗi.

Ví dụ

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

Hàm Thời Gian

Các hàm để làm việc với thời gian. Tất cả các giá trị thời gian tính bằng nano giây kể từ Unix epoch.

`time.now_ns`

Lấy thời gian hiện tại tính bằng nano giây. Sử dụng điều này làm cơ sở cho các chính sách dựa trên thời gian.

Ví dụ

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

Trích xuất giờ, phút và giây từ dấu thời gian. Trả về [hour, minute, second].

Ví dụ

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

Lấy ngày trong tuần từ dấu thời gian. Trả về 0 (Chủ nhật) đến 6 (Thứ bảy).

Ví dụ

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

Trích xuất năm, tháng và ngày từ dấu thời gian. Trả về [year, month, day].

Ví dụ

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

`time.parse_rfc3339_ns`

Phân tích cú pháp chuỗi dấu thời gian định dạng RFC3339 thành nano giây.

Ví dụ

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

`time.add_date`

Thêm năm, tháng và ngày vào dấu thời gian.

Ví dụ

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

Tính sự khác biệt giữa hai dấu thời gian. Trả về [years, months, days, hours, minutes, seconds].

Ví dụ

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

Hàm Tổng Hợp

Các hàm để làm việc với tập hợp các giá trị.

`count`

Đếm số lượng phần tử trong mảng, tập hợp hoặc đối tượng.

Ví dụ

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

Tính tổng các số trong mảng.

Ví dụ

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

Tìm giá trị lớn nhất trong mảng.

Ví dụ

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

`min`

Tìm giá trị nhỏ nhất trong mảng.

Ví dụ

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

`sort`

Sắp xếp mảng theo thứ tự tăng dần.

Ví dụ

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

Tính tích của các số trong mảng.

Ví dụ

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

Hàm Kiểu

Các hàm để kiểm tra và làm việc với các kiểu dữ liệu. Hữu ích để xử lý các trường có thể null một cách an toàn.

`is_null`

Kiểm tra xem giá trị có phải là null không. Thiết yếu để xử lý các trường đầu vào tùy chọn.

Ví dụ

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

`is_number`

Kiểm tra xem giá trị có phải là số không.

Ví dụ

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

`is_string`

Kiểm tra xem giá trị có phải là chuỗi không.

Ví dụ

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

`is_array`

Kiểm tra xem giá trị có phải là mảng không.

Ví dụ

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

`is_boolean`

Kiểm tra xem giá trị có phải là boolean (true hoặc false) không.

Ví dụ

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

Kiểm tra xem giá trị có phải là tập hợp không.

Ví dụ

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

`is_object`

Kiểm tra xem giá trị có phải là đối tượng (bản đồ khóa-giá trị) không.

Ví dụ

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

Lấy tên kiểu của giá trị dưới dạng chuỗi.

Ví dụ

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

Hàm Số

Các hàm cho các phép toán số học.

`abs`

Lấy giá trị tuyệt đối của một số.

Ví dụ

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

`round`

Làm tròn số đến số nguyên gần nhất.

Ví dụ

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

`ceil`

Làm tròn số lên đến số nguyên tiếp theo.

Ví dụ

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

`floor`

Làm tròn số xuống đến số nguyên trước đó.

Ví dụ

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

`to_number`

Chuyển đổi chuỗi thành số. Hữu ích cho các giá trị chuỗi thập lục phân.

Ví dụ

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

`numbers.range`

Tạo mảng số từ đầu đến cuối (bao gồm).

Ví dụ

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

Hàm Đối Tượng

Các hàm để làm việc với đối tượng (bản đồ khóa-giá trị).

`object.get`

Lấy giá trị từ đối tượng một cách an toàn với giá trị mặc định nếu khóa không tồn tại.

Ví dụ

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

Lấy tất cả các khóa từ đối tượng dưới dạng mảng.

Ví dụ

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

`object.remove`

Tạo đối tượng mới với các khóa được chỉ định bị xóa.

Ví dụ

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

Hợp nhất hai đối tượng. Giá trị từ đối tượng thứ hai ghi đè lên đối tượng đầu tiên.

Ví dụ

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

Hàm Mảng

Các hàm cho thao tác mảng.

`array.concat`

Nối hai mảng thành một.

Ví dụ

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

`array.slice`

Trích xuất một phần của mảng theo chỉ số bắt đầu và kết thúc.

Ví dụ

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

Đảo ngược thứ tự các phần tử trong mảng.

Ví dụ

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

Hàm Tập Hợp

Các hàm cho các phép toán tập hợp.

`intersection`

Lấy các phần tử tồn tại trong cả hai tập hợp.

Ví dụ

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

`union`

Kết hợp hai tập hợp thành một với tất cả các phần tử duy nhất.

Ví dụ

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

Hàm Mã Hóa

Các hàm để mã hóa và giải mã dữ liệu.

`base64.encode`

Mã hóa chuỗi sang định dạng Base64.

Ví dụ

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

`base64.decode`

Giải mã chuỗi Base64 trở lại văn bản thuần túy.

Ví dụ

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

`base64url.encode`

Mã hóa chuỗi sang định dạng Base64 an toàn cho URL. Sử dụng - và _ thay vì + và /.

Ví dụ

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

`base64url.decode`

Giải mã chuỗi Base64 an toàn cho URL trở lại văn bản thuần túy.

Ví dụ

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

Mã hóa chuỗi sang định dạng thập lục phân.

Ví dụ

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

Giải mã chuỗi thập lục phân trở lại văn bản thuần túy.

Ví dụ

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