oct6XaB1…Gc2ShV

contract tUSD {

  state {
    name:          string
    symbol:        string
    total_supply:  int
    decimals:      int
    owner:         address
    balances:      map[address]int
    grants:        map[address]map[address]int
    dex:           address
    dex_set:       bool
    dex_locked:    map[address]int
    paused:        int
    num_holders:   int
    holders:       map[int]address
  }

  event Transfer(from: address, to: address, amount: int)
  event Grant(owner: address, spender: address, amount: int)
  event Mint(to: address, amount: int)
  event Burn(from: address, amount: int)
  event DexSet(dex_addr: address)
  event DexDeposit(user: address, amount: int)
  event DexCredit(user: address, amount: int)
  event DexDebit(user: address, amount: int)
  event DexWithdraw(user: address, amount: int)

  error NotOwner(403, "caller is not the owner")
  error NotDex(403, "caller is not the dex")
  error ContractPaused(503, "contract is paused")
  error DexNotSet(400, "dex address not set")
  error InsufficientBalance(400, "insufficient balance")
  error InsufficientLocked(400, "insufficient locked balance")
  error SupplyCapExceeded(400, "supply cap exceeded")

  constructor() {
    self.name         = "Test USD"
    self.symbol       = "tUSD"
    self.decimals     = 6
    self.total_supply = 1000000000000
    self.owner        = origin
    self.dex_set      = false
    self.paused       = 0
    self.num_holders  = 1
    self.balances[origin]  = 1000000000000
    self.holders[0]        = origin
    emit Transfer(origin, origin, 1000000000000)
    emit Mint(origin, 1000000000000)
  }

  fn require_active() {
    require(self.paused == 0, "contract is paused")
  }

  fn only_owner() {
    require(caller == self.owner, "caller is not the owner")
  }

  fn only_dex() {
    require(self.dex_set, "dex address not set")
    require(caller == self.dex, "caller is not the dex")
  }

  fn register_holder(addr: address) {
    if self.balances[addr] == 0 {
      self.holders[self.num_holders] = addr
      self.num_holders = self.num_holders + 1
    }
  }

  fn transfer(to: address, amount: int): bool {
    require_active()
    require(is_address(to), "invalid address")
    require(amount > 0, "zero amount")
    let bal = self.balances[caller]
    require(bal >= amount, "insufficient balance")
    register_holder(to)
    self.balances[caller] = bal - amount
    self.balances[to]     = self.balances[to] + amount
    emit Transfer(caller, to, amount)
    return true
  }

  fn grant(spender: address, amount: int): bool {
    require_active()
    require(is_address(spender), "invalid address")
    require(amount >= 0, "negative amount")
    self.grants[caller][spender] = amount
    emit Grant(caller, spender, amount)
    return true
  }

  fn pull(from: address, to: address, amount: int): bool {
    require_active()
    require(is_address(to), "invalid address")
    require(amount > 0, "zero amount")
    let allowed = self.grants[from][caller]
    require(allowed >= amount, "grant exceeded")
    let bal = self.balances[from]
    require(bal >= amount, "insufficient balance")
    self.grants[from][caller] = allowed - amount
    register_holder(to)
    self.balances[from] = bal - amount
    self.balances[to]   = self.balances[to] + amount
    emit Transfer(from, to, amount)
    return true
  }

  fn mint(to: address, amount: int): bool {
    only_owner()
    require(is_address(to), "invalid address")
    require(amount > 0, "zero amount")
    require(self.total_supply + amount <= 1000000000000, "supply cap exceeded")
    register_holder(to)
    self.balances[to]    = self.balances[to] + amount
    self.total_supply    = self.total_supply + amount
    emit Mint(to, amount)
    return true
  }

  fn burn(amount: int): bool {
    require_active()
    require(amount > 0, "zero amount")
    let bal = self.balances[caller]
    require(bal >= amount, "insufficient balance")
    self.balances[caller] = bal - amount
    self.total_supply     = self.total_supply - amount
    emit Burn(caller, amount)
    return true
  }

  fn set_dex(dex_addr: address): bool {
    only_owner()
    require(is_address(dex_addr), "invalid address")
    self.dex     = dex_addr
    self.dex_set = true
    emit DexSet(dex_addr)
    return true
  }

  fn dex_deposit(amount: int): bool {
    require_active()
    require(self.dex_set, "dex address not set")
    require(amount > 0, "zero amount")
    let bal = self.balances[caller]
    require(bal >= amount, "insufficient balance")
    self.balances[caller]   = bal - amount
    self.dex_locked[caller] = self.dex_locked[caller] + amount
    emit Transfer(caller, self.dex, amount)
    emit DexDeposit(caller, amount)
    return true
  }

  fn dex_credit(trader: address, amount: int): bool {
    only_dex()
    require(amount > 0, "zero amount")
    require(self.total_supply + amount <= 1000000000000, "supply cap exceeded")
    self.total_supply       = self.total_supply + amount
    self.dex_locked[trader] = self.dex_locked[trader] + amount
    register_holder(trader)
    emit DexCredit(trader, amount)
    emit Mint(trader, amount)
    return true
  }

  fn dex_debit(trader: address, amount: int): bool {
    only_dex()
    require(amount > 0, "zero amount")
    let locked = self.dex_locked[trader]
    require(locked >= amount, "insufficient locked balance")
    self.dex_locked[trader] = locked - amount
    self.total_supply       = self.total_supply - amount
    emit DexDebit(trader, amount)
    emit Burn(trader, amount)
    return true
  }

  fn dex_withdraw(amount: int): bool {
    require_active()
    require(amount > 0, "zero amount")
    let locked = self.dex_locked[caller]
    require(locked >= amount, "insufficient locked")
    self.dex_locked[caller] = locked - amount
    register_holder(caller)
    self.balances[caller]   = self.balances[caller] + amount
    emit Transfer(self.dex, caller, amount)
    emit DexWithdraw(caller, amount)
    return true
  }

  fn pause(): bool {
    only_owner()
    self.paused = 1
    return true
  }

  fn unpause(): bool {
    only_owner()
    self.paused = 0
    return true
  }

  view fn name(): string        { return self.name }
  view fn symbol(): string      { return self.symbol }
  view fn total_supply(): int   { return self.total_supply }
  view fn decimals(): int       { return self.decimals }
  view fn get_dex(): address    { return self.dex }
  view fn is_paused(): int      { return self.paused }
  view fn num_holders(): int    { return self.num_holders }

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

  view fn locked_balance(user: address): int {
    return self.dex_locked[user]
  }

  view fn total_balance(user: address): int {
    return self.balances[user] + self.dex_locked[user]
  }

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

  view fn holder(index: int): address {
    return self.holders[index]
  }
}