oct6J37W…dpTx6d

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

  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)

  constructor(n: string, s: string, supply: int, dec: int) {
    require(len(n) > 0, "name empty")
    require(len(n) <= 32, "name too long")
    require(len(s) > 0, "symbol empty")
    require(len(s) <= 10, "symbol too long")
    require(supply > 0, "zero supply")
    require(dec >= 0, "negative decimals")
    require(dec <= 18, "decimals too large")
    self.name = n
    self.symbol = s
    self.total_supply = supply
    self.decimals = dec
    self.owner = origin
    self.balances[origin] = supply
    emit Transfer(origin, origin, supply)
  }

  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 balance_of(account: address): int {
    return self.balances[account]
  }

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

  fn transfer(to: address, amount: int): bool {
    require(is_address(to), "invalid address")
    require(amount > 0, "zero amount")
    let bal = self.balances[caller]
    require(bal >= amount, "insufficient balance")
    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(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(is_address(to), "invalid address")
    require(amount > 0, "zero amount")
    let allowed = self.grants[from][caller]
    require(allowed >= amount, "grant exceeded")
    self.grants[from][caller] = allowed - amount
    let bal = self.balances[from]
    require(bal >= amount, "insufficient balance")
    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 {
    require(caller == self.owner, "not owner")
    require(is_address(to), "invalid address")
    require(amount > 0, "zero amount")
    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(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
  }
}