Afrz: ASA Global Freeze

cmd/goal/account.go

@@ -696,6 +696,10 @@ func printAccountInfo(client libgoal.Client, address string, onlyShowAssetIDs bo
 		frozen := ""
 		if assetHolding.IsFrozen {
 			frozen = " (frozen)"
+		} else if assetParams.Params.LastGlobalFreeze != nil {
+			if *assetParams.Params.LastGlobalFreeze > assetHolding.LastFreezeChange {
+				frozen = " (globally frozen)"
+			}
 		}
 
 		fmt.Fprintf(report, "\tID %d, %s, balance %s %s%s\n", assetHolding.AssetID, assetName, amount, unitName, frozen)

cmd/goal/asset.go

@@ -115,7 +115,6 @@ func init() {
 	freezeAssetCmd.Flags().StringVar(&account, "account", "", "Account address to freeze/unfreeze")
 	freezeAssetCmd.Flags().BoolVar(&assetFrozen, "freeze", false, "Freeze or unfreeze")
 	freezeAssetCmd.MarkFlagRequired("freezer")
-	freezeAssetCmd.MarkFlagRequired("account")
 	freezeAssetCmd.MarkFlagRequired("freeze")
 
 	optinAssetCmd.Flags().StringVar(&assetUnitName, "asset", "", "Unit name of the asset being accepted")
@@ -776,6 +775,12 @@ var infoAssetCmd = &cobra.Command{
 			}
 			return *b
 		}
+		derefUint64 := func(u *uint64) uint64 {
+			if u == nil {
+				return 0
+			}
+			return *u
+		}
 
 		lookupAssetID(cmd, creator, client)
 
@@ -806,6 +811,7 @@ var infoAssetCmd = &cobra.Command{
 		fmt.Printf("Issued:           %s %s\n", assetDecimalsFmt(asset.Params.Total-res.Amount, asset.Params.Decimals), derefString(asset.Params.UnitName))
 		fmt.Printf("Decimals:         %d\n", asset.Params.Decimals)
 		fmt.Printf("Default frozen:   %v\n", derefBool(asset.Params.DefaultFrozen))
+		fmt.Printf("Global freeze:    %v\n", derefUint64(asset.Params.LastGlobalFreeze))
 		fmt.Printf("Manager address:  %s\n", derefString(asset.Params.Manager))
 		if reserveEmpty {
 			fmt.Printf("Reserve address:  %s (Empty. Defaulting to creator)\n", derefString(asset.Params.Reserve))

cmd/opdoc/opdoc.go

@@ -443,7 +443,7 @@ func create(file string) *os.File {
 }
 
 func main() {
-	const docVersion = uint64(11)
+	const docVersion = uint64(12)
 
 	opGroups := make(map[string][]string, len(logic.OpSpecs))
 	for grp, names := range logic.OpGroups {

config/consensus.go

@@ -550,6 +550,11 @@ type ConsensusParams struct {
 
 	// Heartbeat support
 	Heartbeat bool
+
+	// Allow for afrz transactions to target the zero address, freezing that
+	// asset for all holders. Subsequent unfreezing of an individuals holdings
+	// allows them to transfer the asset again.
+	AssetGlobalFreeze bool
 }
 
 // ProposerPayoutRules puts several related consensus parameters in one place. The same
@@ -1546,9 +1551,20 @@ func initConsensusProtocols() {
 	// our current max is 250000
 	v39.ApprovedUpgrades[protocol.ConsensusV40] = 208000
 
+	v41 := v40
+	v41.ApprovedUpgrades = map[protocol.ConsensusVersion]uint64{}
+
+	v41.AssetGlobalFreeze = true
+
+	Consensus[protocol.ConsensusV41] = v41
+
+	// v40 can be upgraded to v41, with an update delay of 7d.
+	// See previous for calculation.
+	// v40.ApprovedUpgrades[protocol.ConsensusV41] = 208000
+
 	// ConsensusFuture is used to test features that are implemented
 	// but not yet released in a production protocol version.
-	vFuture := v40
+	vFuture := v41
 	vFuture.ApprovedUpgrades = map[protocol.ConsensusVersion]uint64{}
 
 	vFuture.LogicSigVersion = 12 // When moving this to a release, put a new higher LogicSigVersion here

daemon/algod/api/algod.oas2.json

@@ -3309,7 +3309,8 @@
       "required": [
         "asset-id",
         "amount",
-        "is-frozen"
+        "is-frozen",
+        "last-freeze-change"
       ],
       "properties": {
         "amount": {
@@ -3325,6 +3326,10 @@
         "is-frozen": {
           "description": "\\[f\\] whether or not the holding is frozen.",
           "type": "boolean"
+        },
+        "last-freeze-change": {
+          "description": "\\[l\\] the last time the holding was frozen or unfrozen.",
+          "type": "integer"
         }
       }
     },
@@ -3359,6 +3364,10 @@
           "description": "\\[f\\] Address of account used to freeze holdings of this asset.  If empty, freezing is not permitted.",
           "type": "string"
         },
+        "last-global-freeze": {
+          "description": "\\[l\\] When (as transaction counter) transfers of this asset were globally frozen. 0 if unfrozen.",
+          "type": "integer"
+        },
         "manager": {
           "description": "\\[m\\] Address of account used to manage the keys of this asset and to destroy it.",
           "type": "string"

daemon/algod/api/algod.oas3.yml

@@ -1550,12 +1550,17 @@
           "is-frozen": {
             "description": "\\[f\\] whether or not the holding is frozen.",
             "type": "boolean"
+          },
+          "last-freeze-change": {
+            "description": "\\[l\\] the last time the holding was frozen or unfrozen.",
+            "type": "integer"
           }
         },
         "required": [
           "amount",
           "asset-id",
-          "is-frozen"
+          "is-frozen",
+          "last-freeze-change"
         ],
         "type": "object"
       },
@@ -1604,6 +1609,10 @@
             "description": "\\[f\\] Address of account used to freeze holdings of this asset.  If empty, freezing is not permitted.",
             "type": "string"
           },
+          "last-global-freeze": {
+            "description": "\\[l\\] When (as transaction counter) transfers of this asset were globally frozen. 0 if unfrozen.",
+            "type": "integer"
+          },
           "manager": {
             "description": "\\[m\\] Address of account used to manage the keys of this asset and to destroy it.",
             "type": "string"

daemon/algod/api/server/v2/account.go

@@ -33,9 +33,10 @@ import (
 // AssetHolding converts between basics.AssetHolding and model.AssetHolding
 func AssetHolding(ah basics.AssetHolding, ai basics.AssetIndex) model.AssetHolding {
 	return model.AssetHolding{
-		Amount:   ah.Amount,
-		AssetID:  uint64(ai),
-		IsFrozen: ah.Frozen,
+		Amount:           ah.Amount,
+		AssetID:          uint64(ai),
+		IsFrozen:         ah.Frozen,
+		LastFreezeChange: ah.LastFreezeChange,
 	}
 }
 
@@ -255,6 +256,10 @@ func AccountToAccountData(a *model.Account) (basics.AccountData, error) {
 			if ca.Params.DefaultFrozen != nil {
 				defaultFrozen = *ca.Params.DefaultFrozen
 			}
+			var lastGlobalFreeze uint64
+			if ca.Params.LastGlobalFreeze != nil {
+				lastGlobalFreeze = *ca.Params.LastGlobalFreeze
+			}
 			var url string
 			if ca.Params.Url != nil {
 				url = *ca.Params.Url
@@ -269,17 +274,18 @@ func AccountToAccountData(a *model.Account) (basics.AccountData, error) {
 			}
 
 			assetParams[basics.AssetIndex(ca.Index)] = basics.AssetParams{
-				Total:         ca.Params.Total,
-				Decimals:      uint32(ca.Params.Decimals),
-				DefaultFrozen: defaultFrozen,
-				UnitName:      unitName,
-				AssetName:     name,
-				URL:           url,
-				MetadataHash:  metadataHash,
-				Manager:       manager,
-				Reserve:       reserve,
-				Freeze:        freeze,
-				Clawback:      clawback,
+				Total:            ca.Params.Total,
+				Decimals:         uint32(ca.Params.Decimals),
+				DefaultFrozen:    defaultFrozen,
+				LastGlobalFreeze: lastGlobalFreeze,
+				UnitName:         unitName,
+				AssetName:        name,
+				URL:              url,
+				MetadataHash:     metadataHash,
+				Manager:          manager,
+				Reserve:          reserve,
+				Freeze:           freeze,
+				Clawback:         clawback,
 			}
 		}
 	}
@@ -288,8 +294,9 @@ func AccountToAccountData(a *model.Account) (basics.AccountData, error) {
 		assets = make(map[basics.AssetIndex]basics.AssetHolding, len(*a.Assets))
 		for _, h := range *a.Assets {
 			assets[basics.AssetIndex(h.AssetID)] = basics.AssetHolding{
-				Amount: h.Amount,
-				Frozen: h.IsFrozen,
+				Amount:           h.Amount,
+				Frozen:           h.IsFrozen,
+				LastFreezeChange: h.LastFreezeChange,
 			}
 		}
 	}
@@ -483,21 +490,23 @@ func AppLocalState(state basics.AppLocalState, appIdx basics.AppIndex) model.App
 // AssetParamsToAsset converts basics.AssetParams to model.Asset
 func AssetParamsToAsset(creator string, idx basics.AssetIndex, params *basics.AssetParams) model.Asset {
 	frozen := params.DefaultFrozen
+	lastGlobalFreeze := params.LastGlobalFreeze
 	assetParams := model.AssetParams{
-		Creator:       creator,
-		Total:         params.Total,
-		Decimals:      uint64(params.Decimals),
-		DefaultFrozen: &frozen,
-		Name:          omitEmpty(printableUTF8OrEmpty(params.AssetName)),
-		NameB64:       sliceOrNil([]byte(params.AssetName)),
-		UnitName:      omitEmpty(printableUTF8OrEmpty(params.UnitName)),
-		UnitNameB64:   sliceOrNil([]byte(params.UnitName)),
-		Url:           omitEmpty(printableUTF8OrEmpty(params.URL)),
-		UrlB64:        sliceOrNil([]byte(params.URL)),
-		Clawback:      addrOrNil(params.Clawback),
-		Freeze:        addrOrNil(params.Freeze),
-		Manager:       addrOrNil(params.Manager),
-		Reserve:       addrOrNil(params.Reserve),
+		Creator:          creator,
+		Total:            params.Total,
+		Decimals:         uint64(params.Decimals),
+		DefaultFrozen:    &frozen,
+		LastGlobalFreeze: &lastGlobalFreeze,
+		Name:             omitEmpty(printableUTF8OrEmpty(params.AssetName)),
+		NameB64:          sliceOrNil([]byte(params.AssetName)),
+		UnitName:         omitEmpty(printableUTF8OrEmpty(params.UnitName)),
+		UnitNameB64:      sliceOrNil([]byte(params.UnitName)),
+		Url:              omitEmpty(printableUTF8OrEmpty(params.URL)),
+		UrlB64:           sliceOrNil([]byte(params.URL)),
+		Clawback:         addrOrNil(params.Clawback),
+		Freeze:           addrOrNil(params.Freeze),
+		Manager:          addrOrNil(params.Manager),
+		Reserve:          addrOrNil(params.Reserve),
 	}
 	if params.MetadataHash != ([32]byte{}) {
 		metadataHash := slices.Clone(params.MetadataHash[:])