Buduj na Octra.

// projekt wieloplikowy AML
main.aml
interfaces/
  IOCS01.aml      // interfejsy tokenów
  IVault.aml

// main.aml importuje z interfaces/
import IOCS01 from "interfaces/IOCS01.aml"

contract Token implements IOCS01 {
  // implementacja
}

curl -X POST https://rpc.octra.org/rpc \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"node_status","params":[]}'

contract Counter {
  state {
    owner: address
    count: int
  }

  event Incremented(by: address, value: int)

  constructor() {
    self.owner = origin
    self.count = 0
  }

  view fn get_count(): int {
    return self.count
  }

  fn inc(): bool {
    self.count = self.count + 1
    emit Incremented(caller, self.count)
    return true
  }
}

state {
  owner:         address
  total_supply:  int
  is_paused:     int           // bool jako 0/1 !
  balances:      map[address]int
  grants:        map[address]map[address]int
  secret_val:    ct_int        // zaszyfrowane pole
}

// Wzorce dostępu do state:
self.owner                          // proste pole
self.balances[addr]                 // wpis mapy
self.grants[owner][spender]         // zagnieżdżona mapa
self.total_supply = supply          // przypisanie
self.balances[to] = self.balances[to] + amount  // aktualizacja
self.balances[to] += amount         // compound (jeśli wspierane)

field              →  proste pole
field:key          →  wpis mapy
field:key1:key2    →  zagnieżdżona mapa
field:key:pole     →  pole structa w mapie
field:0, field:1   →  elementy listy

// Bezpieczny pattern: check → compute → update
fn withdraw(amount: ct_int) {
  // 1. Sprawdź saldo BEZ odszyfrowywania
  require(ct_gte(self.balance, amount))
  // 2. Zaktualizuj zaszyfrowane saldo
  self.balance = ct_sub(self.balance, amount)
  // 3. Wyślij kwotę — decrypt TYLKO dla send()
  send(caller, decrypt(amount))
}

// Porównaj oferty bez ich ujawniania
fn bid(amount: ct_int) {
  require(self.ended == 0)
  // ct_gte nie ujawnia wartości — tylko wynik bool
  if ct_gte(amount, self.best_bid) {
    self.best_bid  = amount
    self.best_addr = caller
  }
}

fn vote(choice: ct_bool) {
  // choice=1 → TAK, choice=0 → NIE
  // Dodaj 1 do yes jeśli choice=true
  self.yes = ct_add(self.yes, ct_and(choice, encrypt(1)))
  // Dodaj 1 do no jeśli choice=false (ct_not)
  self.no  = ct_add(self.no,  ct_and(ct_not(choice), encrypt(1)))
}

POST /rpc
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "METHOD_NAME",
  "params": []   // tablica pozycyjna — nie obiekt!
}

// Sukces:
{ "jsonrpc": "2.0", "id": 1, "result": { /* dane */ } }

// Błąd (standard JSON-RPC):
{ "jsonrpc": "2.0", "id": 1,
  "error": { "code": -32000, "message": "error" } }

// Typowe przyczyny błędów submitu:
// - nieprawidłowy podpis
// - nieprawidłowy nonce
// - niewystarczające saldo
// - zduplikowana transakcja
// - za niska opłata (fee too low)
// - staging full
// - nieprawidłowy adres

curl -X POST https://rpc.octra.org/rpc \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "octra_balance",
    "params": ["octTwójAdres..."]
  }'

// Response:
{
  "result": {
    "balance": "1.500000",          // OCT (6 miejsc)
    "balance_raw": 1500000,         // OU
    "nonce": 5,
    "pending_nonce": 5
  }
}

{
  "from":      "octNadawca...",
  "to":        "octOdbiorca...",
  "amount":    1000000,        // w OU (1 OCT = 1 000 000 OU)
  "fee":       1500,           // recommendedFee × 1.5
  "nonce":     6,              // octra_nonce(address) + 1
  "timestamp": 1748466000,    // unix ms
  "public_key":"ed25519_hex...",
  "signature": "ed25519_sig_hex..."
}

// Read-only — get_count() nie zmienia stanu
curl -X POST https://rpc.octra.org/rpc \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0", "id": 1,
    "method": "octra_viewContract",
    "params": [
      "octAdresKontraktu...",
      "get_count",
      []
    ]
  }'

// Dla read-only: użyj trybu "view" w kliencie
// Dla write:     użyj trybu "send call tx"

{
  "runtime":       "octb",
  "privacy_class": "sealed",
  "browser_mode":  "native_sealed",
  "resource_mode": "sealed_read",
  "code_b64":      null,
  "policy_hash":   null,
  "members_root":  null,
  "export_policy": null,
  "limits": {
    "max_stable_bytes": "33554432",   // 32MB state
    "max_assets_bytes": "33554432",   // 32MB assets
    "max_inline_value": "65536",      // 64KB inline
    "max_wasm_bytes":   "33554432"    // 32MB WASM
  }
}

// Deterministyczne Circle ID
payload_hash = h256("octra:circle_deploy_payload:v1", json(payload))
seed         = h256("octra:circle_deploy_id:v1", deployer, nonce, payload_hash)
circle_id    = "oct" + base58(seed)[0:44]

// Uwaga: zmiana payloadu lub deployer adresu = inny circle_id

# Przez lokalny klient webowy (port 8420)
curl -X POST http://127.0.0.1:8420/api/circle/deploy \
  -H 'Content-Type: application/json' \
  -d '{
    "circle_id":     "oct...",
    "runtime":       "octb",
    "privacy_class": "sealed",
    "browser_mode":  "native_sealed",
    "resource_mode": "sealed_read"
  }'

# Upload zaszyfrowanego assetu przez local API
curl -X POST http://127.0.0.1:8420/api/circle/upload \
  -H 'Content-Type: application/json' \
  -d '{
    "circle_id": "oct...",
    "path":      "/index.html",
    "content":   "base64_zaszyfrowanej_zawartosci..."
  }'

# Odczyt przez klienta (rozszyfrowanie lokalne):
# GET http://127.0.0.1:8420/oct/<circle_id>/index.html
# Klient pobiera z RPC, rozszyfrowuje lokalnie, serwuje

interface IOCS01 {
  fn transfer(to: address, amount: int): bool
  fn grant(spender: address, amount: int): bool
  fn pull(from: address, to: address, amount: int): bool
  fn balance_of(addr: address): int
  fn allowance(owner: address, spender: address): int
  fn get_name(): string
  fn get_symbol(): string
  fn get_total_supply(): int
}

contract PrivateVault {
  state {
    balance: ct_int
    owner:   address
    locked:  int      // bool jako 0/1
  }

  constructor() {
    self.owner   = origin
    self.balance = encrypt(0)
    self.locked  = 0
  }

  fn deposit(): bool {
    require(caller == self.owner)
    require(self.locked == 0)
    // value = natywny OCT przesłany z tx (w OU)
    self.balance = ct_add(self.balance, encrypt(value))
    return true
  }

  fn withdraw(amount: ct_int): bool {
    require(caller == self.owner)
    // check ≥ bez odszyfrowywania
    require(ct_gte(self.balance, amount))
    self.balance = ct_sub(self.balance, amount)
    send(caller, decrypt(amount))
    return true
  }

  fn lock(): bool {
    require(caller == self.owner)
    self.locked = 1
    return true
  }

  view fn is_locked(): int {
    return self.locked
  }
}

contract SealedAuction {
  state {
    best_bid:  ct_int
    best_addr: address
    ended:     int
    admin:     address
  }

  constructor() {
    self.admin    = caller
    self.best_bid = encrypt(0)
    self.ended    = 0
  }

  fn bid(amount: ct_int) {
    require(self.ended == 0)
    // Blind comparison — nikt nie widzi wartości
    if ct_gte(amount, self.best_bid) {
      self.best_bid  = amount
      self.best_addr = caller
    }
  }

  fn finalize(): address {
    require(caller == self.admin)
    self.ended = 1
    return self.best_addr    // zwycięzca — adres jawny
  }

  // Admin może odszyfrować najwyższą ofertę po zakończeniu
  view fn get_winner(): address {
    require(self.ended == 1)
    return self.best_addr
  }
}

contract PrivateVote {
  state {
    yes_count: ct_int
    no_count:  ct_int
    ended:     int
    admin:     address
  }

  constructor() {
    self.admin     = caller
    self.yes_count = encrypt(0)
    self.no_count  = encrypt(0)
    self.ended     = 0
  }

  fn vote(choice: ct_bool) {
    // choice=1 → TAK, choice=0 → NIE
    require(self.ended == 0)
    // Nikt nie widzie indywidualnego głosu
    self.yes_count = ct_add(
      self.yes_count,
      ct_and(choice, encrypt(1))
    )
    self.no_count = ct_add(
      self.no_count,
      ct_and(ct_not(choice), encrypt(1))
    )
  }

  fn close() {
    require(caller == self.admin)
    self.ended = 1
  }

  // Wynik: TAK wygrało (ct_bool — jeszcze zaszyfrowany)
  view fn result(): ct_bool {
    require(self.ended == 1)
    return ct_gte(self.yes_count, self.no_count)
  }
}

import IOCS01 from "interfaces/IOCS01.aml"

contract MyToken implements IOCS01 {
  state {
    owner:        address
    total_supply: int
    name:         string
    symbol:       string
    decimals:     int
    balances:     map[address]int
    grants:       map[address]map[address]int
  }

  constructor(supply: int) {
    self.owner        = origin
    self.name         = "My Token"
    self.symbol       = "MTK"
    self.decimals     = 6
    self.total_supply = supply
    self.balances[origin] = supply  // cały supply do deployer
  }

  fn transfer(to: address, amount: int): bool {
    require(self.balances[caller] >= amount)
    self.balances[caller] = self.balances[caller] - amount
    self.balances[to]     = self.balances[to] + amount
    return true
  }

  fn grant(spender: address, amount: int): bool {
    self.grants[caller][spender] = amount
    return true
  }

  fn pull(from: address, to: address, amount: int): bool {
    require(self.grants[from][caller] >= amount)
    require(self.balances[from] >= amount)
    self.grants[from][caller]  = self.grants[from][caller] - amount
    self.balances[from] = self.balances[from] - amount
    self.balances[to]   = self.balances[to] + amount
    return true
  }

  view fn balance_of(addr: address): int {
    return self.balances[addr]
  }

  view fn allowance(owner: address, spender: address): int {
    return self.grants[owner][spender]
  }

  view fn get_name(): string         { return self.name }
  view fn get_symbol(): string       { return self.symbol }
  view fn get_total_supply(): int    { return self.total_supply }
}