Evaluate Policy

Evaluate Policy

curl --request POST \
  --url https://api-mainnet.onzks.com/v1/trust/evaluate \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "policy": {
    "policy.id": "<string>",
    "policy.name": "<string>",
    "policy.description": "<string>",
    "policy.requirements": [
      {
        "policy.requirements[].type": "<string>",
        "policy.requirements[].operator": "<string>",
        "policy.requirements[].value": "<any>",
        "policy.requirements[].weight": 123,
        "policy.requirements[].required": true
      }
    ],
    "policy.conditions": [
      {
        "policy.conditions[].type": "<string>",
        "policy.conditions[].requirements": [
          {}
        ]
      }
    ],
    "policy.threshold": 123,
    "policy.expiry": "<string>"
  },
  "subject": "<string>",
  "context": {
    "context.service": "<string>",
    "context.action": "<string>",
    "context.metadata": {}
  },
  "options": {
    "options.includeDetails": true,
    "options.includeAttestations": true,
    "options.includeScore": true,
    "options.strictMode": true
  }
}
'

import requests

url = "https://api-mainnet.onzks.com/v1/trust/evaluate"

payload = {
    "policy": {
        "policy.id": "<string>",
        "policy.name": "<string>",
        "policy.description": "<string>",
        "policy.requirements": [
            {
                "policy.requirements[].type": "<string>",
                "policy.requirements[].operator": "<string>",
                "policy.requirements[].value": "<any>",
                "policy.requirements[].weight": 123,
                "policy.requirements[].required": True
            }
        ],
        "policy.conditions": [
            {
                "policy.conditions[].type": "<string>",
                "policy.conditions[].requirements": [{}]
            }
        ],
        "policy.threshold": 123,
        "policy.expiry": "<string>"
    },
    "subject": "<string>",
    "context": {
        "context.service": "<string>",
        "context.action": "<string>",
        "context.metadata": {}
    },
    "options": {
        "options.includeDetails": True,
        "options.includeAttestations": True,
        "options.includeScore": True,
        "options.strictMode": True
    }
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    policy: {
      'policy.id': '<string>',
      'policy.name': '<string>',
      'policy.description': '<string>',
      'policy.requirements': [
        {
          'policy.requirements[].type': '<string>',
          'policy.requirements[].operator': '<string>',
          'policy.requirements[].value': '<any>',
          'policy.requirements[].weight': 123,
          'policy.requirements[].required': true
        }
      ],
      'policy.conditions': [
        {
          'policy.conditions[].type': '<string>',
          'policy.conditions[].requirements': [{}]
        }
      ],
      'policy.threshold': 123,
      'policy.expiry': '<string>'
    },
    subject: '<string>',
    context: {
      'context.service': '<string>',
      'context.action': '<string>',
      'context.metadata': {}
    },
    options: {
      'options.includeDetails': true,
      'options.includeAttestations': true,
      'options.includeScore': true,
      'options.strictMode': true
    }
  })
};

fetch('https://api-mainnet.onzks.com/v1/trust/evaluate', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api-mainnet.onzks.com/v1/trust/evaluate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'policy' => [
        'policy.id' => '<string>',
        'policy.name' => '<string>',
        'policy.description' => '<string>',
        'policy.requirements' => [
                [
                                'policy.requirements[].type' => '<string>',
                                'policy.requirements[].operator' => '<string>',
                                'policy.requirements[].value' => '<any>',
                                'policy.requirements[].weight' => 123,
                                'policy.requirements[].required' => true
                ]
        ],
        'policy.conditions' => [
                [
                                'policy.conditions[].type' => '<string>',
                                'policy.conditions[].requirements' => [
                                                                [
                                                                                                                                
                                                                ]
                                ]
                ]
        ],
        'policy.threshold' => 123,
        'policy.expiry' => '<string>'
    ],
    'subject' => '<string>',
    'context' => [
        'context.service' => '<string>',
        'context.action' => '<string>',
        'context.metadata' => [
                
        ]
    ],
    'options' => [
        'options.includeDetails' => true,
        'options.includeAttestations' => true,
        'options.includeScore' => true,
        'options.strictMode' => true
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api-mainnet.onzks.com/v1/trust/evaluate"

	payload := strings.NewReader("{\n  \"policy\": {\n    \"policy.id\": \"<string>\",\n    \"policy.name\": \"<string>\",\n    \"policy.description\": \"<string>\",\n    \"policy.requirements\": [\n      {\n        \"policy.requirements[].type\": \"<string>\",\n        \"policy.requirements[].operator\": \"<string>\",\n        \"policy.requirements[].value\": \"<any>\",\n        \"policy.requirements[].weight\": 123,\n        \"policy.requirements[].required\": true\n      }\n    ],\n    \"policy.conditions\": [\n      {\n        \"policy.conditions[].type\": \"<string>\",\n        \"policy.conditions[].requirements\": [\n          {}\n        ]\n      }\n    ],\n    \"policy.threshold\": 123,\n    \"policy.expiry\": \"<string>\"\n  },\n  \"subject\": \"<string>\",\n  \"context\": {\n    \"context.service\": \"<string>\",\n    \"context.action\": \"<string>\",\n    \"context.metadata\": {}\n  },\n  \"options\": {\n    \"options.includeDetails\": true,\n    \"options.includeAttestations\": true,\n    \"options.includeScore\": true,\n    \"options.strictMode\": true\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api-mainnet.onzks.com/v1/trust/evaluate")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"policy\": {\n    \"policy.id\": \"<string>\",\n    \"policy.name\": \"<string>\",\n    \"policy.description\": \"<string>\",\n    \"policy.requirements\": [\n      {\n        \"policy.requirements[].type\": \"<string>\",\n        \"policy.requirements[].operator\": \"<string>\",\n        \"policy.requirements[].value\": \"<any>\",\n        \"policy.requirements[].weight\": 123,\n        \"policy.requirements[].required\": true\n      }\n    ],\n    \"policy.conditions\": [\n      {\n        \"policy.conditions[].type\": \"<string>\",\n        \"policy.conditions[].requirements\": [\n          {}\n        ]\n      }\n    ],\n    \"policy.threshold\": 123,\n    \"policy.expiry\": \"<string>\"\n  },\n  \"subject\": \"<string>\",\n  \"context\": {\n    \"context.service\": \"<string>\",\n    \"context.action\": \"<string>\",\n    \"context.metadata\": {}\n  },\n  \"options\": {\n    \"options.includeDetails\": true,\n    \"options.includeAttestations\": true,\n    \"options.includeScore\": true,\n    \"options.strictMode\": true\n  }\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api-mainnet.onzks.com/v1/trust/evaluate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"policy\": {\n    \"policy.id\": \"<string>\",\n    \"policy.name\": \"<string>\",\n    \"policy.description\": \"<string>\",\n    \"policy.requirements\": [\n      {\n        \"policy.requirements[].type\": \"<string>\",\n        \"policy.requirements[].operator\": \"<string>\",\n        \"policy.requirements[].value\": \"<any>\",\n        \"policy.requirements[].weight\": 123,\n        \"policy.requirements[].required\": true\n      }\n    ],\n    \"policy.conditions\": [\n      {\n        \"policy.conditions[].type\": \"<string>\",\n        \"policy.conditions[].requirements\": [\n          {}\n        ]\n      }\n    ],\n    \"policy.threshold\": 123,\n    \"policy.expiry\": \"<string>\"\n  },\n  \"subject\": \"<string>\",\n  \"context\": {\n    \"context.service\": \"<string>\",\n    \"context.action\": \"<string>\",\n    \"context.metadata\": {}\n  },\n  \"options\": {\n    \"options.includeDetails\": true,\n    \"options.includeAttestations\": true,\n    \"options.includeScore\": true,\n    \"options.strictMode\": true\n  }\n}"

response = http.request(request)
puts response.read_body

{
  "success": true,
  "passed": true,
  "score": 123,
  "threshold": 123,
  "subject": "<string>",
  "policy": {
    "id": "<string>",
    "name": "<string>",
    "description": "<string>"
  },
  "requirements": [
    {
      "type": "<string>",
      "passed": true,
      "score": 123,
      "weight": 123,
      "required": true,
      "details": {}
    }
  ],
  "attestations": [
    {
      "id": "<string>",
      "schema": "<string>",
      "trustScore": 123,
      "relevance": 123
    }
  ],
  "breakdown": {
    "trustScore": 123,
    "attestationScore": 123,
    "skillScore": 123,
    "relationshipScore": 123,
    "achievementScore": 123
  },
  "recommendations": [
    {
      "type": "<string>",
      "description": "<string>",
      "impact": 123,
      "priority": "<string>"
    }
  ],
  "timestamp": "<string>"
}

POST

trust

evaluate

Evaluate Policy

curl --request POST \
  --url https://api-mainnet.onzks.com/v1/trust/evaluate \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "policy": {
    "policy.id": "<string>",
    "policy.name": "<string>",
    "policy.description": "<string>",
    "policy.requirements": [
      {
        "policy.requirements[].type": "<string>",
        "policy.requirements[].operator": "<string>",
        "policy.requirements[].value": "<any>",
        "policy.requirements[].weight": 123,
        "policy.requirements[].required": true
      }
    ],
    "policy.conditions": [
      {
        "policy.conditions[].type": "<string>",
        "policy.conditions[].requirements": [
          {}
        ]
      }
    ],
    "policy.threshold": 123,
    "policy.expiry": "<string>"
  },
  "subject": "<string>",
  "context": {
    "context.service": "<string>",
    "context.action": "<string>",
    "context.metadata": {}
  },
  "options": {
    "options.includeDetails": true,
    "options.includeAttestations": true,
    "options.includeScore": true,
    "options.strictMode": true
  }
}
'

import requests

url = "https://api-mainnet.onzks.com/v1/trust/evaluate"

payload = {
    "policy": {
        "policy.id": "<string>",
        "policy.name": "<string>",
        "policy.description": "<string>",
        "policy.requirements": [
            {
                "policy.requirements[].type": "<string>",
                "policy.requirements[].operator": "<string>",
                "policy.requirements[].value": "<any>",
                "policy.requirements[].weight": 123,
                "policy.requirements[].required": True
            }
        ],
        "policy.conditions": [
            {
                "policy.conditions[].type": "<string>",
                "policy.conditions[].requirements": [{}]
            }
        ],
        "policy.threshold": 123,
        "policy.expiry": "<string>"
    },
    "subject": "<string>",
    "context": {
        "context.service": "<string>",
        "context.action": "<string>",
        "context.metadata": {}
    },
    "options": {
        "options.includeDetails": True,
        "options.includeAttestations": True,
        "options.includeScore": True,
        "options.strictMode": True
    }
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    policy: {
      'policy.id': '<string>',
      'policy.name': '<string>',
      'policy.description': '<string>',
      'policy.requirements': [
        {
          'policy.requirements[].type': '<string>',
          'policy.requirements[].operator': '<string>',
          'policy.requirements[].value': '<any>',
          'policy.requirements[].weight': 123,
          'policy.requirements[].required': true
        }
      ],
      'policy.conditions': [
        {
          'policy.conditions[].type': '<string>',
          'policy.conditions[].requirements': [{}]
        }
      ],
      'policy.threshold': 123,
      'policy.expiry': '<string>'
    },
    subject: '<string>',
    context: {
      'context.service': '<string>',
      'context.action': '<string>',
      'context.metadata': {}
    },
    options: {
      'options.includeDetails': true,
      'options.includeAttestations': true,
      'options.includeScore': true,
      'options.strictMode': true
    }
  })
};

fetch('https://api-mainnet.onzks.com/v1/trust/evaluate', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api-mainnet.onzks.com/v1/trust/evaluate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'policy' => [
        'policy.id' => '<string>',
        'policy.name' => '<string>',
        'policy.description' => '<string>',
        'policy.requirements' => [
                [
                                'policy.requirements[].type' => '<string>',
                                'policy.requirements[].operator' => '<string>',
                                'policy.requirements[].value' => '<any>',
                                'policy.requirements[].weight' => 123,
                                'policy.requirements[].required' => true
                ]
        ],
        'policy.conditions' => [
                [
                                'policy.conditions[].type' => '<string>',
                                'policy.conditions[].requirements' => [
                                                                [
                                                                                                                                
                                                                ]
                                ]
                ]
        ],
        'policy.threshold' => 123,
        'policy.expiry' => '<string>'
    ],
    'subject' => '<string>',
    'context' => [
        'context.service' => '<string>',
        'context.action' => '<string>',
        'context.metadata' => [
                
        ]
    ],
    'options' => [
        'options.includeDetails' => true,
        'options.includeAttestations' => true,
        'options.includeScore' => true,
        'options.strictMode' => true
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api-mainnet.onzks.com/v1/trust/evaluate"

	payload := strings.NewReader("{\n  \"policy\": {\n    \"policy.id\": \"<string>\",\n    \"policy.name\": \"<string>\",\n    \"policy.description\": \"<string>\",\n    \"policy.requirements\": [\n      {\n        \"policy.requirements[].type\": \"<string>\",\n        \"policy.requirements[].operator\": \"<string>\",\n        \"policy.requirements[].value\": \"<any>\",\n        \"policy.requirements[].weight\": 123,\n        \"policy.requirements[].required\": true\n      }\n    ],\n    \"policy.conditions\": [\n      {\n        \"policy.conditions[].type\": \"<string>\",\n        \"policy.conditions[].requirements\": [\n          {}\n        ]\n      }\n    ],\n    \"policy.threshold\": 123,\n    \"policy.expiry\": \"<string>\"\n  },\n  \"subject\": \"<string>\",\n  \"context\": {\n    \"context.service\": \"<string>\",\n    \"context.action\": \"<string>\",\n    \"context.metadata\": {}\n  },\n  \"options\": {\n    \"options.includeDetails\": true,\n    \"options.includeAttestations\": true,\n    \"options.includeScore\": true,\n    \"options.strictMode\": true\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api-mainnet.onzks.com/v1/trust/evaluate")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"policy\": {\n    \"policy.id\": \"<string>\",\n    \"policy.name\": \"<string>\",\n    \"policy.description\": \"<string>\",\n    \"policy.requirements\": [\n      {\n        \"policy.requirements[].type\": \"<string>\",\n        \"policy.requirements[].operator\": \"<string>\",\n        \"policy.requirements[].value\": \"<any>\",\n        \"policy.requirements[].weight\": 123,\n        \"policy.requirements[].required\": true\n      }\n    ],\n    \"policy.conditions\": [\n      {\n        \"policy.conditions[].type\": \"<string>\",\n        \"policy.conditions[].requirements\": [\n          {}\n        ]\n      }\n    ],\n    \"policy.threshold\": 123,\n    \"policy.expiry\": \"<string>\"\n  },\n  \"subject\": \"<string>\",\n  \"context\": {\n    \"context.service\": \"<string>\",\n    \"context.action\": \"<string>\",\n    \"context.metadata\": {}\n  },\n  \"options\": {\n    \"options.includeDetails\": true,\n    \"options.includeAttestations\": true,\n    \"options.includeScore\": true,\n    \"options.strictMode\": true\n  }\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api-mainnet.onzks.com/v1/trust/evaluate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"policy\": {\n    \"policy.id\": \"<string>\",\n    \"policy.name\": \"<string>\",\n    \"policy.description\": \"<string>\",\n    \"policy.requirements\": [\n      {\n        \"policy.requirements[].type\": \"<string>\",\n        \"policy.requirements[].operator\": \"<string>\",\n        \"policy.requirements[].value\": \"<any>\",\n        \"policy.requirements[].weight\": 123,\n        \"policy.requirements[].required\": true\n      }\n    ],\n    \"policy.conditions\": [\n      {\n        \"policy.conditions[].type\": \"<string>\",\n        \"policy.conditions[].requirements\": [\n          {}\n        ]\n      }\n    ],\n    \"policy.threshold\": 123,\n    \"policy.expiry\": \"<string>\"\n  },\n  \"subject\": \"<string>\",\n  \"context\": {\n    \"context.service\": \"<string>\",\n    \"context.action\": \"<string>\",\n    \"context.metadata\": {}\n  },\n  \"options\": {\n    \"options.includeDetails\": true,\n    \"options.includeAttestations\": true,\n    \"options.includeScore\": true,\n    \"options.strictMode\": true\n  }\n}"

response = http.request(request)
puts response.read_body

{
  "success": true,
  "passed": true,
  "score": 123,
  "threshold": 123,
  "subject": "<string>",
  "policy": {
    "id": "<string>",
    "name": "<string>",
    "description": "<string>"
  },
  "requirements": [
    {
      "type": "<string>",
      "passed": true,
      "score": 123,
      "weight": 123,
      "required": true,
      "details": {}
    }
  ],
  "attestations": [
    {
      "id": "<string>",
      "schema": "<string>",
      "trustScore": 123,
      "relevance": 123
    }
  ],
  "breakdown": {
    "trustScore": 123,
    "attestationScore": 123,
    "skillScore": 123,
    "relationshipScore": 123,
    "achievementScore": 123
  },
  "recommendations": [
    {
      "type": "<string>",
      "description": "<string>",
      "impact": 123,
      "priority": "<string>"
    }
  ],
  "timestamp": "<string>"
}

Overview

Evaluate trust policies to determine if a subject meets specific trust requirements. This endpoint allows you to check compliance with trust-based access control, verify credentials, and assess eligibility for services based on trust scores and attestations.

Use this endpoint to implement trust-based access control, verify user credentials, and assess eligibility for services based on trust requirements.

Parameters

object

required

Trust policy to evaluate

Show policy properties

string

Unique policy identifier

string

Policy name

string

Policy description

array

Policy requirements

Show requirement properties

string

Requirement type (trustScore, attestation, skill, relationship, etc.)

string

Comparison operator (gte, lte, eq, in, contains, etc.)

any

Requirement value

number

Requirement weight (0-1)

boolean

Whether requirement is mandatory

array

Policy conditions

Show condition properties

string

Condition type (and, or, not)

array

Requirements to evaluate

number

Minimum score threshold (0-100)

string

Policy expiry date (ISO 8601)

string

required

Subject identity to evaluate (ZKS ID or wallet address)

object

Additional context for evaluation

Show context properties

string

Service requesting evaluation

string

Action being evaluated

object

Additional metadata

object

Evaluation options

Show options properties

boolean

Include detailed evaluation results (default: true)

boolean

Include relevant attestations (default: true)

boolean

Include trust score breakdown (default: true)

boolean

Use strict evaluation mode (default: false)

Response

boolean

Indicates if the evaluation was successful

boolean

Whether the subject passed the policy evaluation

number

Overall evaluation score (0-100)

number

Policy threshold score

string

Evaluated subject identity

object

Policy details

Show policy properties

string

Policy identifier

string

Policy name

string

Policy description

array

Requirement evaluation results

Show requirement properties

string

Requirement type

boolean

Whether requirement passed

number

Requirement score

number

Requirement weight

boolean

Whether requirement is mandatory

object

Requirement evaluation details

array

Relevant attestations used in evaluation

Show attestation properties

string

Attestation identifier

string

Attestation schema

number

Attestation trust score

number

Relevance to policy (0-1)

object

Score breakdown by category

Show breakdown properties

number

Overall trust score

number

Attestation-based score

number

Skill-based score

number

Relationship-based score

number

Achievement-based score

array

Recommendations for improvement

Show recommendation properties

string

Recommendation type

string

Recommendation description

number

Expected impact on score

string

Recommendation priority (high, medium, low)

string

ISO 8601 timestamp of the evaluation

Examples

curl -X POST "https://api.onzks.com/v1/trust/evaluate" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "policy": {
      "id": "defi_access_policy",
      "name": "DeFi Protocol Access",
      "description": "Access policy for DeFi protocols",
      "requirements": [
        {
          "type": "trustScore",
          "operator": "gte",
          "value": 70,
          "weight": 0.4,
          "required": true
        },
        {
          "type": "attestation",
          "operator": "contains",
          "value": "skill",
          "weight": 0.3,
          "required": true
        },
        {
          "type": "attestation",
          "operator": "contains",
          "value": "relationship",
          "weight": 0.3,
          "required": false
        }
      ],
      "threshold": 75
    },
    "subject": "alice.zks",
    "context": {
      "service": "defi_protocol",
      "action": "lending"
    }
  }'

curl -X POST "https://api.onzks.com/v1/trust/evaluate" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "policy": {
      "id": "whale_trader_policy",
      "name": "Whale Trader Access",
      "description": "Access policy for high-volume traders",
      "requirements": [
        {
          "type": "trustScore",
          "operator": "gte",
          "value": 85,
          "weight": 0.5,
          "required": true
        },
        {
          "type": "attestation",
          "operator": "contains",
          "value": "achievement",
          "weight": 0.3,
          "required": true
        },
        {
          "type": "attestation",
          "operator": "contains",
          "value": "reputation",
          "weight": 0.2,
          "required": false
        }
      ],
      "conditions": [
        {
          "type": "and",
          "requirements": [0, 1]
        }
      ],
      "threshold": 80
    },
    "subject": "bob.zks",
    "options": {
      "includeDetails": true,
      "includeAttestations": true,
      "includeScore": true,
      "strictMode": false
    }
  }'

async function evaluatePolicy(policy, subject, context = {}, options = {}) {
  const {
    includeDetails = true,
    includeAttestations = true,
    includeScore = true,
    strictMode = false
  } = options;

  const requestBody = {
    policy,
    subject,
    context,
    options: {
      includeDetails,
      includeAttestations,
      includeScore,
      strictMode
    }
  };

  const response = await fetch('https://api.onzks.com/v1/trust/evaluate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(requestBody)
  });

  const result = await response.json();

  console.log(`Policy Evaluation for ${subject}:`);
  console.log(`Passed: ${result.passed}`);
  console.log(`Score: ${result.score}/${result.threshold}`);
  console.log(`Requirements passed: ${result.requirements.filter(r => r.passed).length}/${result.requirements.length}`);

  if (result.recommendations && result.recommendations.length > 0) {
    console.log('Recommendations:');
    result.recommendations.forEach(rec => {
      console.log(`- ${rec.description} (${rec.priority} priority)`);
    });
  }

  return result;
}

// Usage examples
const defiPolicy = {
  id: 'defi_access_policy',
  name: 'DeFi Protocol Access',
  description: 'Access policy for DeFi protocols',
  requirements: [
    {
      type: 'trustScore',
      operator: 'gte',
      value: 70,
      weight: 0.4,
      required: true
    },
    {
      type: 'attestation',
      operator: 'contains',
      value: 'skill',
      weight: 0.3,
      required: true
    }
  ],
  threshold: 75
};

await evaluatePolicy(defiPolicy, 'alice.zks', {
  service: 'defi_protocol',
  action: 'lending'
});

import requests
import json

def evaluate_policy(policy, subject, context=None, options=None):
    if context is None:
        context = {}
    if options is None:
        options = {}
    
    request_body = {
        'policy': policy,
        'subject': subject,
        'context': context,
        'options': {
            'includeDetails': options.get('includeDetails', True),
            'includeAttestations': options.get('includeAttestations', True),
            'includeScore': options.get('includeScore', True),
            'strictMode': options.get('strictMode', False)
        }
    }
    
    response = requests.post(
        'https://api.onzks.com/v1/trust/evaluate',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        },
        json=request_body
    )
    
    result = response.json()
    
    print(f"Policy Evaluation for {subject}:")
    print(f"Passed: {result['passed']}")
    print(f"Score: {result['score']}/{result['threshold']}")
    print(f"Requirements passed: {len([r for r in result['requirements'] if r['passed']])}/{len(result['requirements'])}")
    
    if result.get('recommendations'):
        print('Recommendations:')
        for rec in result['recommendations']:
            print(f"- {rec['description']} ({rec['priority']} priority)")
    
    return result

# Usage examples
defi_policy = {
    'id': 'defi_access_policy',
    'name': 'DeFi Protocol Access',
    'description': 'Access policy for DeFi protocols',
    'requirements': [
        {
            'type': 'trustScore',
            'operator': 'gte',
            'value': 70,
            'weight': 0.4,
            'required': True
        },
        {
            'type': 'attestation',
            'operator': 'contains',
            'value': 'skill',
            'weight': 0.3,
            'required': True
        }
    ],
    'threshold': 75
}

evaluate_policy(defi_policy, 'alice.zks', {
    'service': 'defi_protocol',
    'action': 'lending'
})

Response Example

{
  "success": true,
  "passed": true,
  "score": 82.5,
  "threshold": 75,
  "subject": "alice.zks",
  "policy": {
    "id": "defi_access_policy",
    "name": "DeFi Protocol Access",
    "description": "Access policy for DeFi protocols"
  },
  "requirements": [
    {
      "type": "trustScore",
      "passed": true,
      "score": 85.0,
      "weight": 0.4,
      "required": true,
      "details": {
        "currentScore": 85.0,
        "requiredScore": 70.0,
        "difference": 15.0
      }
    },
    {
      "type": "attestation",
      "passed": true,
      "score": 90.0,
      "weight": 0.3,
      "required": true,
      "details": {
        "schema": "skill",
        "count": 3,
        "averageTrustScore": 90.0
      }
    },
    {
      "type": "attestation",
      "passed": true,
      "score": 75.0,
      "weight": 0.3,
      "required": false,
      "details": {
        "schema": "relationship",
        "count": 2,
        "averageTrustScore": 75.0
      }
    }
  ],
  "attestations": [
    {
      "id": "att_1234567890abcdef",
      "schema": "skill",
      "trustScore": 90.0,
      "relevance": 0.9
    },
    {
      "id": "att_abcdef1234567890",
      "schema": "relationship",
      "trustScore": 75.0,
      "relevance": 0.7
    }
  ],
  "breakdown": {
    "trustScore": 85.0,
    "attestationScore": 82.5,
    "skillScore": 90.0,
    "relationshipScore": 75.0,
    "achievementScore": 0.0
  },
  "recommendations": [
    {
      "type": "improvement",
      "description": "Consider adding more relationship attestations to improve your score",
      "impact": 5.0,
      "priority": "medium"
    },
    {
      "type": "maintenance",
      "description": "Your current score is good, maintain your existing attestations",
      "impact": 0.0,
      "priority": "low"
    }
  ],
  "timestamp": "2024-01-20T15:45:00Z"
}

Use Cases

1. Access Control

Implement trust-based access control:

async function checkAccess(subject, service, action) {
  const policy = await getAccessPolicy(service, action);
  
  const result = await evaluatePolicy(policy, subject, {
    service,
    action
  });
  
  return {
    allowed: result.passed,
    score: result.score,
    threshold: result.threshold,
    requirements: result.requirements,
    recommendations: result.recommendations
  };
}

// Usage
const access = await checkAccess('alice.zks', 'defi_protocol', 'lending');
if (access.allowed) {
  console.log('Access granted');
} else {
  console.log('Access denied. Recommendations:', access.recommendations);
}

2. Credential Verification

Verify user credentials:

async function verifyCredentials(subject, requiredCredentials) {
  const policy = {
    id: 'credential_verification',
    name: 'Credential Verification',
    description: 'Verify required credentials',
    requirements: requiredCredentials.map(cred => ({
      type: 'attestation',
      operator: 'contains',
      value: cred.schema,
      weight: cred.weight || 1.0,
      required: cred.required !== false
    })),
    threshold: 80
  };
  
  return await evaluatePolicy(policy, subject);
}

// Usage
const credentials = [
  { schema: 'skill', weight: 0.4, required: true },
  { schema: 'identity', weight: 0.3, required: true },
  { schema: 'reputation', weight: 0.3, required: false }
];

const verification = await verifyCredentials('alice.zks', credentials);

3. Service Eligibility

Check eligibility for services:

async function checkEligibility(subject, service) {
  const policies = await getServicePolicies(service);
  
  const results = await Promise.all(
    policies.map(policy => evaluatePolicy(policy, subject))
  );
  
  const overallPassed = results.every(result => result.passed);
  const averageScore = results.reduce((sum, result) => sum + result.score, 0) / results.length;
  
  return {
    eligible: overallPassed,
    averageScore,
    results,
    recommendations: results.flatMap(r => r.recommendations)
  };
}

4. Policy Testing

Test policies before deployment:

async function testPolicy(policy, testSubjects) {
  const results = await Promise.all(
    testSubjects.map(subject => evaluatePolicy(policy, subject))
  );
  
  const analysis = {
    totalTests: results.length,
    passed: results.filter(r => r.passed).length,
    failed: results.filter(r => !r.passed).length,
    averageScore: results.reduce((sum, r) => sum + r.score, 0) / results.length,
    scoreDistribution: analyzeScoreDistribution(results),
    commonFailures: identifyCommonFailures(results)
  };
  
  return analysis;
}

5. Policy Optimization

Optimize policies based on results:

function optimizePolicy(policy, evaluationResults) {
  const failedRequirements = evaluationResults
    .filter(r => !r.passed)
    .flatMap(r => r.requirements.filter(req => !req.passed));
  
  const optimization = {
    adjustThreshold: calculateThresholdAdjustment(failedRequirements),
    modifyRequirements: suggestRequirementChanges(failedRequirements),
    addRequirements: suggestNewRequirements(evaluationResults),
    removeRequirements: suggestRequirementRemoval(failedRequirements)
  };
  
  return optimization;
}

Best Practices

1. Policy Design

Design effective policies:

function createEffectivePolicy(requirements, threshold) {
  return {
    id: generatePolicyId(),
    name: 'Effective Policy',
    description: 'Well-designed policy',
    requirements: requirements.map(req => ({
      ...req,
      weight: req.weight || 1.0,
      required: req.required !== false
    })),
    threshold: threshold || 70,
    conditions: createLogicalConditions(requirements)
  };
}

2. Caching

Cache policy evaluations:

let policyCache = new Map();
const CACHE_TTL = 5 * 60 * 1000; // 5 minutes

async function getCachedPolicyEvaluation(policy, subject) {
  const cacheKey = `${policy.id}-${subject}`;
  const cached = policyCache.get(cacheKey);
  
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }
  
  const data = await evaluatePolicy(policy, subject);
  policyCache.set(cacheKey, {
    data,
    timestamp: Date.now()
  });
  
  return data;
}

3. Error Handling

Handle evaluation errors:

async function safeEvaluatePolicy(policy, subject) {
  try {
    return await evaluatePolicy(policy, subject);
  } catch (error) {
    if (error.message.includes('Policy not found')) {
      throw new Error('Invalid policy');
    } else if (error.message.includes('Subject not found')) {
      throw new Error('Invalid subject');
    } else {
      throw new Error('Evaluation failed');
    }
  }
}

4. Monitoring

Monitor policy performance:

function monitorPolicyPerformance(policy, evaluations) {
  const metrics = {
    totalEvaluations: evaluations.length,
    passRate: evaluations.filter(e => e.passed).length / evaluations.length,
    averageScore: evaluations.reduce((sum, e) => sum + e.score, 0) / evaluations.length,
    commonFailures: identifyCommonFailures(evaluations),
    performanceTrends: analyzePerformanceTrends(evaluations)
  };
  
  return metrics;
}

Get Attestations - Retrieve attestations
Create Attestation - Create new attestations
Revoke Attestation - Revoke attestations
Get Modules - Get available trust modules

Troubleshooting

”Policy not found”

Cause: Invalid policy ID or policy doesn’t exist. Solution:

Verify the policy ID is correct
Check if the policy exists
Ensure you have access to the policy

”Subject not found”

Cause: Invalid subject identity or subject doesn’t exist. Solution:

Verify the subject identity is correct
Check if the subject exists
Ensure the subject has some activity

”Invalid policy format”

Cause: Policy structure is invalid. Solution:

Check the policy structure
Ensure all required fields are present
Validate the policy format

”Evaluation failed”

Cause: Internal error during evaluation. Solution:

Check the policy requirements
Verify the subject data
Contact support if the issue persists

Rate Limits

Policy evaluation requests are subject to rate limits:

Free tier: 60 requests per minute
Starter tier: 300 requests per minute
Professional tier: 1,000 requests per minute
Enterprise tier: Custom limits

Implement caching to reduce API calls.

Revoke Attestation Create API Key

API Documentation

Identity

Scores

Achievements

Trading

Trust Layer

Developer Tools

Overview

Parameters

Response

Examples

Response Example

Use Cases

1. Access Control

2. Credential Verification

3. Service Eligibility

4. Policy Testing

5. Policy Optimization

Best Practices

1. Policy Design

2. Caching

3. Error Handling

4. Monitoring

Troubleshooting

”Policy not found”

”Subject not found”

”Invalid policy format”

”Evaluation failed”

Rate Limits

​Overview

​Parameters

​Response

​Examples

​Response Example

​Use Cases

​1. Access Control

​2. Credential Verification

​3. Service Eligibility

​4. Policy Testing

​5. Policy Optimization

​Best Practices

​1. Policy Design

​2. Caching

​3. Error Handling

​4. Monitoring

​Related Endpoints

​Troubleshooting

​”Policy not found”

​”Subject not found”

​”Invalid policy format”

​”Evaluation failed”

​Rate Limits

Overview

Parameters

Response

Examples

Response Example

Use Cases

1. Access Control

2. Credential Verification

3. Service Eligibility

4. Policy Testing

5. Policy Optimization

Best Practices

1. Policy Design

2. Caching

3. Error Handling

4. Monitoring

Related Endpoints

Troubleshooting

”Policy not found”

”Subject not found”

”Invalid policy format”

”Evaluation failed”

Rate Limits