refactor: PrevRealm => PreviousRealm

docs/assets/how-to-guides/creating-grc20/mytoken-1.gno

@@ -17,7 +17,7 @@ var (
 // init is called once at time of deployment
 func init() {
 	// Set deployer of Realm to admin
-	admin = std.PrevRealm().Addr()
+	admin = std.PreviousRealm().Addr()
 
 	// Set token name, symbol and number of decimals
 	banker = grc20.NewBanker("My Token", "TKN", 4)

docs/assets/how-to-guides/creating-grc20/mytoken-2.gno

@@ -44,13 +44,13 @@ func TransferFrom(from, to std.Address, amount uint64) {
 
 // Mint mints amount of tokens to address. Callable only by admin of token
 func Mint(address std.Address, amount uint64) {
-	assertIsAdmin(std.PrevRealm().Addr())
+	assertIsAdmin(std.PreviousRealm().Addr())
 	checkErr(banker.Mint(address, amount))
 }
 
 // Burn burns amount of tokens from address. Callable only by admin of token
 func Burn(address std.Address, amount uint64) {
-	assertIsAdmin(std.PrevRealm().Addr())
+	assertIsAdmin(std.PreviousRealm().Addr())
 	checkErr(banker.Burn(address, amount))
 }
 

docs/concepts/effective-gno.md

@@ -115,7 +115,7 @@ that could lead to user frustration or the need to fork the code.
 import "std"
 
 func Foobar() {
-    caller := std.PrevRealm().Addr()
+    caller := std.PreviousRealm().Addr()
     if caller != "g1xxxxx" {
         panic("permission denied")
     }
@@ -399,15 +399,15 @@ certain operations.
 import "std"
 
 func PublicMethod(nb int) {
-    caller := std.PrevRealm().Addr()
+    caller := std.PreviousRealm().Addr()
     privateMethod(caller, nb)
 }
 
 func privateMethod(caller std.Address, nb int) { /* ... */ }
 ```
 
 In this example, `PublicMethod` is a public function that can be called by other
-realms. It retrieves the caller's address using `std.PrevRealm().Addr()`, and
+realms. It retrieves the caller's address using `std.PreviousRealm().Addr()`, and
 then passes it to `privateMethod`, which is a private function that performs the
 actual logic. This way, `privateMethod` can only be called from within the
 realm, and it can use the caller's address for authentication or authorization
@@ -440,11 +440,11 @@ import (
 var owner std.Address
 
 func init() {
-	owner = std.PrevRealm().Addr()
+	owner = std.PreviousRealm().Addr()
 }
 
 func ChangeOwner(newOwner std.Address) {
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 
 	if caller != owner {
 		panic("access denied")
@@ -494,7 +494,7 @@ whitelisted or not.
 
 Let's deep dive into the different access control mechanisms we can use:
 
-One strategy is to look at the caller with `std.PrevRealm()`, which could be the
+One strategy is to look at the caller with `std.PreviousRealm()`, which could be the
 EOA (Externally Owned Account), or the preceding realm in the call stack.
 
 Another approach is to look specifically at the EOA. For this, you should call
@@ -516,7 +516,7 @@ import "std"
 var admin std.Address = "g1xxxxx"
 
 func AdminOnlyFunction() {
-    caller := std.PrevRealm().Addr()
+    caller := std.PreviousRealm().Addr()
     if caller != admin {
         panic("permission denied")
     }
@@ -527,7 +527,7 @@ func AdminOnlyFunction() {
 ```
 
 In this example, `AdminOnlyFunction` is a function that can only be called by
-the admin. It retrieves the caller's address using `std.PrevRealm().Addr()`,
+the admin. It retrieves the caller's address using `std.PreviousRealm().Addr()`,
 this can be either another realm contract, or the calling user if there is no
 other intermediary realm. and then checks if the caller is the admin. If not, it
 panics and stops the execution.
@@ -543,7 +543,7 @@ Here's an example:
 import "std"
 
 func TransferTokens(to std.Address, amount int64) {
-    caller := std.PrevRealm().Addr()
+    caller := std.PreviousRealm().Addr()
     if caller != admin {
         panic("permission denied")
     }
@@ -552,7 +552,7 @@ func TransferTokens(to std.Address, amount int64) {
 ```
 
 In this example, `TransferTokens` is a function that can only be called by the
-admin. It retrieves the caller's address using `std.PrevRealm().Addr()`, and
+admin. It retrieves the caller's address using `std.PreviousRealm().Addr()`, and
 then checks if the caller is the admin. If not, the function panics and execution is stopped.
 
 By using these access control mechanisms, you can ensure that your contract's
@@ -631,7 +631,7 @@ type MySafeStruct {
 }
 
 func NewSafeStruct() *MySafeStruct {
-    caller := std.PrevRealm().Addr()
+    caller := std.PreviousRealm().Addr()
     return &MySafeStruct{
         counter: 0,
         admin: caller,
@@ -640,7 +640,7 @@ func NewSafeStruct() *MySafeStruct {
 
 func (s *MySafeStruct) Counter() int { return s.counter }
 func (s *MySafeStruct) Inc() {
-    caller := std.PrevRealm().Addr()
+    caller := std.PreviousRealm().Addr()
     if caller != s.admin {
         panic("permission denied")
     }
@@ -704,7 +704,7 @@ import "gno.land/p/demo/grc/grc20"
 var fooToken = grc20.NewBanker("Foo Token", "FOO", 4)
 
 func MyBalance() uint64 {
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	return fooToken.BalanceOf(caller)
 }
 ```

docs/how-to-guides/creating-grc20.md

@@ -41,7 +41,7 @@ var (
 // init is called once at time of deployment
 func init() {
 	// Set deployer of Realm to admin
-	admin = std.PrevRealm().Addr()
+	admin = std.PreviousRealm().Addr()
 
 	// Set token name, symbol and number of decimals
 	banker = grc20.NewBanker("My Token", "TKN", 4)
@@ -142,7 +142,7 @@ caller’s allowance.
 ```go
 // Mint mints amount of tokens to address. Callable only by admin of token
 func Mint(address std.Address, amount uint64) {
-	assertIsAdmin(std.PrevRealm().Addr())
+	assertIsAdmin(std.PreviousRealm().Addr())
 	checkErr(banker.Mint(address, amount))
 }
 ```
@@ -153,7 +153,7 @@ increasing the total supply.
 ```go
 // Burn burns amount of tokens from address. Callable only by admin of token
 func Burn(address std.Address, amount uint64) {
-	assertIsAdmin(std.PrevRealm().Addr())
+	assertIsAdmin(std.PreviousRealm().Addr())
 	checkErr(banker.Burn(address, amount))
 }
 ```
@@ -162,7 +162,7 @@ decreasing the total supply.
 
 [embedmd]:# (../assets/how-to-guides/creating-grc20/mytoken-2.gno go /.*assertIsAdmin/ /^}/)
 ```go
-	assertIsAdmin(std.PrevRealm().Addr())
+	assertIsAdmin(std.PreviousRealm().Addr())
 	checkErr(banker.Mint(address, amount))
 }
 ```

docs/reference/stdlibs/std/chain.md

@@ -125,16 +125,16 @@ currentRealm := std.CurrentRealm()
 ```
 ---
 
-## PrevRealm
+## PreviousRealm
 ```go
-func PrevRealm() Realm
+func PreviousRealm() Realm
 ```
 Returns the previous caller [realm](realm.md) (can be code or user realm). If caller is a
 user realm, `pkgpath` will be empty.
 
 #### Usage
 ```go
-prevRealm := std.PrevRealm()
+prevRealm := std.PreviousRealm()
 ```
 ---
 

docs/reference/stdlibs/std/testing.md

@@ -98,7 +98,7 @@ func TestSetRealm(rlm Realm)
 
 Sets the realm for the current frame. After calling `TestSetRealm()`, calling 
 [`CurrentRealm()`](chain.md#currentrealm) in the same test function will yield the value of `rlm`, and 
-any `PrevRealm()` called from a function used after TestSetRealm will yield `rlm`.
+any `PreviousRealm()` called from a function used after TestSetRealm will yield `rlm`.
 
 Should be used in combination with [`NewUserRealm`](#newuserrealm) &
 [`NewCodeRealm`](#newcoderealm).

examples/gno.land/p/demo/grc/grc20/examples_test.gno

@@ -7,7 +7,7 @@ func ExampleExposeBankForMaketxRunOrImports() {}
 func ExampleCustomTellerImpl()                {}
 func ExampleAllowance()                       {}
 func ExampleRealmBanker()                     {}
-func ExamplePrevRealmBanker()                 {}
+func ExamplePreviousRealmBanker()                 {}
 func ExampleAccountBanker()                   {}
 func ExampleTransfer()                        {}
 func ExampleApprove()                         {}

examples/gno.land/p/demo/grc/grc20/tellers.gno

@@ -4,7 +4,7 @@ import (
 	"std"
 )
 
-// CallerTeller returns a GRC20 compatible teller that checks the PrevRealm
+// CallerTeller returns a GRC20 compatible teller that checks the PreviousRealm
 // caller for each call. It's usually safe to expose it publicly to let users
 // manipulate their tokens directly, or for realms to use their allowance.
 func (tok *Token) CallerTeller() Teller {
@@ -14,7 +14,7 @@ func (tok *Token) CallerTeller() Teller {
 
 	return &fnTeller{
 		accountFn: func() std.Address {
-			caller := std.PrevRealm().Addr()
+			caller := std.PreviousRealm().Addr()
 			return caller
 		},
 		Token: tok,
@@ -44,7 +44,7 @@ func (tok *Token) RealmTeller() Teller {
 		panic("Token cannot be nil")
 	}
 
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 
 	return &fnTeller{
 		accountFn: func() std.Address {
@@ -61,7 +61,7 @@ func (tok *Token) RealmSubTeller(slug string) Teller {
 		panic("Token cannot be nil")
 	}
 
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	account := accountSlugAddr(caller, slug)
 
 	return &fnTeller{

examples/gno.land/p/demo/grc/grc721/basic_nft.gno

@@ -81,7 +81,7 @@ func (s *basicNFT) SetTokenURI(tid TokenID, tURI TokenURI) (bool, error) {
 	if err != nil {
 		return false, err
 	}
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	if caller != owner {
 		return false, ErrCallerIsNotOwner
 	}
@@ -115,7 +115,7 @@ func (s *basicNFT) Approve(to std.Address, tid TokenID) error {
 		return ErrApprovalToCurrentOwner
 	}
 
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	if caller != owner && !s.IsApprovedForAll(owner, caller) {
 		return ErrCallerIsNotOwnerOrApproved
 	}
@@ -147,15 +147,15 @@ func (s *basicNFT) SetApprovalForAll(operator std.Address, approved bool) error
 		return ErrInvalidAddress
 	}
 
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	return s.setApprovalForAll(caller, operator, approved)
 }
 
 // Safely transfers `tokenId` token from `from` to `to`, checking that
 // contract recipients are aware of the GRC721 protocol to prevent
 // tokens from being forever locked.
 func (s *basicNFT) SafeTransferFrom(from, to std.Address, tid TokenID) error {
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	if !s.isApprovedOrOwner(caller, tid) {
 		return ErrCallerIsNotOwnerOrApproved
 	}
@@ -174,7 +174,7 @@ func (s *basicNFT) SafeTransferFrom(from, to std.Address, tid TokenID) error {
 
 // Transfers `tokenId` token from `from` to `to`.
 func (s *basicNFT) TransferFrom(from, to std.Address, tid TokenID) error {
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	if !s.isApprovedOrOwner(caller, tid) {
 		return ErrCallerIsNotOwnerOrApproved
 	}

examples/gno.land/p/demo/grc/grc721/basic_nft_test.gno

@@ -111,7 +111,7 @@ func TestSetApprovalForAll(t *testing.T) {
 	dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
 	uassert.True(t, dummy != nil, "should not be nil")
 
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
 
 	isApprovedForAll := dummy.IsApprovedForAll(caller, addr)
@@ -136,7 +136,7 @@ func TestApprove(t *testing.T) {
 	dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
 	uassert.True(t, dummy != nil, "should not be nil")
 
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
 
 	dummy.mint(caller, TokenID("1"))
@@ -156,7 +156,7 @@ func TestTransferFrom(t *testing.T) {
 	dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
 	uassert.True(t, dummy != nil, "should not be nil")
 
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
 
 	dummy.mint(caller, TokenID("1"))
@@ -185,7 +185,7 @@ func TestSafeTransferFrom(t *testing.T) {
 	dummy := NewBasicNFT(dummyNFTName, dummyNFTSymbol)
 	uassert.True(t, dummy != nil, "should not be nil")
 
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	addr := std.Address("g1var589z07ppjsjd24ukm4uguzwdt0tw7g47cgm")
 
 	dummy.mint(caller, TokenID("1"))

examples/gno.land/p/demo/grc/grc721/grc721_metadata.gno

@@ -34,7 +34,7 @@ func (s *metadataNFT) SetTokenMetadata(tid TokenID, metadata Metadata) error {
 	if err != nil {
 		return err
 	}
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	if caller != owner {
 		return ErrCallerIsNotOwner
 	}

examples/gno.land/p/demo/grc/grc721/grc721_royalty.gno

@@ -45,7 +45,7 @@ func (r *royaltyNFT) SetTokenRoyalty(tid TokenID, royaltyInfo RoyaltyInfo) error
 	if err != nil {
 		return err
 	}
-	caller := std.PrevRealm().Addr()
+	caller := std.PreviousRealm().Addr()
 	if caller != owner {
 		return ErrCallerIsNotOwner
 	}

examples/gno.land/p/demo/memeland/memeland.gno

@@ -50,7 +50,7 @@ func (m *Memeland) PostMeme(data string, timestamp int64) string {
 	newPost := &Post{
 		ID:            id,
 		Data:          data,
-		Author:        std.PrevRealm().Addr(),
+		Author:        std.PreviousRealm().Addr(),
 		Timestamp:     time.Unix(timestamp, 0),
 		UpvoteTracker: avl.NewTree(),
 	}
@@ -65,7 +65,7 @@ func (m *Memeland) Upvote(id string) string {
 		panic("post with specified ID does not exist")
 	}
 
-	caller := std.PrevRealm().Addr().String()
+	caller := std.PreviousRealm().Addr().String()
 
 	if _, exists := post.UpvoteTracker.Get(caller); exists {
 		panic("user has already upvoted this post")