This page contains practical examples of using Gateway’s garbled circuits for privacy-preserving computations. For more examples and the complete source code, visit our GitHub repository.

​
Core Examples

​
1. Discount Eligibility Check

A simple example demonstrating threshold-based decision making:

use compute::prelude::*;

#[encrypted(execute)]
fn qualifies_for_discount(purchase_amount: u16) -> bool {
    let DISCOUNT_THRESHOLD = 80;
    purchase_amount >= DISCOUNT_THRESHOLD
}

This example shows:

  • Basic comparison operations
  • Constant value handling
  • Boolean return types

​
2. Loan Eligibility Assessment

A complex example showcasing multi-criteria decision making:

use compute::prelude::*;

#[encrypted(execute)]
fn check_loan_eligibility(credit_score: u16, income: u16, debt_ratio: u16) -> u8 {
    // Define eligibility levels
    let PRIME = 1;
    let SUBPRIME = 2;
    let HIGH_RISK = 3;
    let INELIGIBLE = 0;

    // Nested range checks with if-let expressions
    if let 750..=850 = credit_score {
        if let 50..=200 = income {
            if let 1..=30 = debt_ratio {
                PRIME
            } else {
                HIGH_RISK
            }
        } else {
            SUBPRIME
        }
    } else if let 650..=749 = credit_score {
        if let 35..=199 = income {
            if let 1..=40 = debt_ratio {
                SUBPRIME
            } else {
                HIGH_RISK
            }
        } else {
            HIGH_RISK
        }
    } else if let 300..=649 = credit_score {
        HIGH_RISK
    } else {
        INELIGIBLE
    }
}

This example demonstrates:

  • Complex conditional logic
  • Range-based pattern matching
  • Multiple input parameters
  • Categorical output encoding

​
3. Access Control System

An example showing role-based access control:

use compute::prelude::*;

#[encrypted(execute)]
fn access_control(role: u8) -> u8 {
    let SENSITIVE_DATA = 1;
    let PATIENT_NOTES = 2;

    let ADMIN_ROLE = 1;
    let DOCTOR_ROLE = 2;
    let NURSE_ROLE = 3;

    match role {
        ADMIN_ROLE => SENSITIVE_DATA,
        DOCTOR_ROLE => PATIENT_NOTES + SENSITIVE_DATA,
        NURSE_ROLE => PATIENT_NOTES,
        _ => 0
    }
}

This example illustrates:

  • Match expressions
  • Role-based authorization
  • Bitwise operations for permission flags

​
Key Patterns

​
Pattern 1: Range-Based Logic

if let 1..=100 = value {
    // Value is within acceptable range
    perform_operation(value)
} else {
    // Value is outside range
    handle_error()
}

​
Pattern 2: Multi-Level Decision Trees

match value {
    0 => BASE_LEVEL,
    1..=5 => INTERMEDIATE_LEVEL,
    6..10 => ADVANCED_LEVEL,
    _ => ERROR_LEVEL,
}

​
Pattern 3: Composite Conditions

if condition_a && condition_b {
    // Both conditions must be true
    POSITIVE_RESULT
} else {
    NEGATIVE_RESULT
}

​
Testing Examples

Each example can be tested using the provided main function:

fn main() {
    // Test case for loan eligibility
    let credit_score = 780_u16;
    let income = 75_u16;
    let debt_ratio = 25_u16;

    let eligibility = check_loan_eligibility(credit_score, income, debt_ratio);
    println!("Eligibility Level: {}", eligibility);
}

Remember that these examples are running in a secure, encrypted environment where all computations maintain data privacy throughout the execution.

​
Best Practices Demonstrated

​
1. Clear Constants

  • Define constants at the beginning of functions
  • Use descriptive names for better readability

​
2. Range Validation

  • Use if-let with ranges for input validation
  • Handle out-of-range cases explicitly

​
3. Error Handling

  • Always provide default/error cases
  • Use clear error codes or flags

​
4. Code Organization

  • Structured decision trees
  • Clear separation of logic levels

​
Additional Resources

You can find more examples in our GitHub repository. Each example includes detailed comments and test cases. The repository also contains additional utilities and helper functions.

Rust SDKOverview