txtar linguist mode comparison

1.c

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.console

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.cpp

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.cs

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.go

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.hs

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.js

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.json

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.php

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.pl

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.py

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.rb

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.sh

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.ts

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.txtar

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}

1.yml

# test for add package

## start a new node
gnoland start

# add registry
gnokey maketx addpkg -pkgdir $WORK/registry -pkgpath gno.land/r/registry -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, before it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'not found'

# add foo20, and foo20wrapper
gnokey maketx addpkg -pkgdir $WORK/foo20 -pkgpath gno.land/r/foo20 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
gnokey maketx addpkg -pkgdir $WORK/foo20wrapper -pkgpath gno.land/r/foo20wrapper -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1

# we call Transfer with foo20, after it's registered
gnokey maketx call -pkgpath gno.land/r/registry -func TransferByName -args 'foo20' -args 'g123456789' -args '42' -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
stdout 'same address, success!'

-- registry/registry.gno --
package registry

import "std"

type transferCb func(to std.Address, amount uint64) string
type pair struct {name string; cb transferCb}
var registry = []pair{}
func Register(name string, cb transferCb) { registry = append(registry, pair{name: name, cb: cb}) }
func TransferByName(name string, to string, amount uint64) string {
	for _, pair := range registry {
		if pair.name ==  name {
			if std.CurrentRealm().Addr().String() == pair.cb(std.Address(to), amount) {
				return "same address, success!"
			} else {
				return "invalid address, ownership issue :("
			}
			return "registry=" + std.CurrentRealm().Addr().String() + " " + pair.cb(std.Address(to), amount)
		}
	}
	return "not found"
}

-- foo20wrapper/foo20wrapper.gno --
package foo20wrapper

import "gno.land/r/registry"
import "gno.land/r/foo20"

func init() {
	  registry.Register("foo20", foo20.Transfer)	
}

-- foo20/foo20.gno --
package foo20

import "std"

func Transfer(to std.Address, amount uint64) string {
	println("transfer from=" + std.PrevRealm().Addr().String() + " to=" + to.String() + " some-amount")
	return std.PrevRealm().Addr().String()
}