Skip to content Search Apps Documentation Source Content Run Reset Eval Playground File Folder Download Copy Actions State String Boolean Number Struct Map Slice Pointer Function Closure Reference Nil Package Type Interface Unknown

Playground

contract.gno

// Package vault demonstrates a minimal time-locked token vault built on top of
// the grc20 token package. Deposited tokens are held at the realm's own
// address; withdrawing them is a two-step process: Unvault marks an amount for
// withdrawal and starts a lock timer, then (once the lock elapses) Redeem moves
// the tokens back to the depositor.
package vault

import (
	"chain/runtime"
	"chain/runtime/unsafe"

	tokens "gno.land/p/nt/grc20/v0"
)

// test1 receives the initial mint at construction.
var test1 = address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5")

// lockDuration is the number of blocks that must pass between Unvault and
// Redeem.
const lockDuration = int64(100)

// Token and FooVault-equivalent state are exported for reading; privateLedger
// stays unexported (unrestricted mint/burn/transfer).
var (
	Token         *tokens.Token
	privateLedger *tokens.PrivateLedger
	vaultAddr     address // address holding all deposited tokens

	vaulted   = map[address]uint{}    // still-locked deposits per owner
	pending   = map[address]uint{}    // amount marked for withdrawal
	unlockAt  = map[address]int64{}    // block height at which pending unlocks
	recoverOf = map[address]address{}  // recovery address per depositor
)

func init(cur realm) {
	// generate the token and mint some tokens to test1.
	Token, privateLedger = tokens.NewToken("Foo Token", "FOO", 4, 0, cur)
	privateLedger.Mint(test1, 100000000)

	// the vault holds deposited tokens at the realm's own address.
	vaultAddr = cur.Address()
}

func MyBalance() int64 {
	return Token.BalanceOf(unsafe.OriginCaller())
}

// Deposit moves amount tokens from the caller into the vault, recording a
// recovery address for later use.
func Deposit(cur realm, amount uint, recoverAddress address) {
	caller := unsafe.OriginCaller()
	if err := privateLedger.Transfer(caller, vaultAddr, int64(amount)); err != nil {
		panic(err)
	}
	vaulted[caller] += amount
	recoverOf[caller] = recoverAddress
}

// Recover sends target's still-locked deposit to its recorded recovery address.
func Recover(cur realm, target address) {
	amount := vaulted[target]
	if amount == 0 {
		return
	}
	dest := recoverOf[target]
	if err := privateLedger.Transfer(vaultAddr, dest, int64(amount)); err != nil {
		panic(err)
	}
	vaulted[target] = 0
}

// Unvault marks amount of the caller's deposit for withdrawal and starts the
// lock timer.
func Unvault(cur realm, amount uint) {
	caller := unsafe.OriginCaller()
	if vaulted[caller] < amount {
		panic("insufficient vaulted balance")
	}
	vaulted[caller] -= amount
	pending[caller] += amount
	unlockAt[caller] = runtime.ChainHeight() + lockDuration
}

// Redeem transfers amount of the caller's matured pending withdrawal back to
// the caller.
func Redeem(cur realm, amount uint) {
	caller := unsafe.OriginCaller()
	if pending[caller] < amount {
		panic("insufficient pending balance")
	}
	if runtime.ChainHeight() < unlockAt[caller] {
		panic("still locked")
	}
	if err := privateLedger.Transfer(vaultAddr, caller, int64(amount)); err != nil {
		panic(err)
	}
	pending[caller] -= amount
}

gnomod.toml

module = "gno.land/r/moul/demo/vault/v0"
gno = "0.9"

[addpkg]
  creator = "g1manfred47kzduec920z88wfr64ylksmdcedlf5"
  height = 26343
  max_deposit = "100000000ugnot"