API: Experimental full assets for account endpoint.

cmd/goal/account.go

@@ -71,6 +71,9 @@
 	listAccountInfo    bool
 	onlyShowAssetIds   bool
 	partKeyIDToDelete  string
+
+	next  string
+	limit uint64
 )
 
 func init() {
@@ -79,6 +82,7 @@
 	accountCmd.AddCommand(listCmd)
 	accountCmd.AddCommand(renameCmd)
 	accountCmd.AddCommand(infoCmd)
+	accountCmd.AddCommand(assetDetailsCmd)
 	accountCmd.AddCommand(balanceCmd)
 	accountCmd.AddCommand(rewardsCmd)
 	accountCmd.AddCommand(changeOnlineCmd)
@@ -136,6 +140,12 @@
 	infoCmd.MarkFlagRequired("address")
 	infoCmd.Flags().BoolVar(&onlyShowAssetIds, "onlyShowAssetIds", false, "Only show ASA IDs and not pull asset metadata")
 
+	// Asset details flags
+	assetDetailsCmd.Flags().StringVarP(&accountAddress, "address", "a", "", "Account address to look up (required)")
+	assetDetailsCmd.MarkFlagRequired("address")
+	assetDetailsCmd.Flags().StringVarP(&next, "next", "n", "", "The next asset index to use for pagination")
+	assetDetailsCmd.Flags().Uint64VarP(&limit, "limit", "l", 0, "The maximum number of assets to return")
+
 	// Balance flags
 	balanceCmd.Flags().StringVarP(&accountAddress, "address", "a", "", "Account address to retrieve balance (required)")
 	balanceCmd.MarkFlagRequired("address")
@@ -539,6 +549,33 @@
 	},
 }
 
+var assetDetailsCmd = &cobra.Command{
+	Use:   "assetdetails",
+	Short: "Retrieve information about the assets belonging to the specified account inclusive of asset metadata",
+	Long:  `Retrieve information about the assets the specified account has created or opted into, inclusive of asset metadata.`,
+	Args:  validateNoPosArgsFn,
+	Run: func(cmd *cobra.Command, args []string) {
+		dataDir := datadir.EnsureSingleDataDir()
+		client := ensureAlgodClient(dataDir)
+
+		var nextPtr *string
+		var limitPtr *uint64
+		if next != "" {
+			nextPtr = &next
+		}
+		if limit != 0 {
+			limitPtr = &limit
+		}
+		response, err := client.AccountAssetsInformation(accountAddress, nextPtr, limitPtr)
+
+		if err != nil {
+			reportErrorf(errorRequestFail, err)
+		}
+
+		printAccountAssetsInformation(accountAddress, response)
+
+	},
+}
 var infoCmd = &cobra.Command{
 	Use:   "info",
 	Short: "Retrieve information about the assets and applications belonging to the specified account",
@@ -731,6 +768,48 @@
 	return hasError
 }
 
+func printAccountAssetsInformation(address string, response model.AccountAssetsInformationResponse) {
+	fmt.Printf("Account: %s\n", address)
+	fmt.Printf("Round: %d\n", response.Round)
+	if response.NextToken != nil {
+		fmt.Printf("NextToken (to retrieve more account assets): %s\n", *response.NextToken)
+	}
+	fmt.Printf("Assets:\n")
+	for _, asset := range *response.AssetHoldings {
+		fmt.Printf("  Asset ID: %d\n", asset.AssetHolding.AssetID)
+
+		if asset.AssetParams != nil {
+			amount := assetDecimalsFmt(asset.AssetHolding.Amount, asset.AssetParams.Decimals)
+			fmt.Printf("    Amount: %s\n", amount)
+			fmt.Printf("    IsFrozen: %t\n", asset.AssetHolding.IsFrozen)
+			fmt.Printf("  Asset Params:\n")
+			fmt.Printf("    Creator: %s\n", asset.AssetParams.Creator)
+
+			name := "<unnamed>"
+			if asset.AssetParams.Name != nil {
+				_, name = unicodePrintable(*asset.AssetParams.Name)
+			}
+			fmt.Printf("    Name: %s\n", name)
+
+			units := "units"
+			if asset.AssetParams.UnitName != nil {
+				_, units = unicodePrintable(*asset.AssetParams.UnitName)
+			}
+			fmt.Printf("    Units: %s\n", units)
+			fmt.Printf("    Total: %d\n", asset.AssetParams.Total)
+			fmt.Printf("    Decimals: %d\n", asset.AssetParams.Decimals)
+			safeURL := ""
+			if asset.AssetParams.Url != nil {
+				_, safeURL = unicodePrintable(*asset.AssetParams.Url)
+			}
+			fmt.Printf("    URL: %s\n", safeURL)
+		} else {
+			fmt.Printf("    Amount (without formatting): %d\n", asset.AssetHolding.Amount)
+			fmt.Printf("    IsFrozen: %t\n", asset.AssetHolding.IsFrozen)
+		}
+	}
+}
+
 var balanceCmd = &cobra.Command{
 	Use:   "balance",
 	Short: "Retrieve the balances for the specified account",

daemon/algod/api/algod.oas2.json

@@ -344,6 +344,73 @@
         }
       ]
     },
+    "/v2/accounts/{address}/assets": {
+      "get": {
+        "description": "Lookup an account's asset holdings.",
+        "tags": [
+          "public",
+          "experimental"
+        ],
+        "produces": [
+          "application/json"
+        ],
+        "schemes": [
+          "http"
+        ],
+        "summary": "Get a list of assets held by an account, inclusive of asset params.",
+        "operationId": "AccountAssetsInformation",
+        "parameters": [
+          {
+            "pattern": "[A-Z0-9]{58}",
+            "type": "string",
+            "description": "An account public key",
+            "name": "address",
+            "in": "path",
+            "required": true
+          },
+          {
+            "$ref": "#/parameters/limit"
+          },
+          {
+            "$ref": "#/parameters/next"
+          }
+        ],
+        "responses": {
+          "200": {
+            "$ref": "#/responses/AccountAssetsInformationResponse"
+          },
+          "400": {
+            "description": "Malformed address",
+            "schema": {
+              "$ref": "#/definitions/ErrorResponse"
+            }
+          },
+          "401": {
+            "description": "Invalid API Token",
+            "schema": {
+              "$ref": "#/definitions/ErrorResponse"
+            }
+          },
+          "500": {
+            "description": "Internal Error",
+            "schema": {
+              "$ref": "#/definitions/ErrorResponse"
+            }
+          },
+          "default": {
+            "description": "Unknown Error"
+          }
+        }
+      },
+      "parameters": [
+        {
+          "type": "string",
+          "name": "address",
+          "in": "path",
+          "required": true
+        }
+      ]
+    },
     "/v2/accounts/{address}/applications/{application-id}": {
       "get": {
         "description": "Given a specific account public key and application ID, this call returns the account's application local state and global state (AppLocalState and AppParams, if either exists). Global state will only be returned if the provided address is the application's creator.",
@@ -3087,6 +3154,23 @@
         }
       }
     },
+    "AccountAssetHolding": {
+      "description": "AccountAssetHolding describes the account's asset holding and asset parameters (if either exist) for a specific asset ID.",
+      "type": "object",
+      "required": [
+        "asset-holding"
+      ],
+      "properties": {
+        "asset-holding": {
+          "description": "\\[asset\\] Details about the asset held by this account.\n\nThe raw account uses `AssetHolding` for this type.",
+          "$ref": "#/definitions/AssetHolding"
+        },
+        "asset-params": {
+          "description": "\\[apar\\] parameters of the asset held by this account.\n\nThe raw account uses `AssetParams` for this type.",
+          "$ref": "#/definitions/AssetParams"
+        }
+      }
+    },
     "AccountParticipation": {
       "description": "AccountParticipation describes the parameters used by this account in consensus protocol.",
       "type": "object",
@@ -4818,6 +4902,31 @@
         }
       }
     },
+    "AccountAssetsInformationResponse": {
+      "description": "AccountAssetsInformationResponse contains a list of assets held by an account.",
+      "schema": {
+        "type": "object",
+        "required": [
+          "round"
+        ],
+        "properties": {
+          "round": {
+            "description": "The round for which this information is relevant.",
+            "type": "integer"
+          },
+          "next-token": {
+            "description": "Used for pagination, when making another request provide this token with the next parameter.",
+            "type": "string"
+          },
+          "asset-holdings": {
+            "type": "array",
+            "items": {
+              "$ref": "#/definitions/AccountAssetHolding"
+            }
+          }
+        }
+      }
+    },
     "AccountApplicationResponse": {
       "description": "AccountApplicationResponse describes the account's application local state and global state (AppLocalState and AppParams, if either exists) for a specific application ID. Global state will only be returned if the provided address is the application's creator.",
       "schema": {