Boxes: Support GetApplicationBoxes

client/v2/algod/algod.go

@@ -116,6 +116,10 @@ func (c *Client) GetApplicationByID(applicationId uint64) *GetApplicationByID {
 	return &GetApplicationByID{c: c, applicationId: applicationId}
 }
 
+func (c *Client) GetApplicationBoxes(applicationId uint64) *GetApplicationBoxes {
+	return &GetApplicationBoxes{c: c, applicationId: applicationId}
+}
+
 func (c *Client) GetApplicationBoxByName(applicationId uint64) *GetApplicationBoxByName {
 	return &GetApplicationBoxByName{c: c, applicationId: applicationId}
 }

client/v2/algod/getApplicationBoxes.go

@@ -0,0 +1,40 @@
+package algod
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/algorand/go-algorand-sdk/client/v2/common"
+	"github.com/algorand/go-algorand-sdk/client/v2/common/models"
+)
+
+// GetApplicationBoxesParams contains all of the query parameters for url serialization.
+type GetApplicationBoxesParams struct {
+
+	// Max max number of box names to return. If max is not set, or max == 0, returns
+	// all box-names.
+	Max uint64 `url:"max,omitempty"`
+}
+
+// GetApplicationBoxes given an application ID, it returns the box names of that
+// application. No particular ordering is guaranteed.
+type GetApplicationBoxes struct {
+	c *Client
+
+	applicationId uint64
+
+	p GetApplicationBoxesParams
+}
+
+// Max max number of box names to return. If max is not set, or max == 0, returns
+// all box-names.
+func (s *GetApplicationBoxes) Max(Max uint64) *GetApplicationBoxes {
+	s.p.Max = Max
+	return s
+}
+
+// Do performs the HTTP request
+func (s *GetApplicationBoxes) Do(ctx context.Context, headers ...*common.Header) (response models.BoxesResponse, err error) {
+	err = s.c.get(ctx, &response, fmt.Sprintf("/v2/applications/%s/boxes", common.EscapeParams(s.applicationId)...), s.p, headers)
+	return
+}

client/v2/common/models/box_descriptor.go

@@ -0,0 +1,7 @@
+package models
+
+// BoxDescriptor box descriptor describes a Box.
+type BoxDescriptor struct {
+	// Name base64 encoded box name
+	Name []byte `json:"name"`
+}

client/v2/common/models/boxes_response.go

@@ -0,0 +1,7 @@
+package models
+
+// BoxesResponse box names of an application
+type BoxesResponse struct {
+	// Boxes
+	Boxes []BoxDescriptor `json:"boxes"`
+}

encoding/box_query_encoding.go

@@ -23,6 +23,15 @@ func EncodeBoxForBoxQuery(b models.Box) (string, error) {
 	return EncodeBytesForBoxQuery(decoded), nil
 }
 
+func EncodeBoxDescriptorForBoxQuery(bd models.BoxDescriptor) (string, error) {
+	decoded, err := base64.StdEncoding.DecodeString(string(bd.Name))
+	if err != nil {
+		return "", err
+	}
+
+	return EncodeBytesForBoxQuery(decoded), nil
+}
+
 // EncodeBoxReferenceForBoxQuery provides a convenience method to string encode box names for use with Box search APIs (e.g. GetApplicationBoxByName).
 func EncodeBoxReferenceForBoxQuery(br types.BoxReference) string {
 	return EncodeBytesForBoxQuery(br.Name)

encoding/box_query_encoding_test.go

@@ -31,6 +31,15 @@ func TestEncode(t *testing.T) {
 		actual,
 	)
 
+	// Encode BoxDescriptor
+	bd := models.BoxDescriptor{Name: []byte(base64.StdEncoding.EncodeToString(e.source))}
+	actual, err = EncodeBoxDescriptorForBoxQuery(bd)
+	require.NoError(t, err)
+	require.Equal(t,
+		e.expectedEncoding,
+		actual,
+	)
+
 	// Encode BoxReference
 	require.Equal(t,
 		e.expectedEncoding,

test/algodclientv2_test.go

@@ -52,7 +52,19 @@ func AlgodClientV2Context(s *godog.Suite) {
 	s.Step(`^we make an Account Information call against account "([^"]*)" with exclude "([^"]*)"$`, weMakeAnAccountInformationCallAgainstAccountWithExclude)
 	s.Step(`^we make an Account Asset Information call against account "([^"]*)" assetID (\d+)$`, weMakeAnAccountAssetInformationCallAgainstAccountAssetID)
 	s.Step(`^we make an Account Application Information call against account "([^"]*)" applicationID (\d+)$`, weMakeAnAccountApplicationInformationCallAgainstAccountApplicationID)
-	s.Step(`^we make a GetApplicationBoxByName call for applicationID (\d+) with encoded box name "([^"]*)"$`, weMakeAGetApplicationBoxByNameCallForApplicationIDWithEncodedBoxName)
+	s.Step(`^we make a GetApplicationBoxByName call for applicationID (\d+) with encoded box name "([^"]*)"$`,
+		func(appId int, encodedBoxName string) error {
+			return withClient(func(c algod.Client) {
+				_, _ = c.GetApplicationBoxByName(uint64(appId)).Name(encodedBoxName).Do(context.Background())
+			})
+		})
+	s.Step(`^we make a GetApplicationBoxes call for applicationID (\d+) with max (\d+)$`,
+		func(appId int, max int) error {
+			return withClient(func(c algod.Client) {
+				_, _ = c.GetApplicationBoxes(uint64(appId)).Max(uint64(max)).Do(context.Background())
+			})
+		},
+	)
 	s.BeforeScenario(func(interface{}) {
 		globalErrForExamination = nil
 	})
@@ -257,12 +269,12 @@ func weMakeAnAccountApplicationInformationCallAgainstAccountApplicationID(accoun
 	return nil
 }
 
-func weMakeAGetApplicationBoxByNameCallForApplicationIDWithEncodedBoxName(appId int, encodedBoxName string) error {
-	algodClient, err := algod.MakeClient(mockServer.URL, "")
+func withClient(f func(client algod.Client)) error {
+	c, err := algod.MakeClient(mockServer.URL, "")
 	if err != nil {
 		return err
 	}
 
-	_, _ = algodClient.GetApplicationBoxByName(uint64(appId)).Name(encodedBoxName).Do(context.Background())
+	f(*c)
 	return nil
 }

test/applications_integration_test.go

@@ -7,6 +7,7 @@ import (
 	"encoding/base64"
 	"encoding/binary"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"reflect"
 	"regexp"
@@ -331,6 +332,12 @@ func parseAppArgs(appArgsString string) (appArgs [][]byte, err error) {
 				return nil, fmt.Errorf("failed to convert %s to bytes", arg)
 			}
 			resp[idx] = buf.Bytes()
+		case "b64":
+			d, err := (base64.StdEncoding.DecodeString(typeArg[1]))
+			if err != nil {
+				return nil, fmt.Errorf("failed to b64 decode arg = %s", arg)
+			}
+			resp[idx] = d
 		default:
 			return nil, fmt.Errorf("Applications doesn't currently support argument of type %s", typeArg[0])
 		}
@@ -914,6 +921,28 @@ func checkRandomElementResult(resultIndex int, input string) error {
 	return nil
 }
 
+// decodeBoxName parses the encoding scheme to return the corresponding byte representation
+func decodeBoxName(encodedBoxName string) ([]byte, error) {
+	split := strings.Split(encodedBoxName, ":")
+	if len(split) != 2 {
+		return nil, errors.New("encodedBoxName (" + encodedBoxName + ") does not match expected format")
+	}
+	encoding, encoded := split[0], split[1]
+	switch encoding {
+	case "str":
+		return []byte(encoded), nil
+	case "b64":
+		d, err := base64.StdEncoding.DecodeString(encoded)
+		if err != nil {
+			return nil, fmt.Errorf("failed to b64 decode arg = %s", encoded)
+		}
+
+		return d, nil
+	default:
+		return nil, errors.New("unsupported encoding = " + encoding)
+	}
+}
+
 func theContentsOfTheBoxWithNameShouldBeIfThereIsAnErrorItIs(encodedBoxName, boxContents, errStr string) error {
 
 	box, err := algodV2client.GetApplicationBoxByName(applicationId).Name(encodedBoxName).Do(context.Background())
@@ -962,5 +991,52 @@ func ApplicationsContext(s *godog.Suite) {
 	s.Step(`^The (\d+)th atomic result for randomInt\((\d+)\) proves correct$`, checkRandomIntResult)
 	s.Step(`^The (\d+)th atomic result for randElement\("([^"]*)"\) proves correct$`, checkRandomElementResult)
 
-	s.Step(`^the contents of the box with name "([^"]*)" should be "([^"]*)"\. If there is an error it is "([^"]*)"\.$`, theContentsOfTheBoxWithNameShouldBeIfThereIsAnErrorItIs)
+	s.Step(`^the contents of the box with name "([^"]*)" in the current application should be "([^"]*)"\. If there is an error it is "([^"]*)"\.$`, theContentsOfTheBoxWithNameShouldBeIfThereIsAnErrorItIs)
+
+	s.Step(`^the current application should have the following boxes "([^"]*)"\.$`,
+		func(encodedBoxesRaw string) error {
+			var expectedNames [][]byte
+			if len(encodedBoxesRaw) > 0 {
+				encodedBoxes := strings.Split(encodedBoxesRaw, ",")
+				expectedNames = make([][]byte, len(encodedBoxes))
+				for i, b := range encodedBoxes {
+					expected, err := decodeBoxName(b)
+					if err != nil {
+						return err
+					}
+					expectedNames[i] = expected
+				}
+			}
+
+			r, err := algodV2client.GetApplicationBoxes(applicationId).Do(context.Background())
+			if err != nil {
+				return err
+			}
+
+			actualNames := make([][]byte, len(r.Boxes))
+			for i, b := range r.Boxes {
+				actualNames[i] = b.Name
+			}
+
+			if len(expectedNames) != len(actualNames) {
+				return fmt.Errorf("expected and actual box names length do not match:  %v != %v", len(expectedNames), len(actualNames))
+			}
+
+			contains := func(elem []byte, xs [][]byte) bool {
+				for _, x := range xs {
+					if bytes.Equal(elem, x) {
+						return true
+					}
+				}
+				return false
+			}
+
+			for _, e := range expectedNames {
+				if !contains(e, actualNames) {
+					return fmt.Errorf("expected and actual box names do not match: %v != %v", expectedNames, actualNames)
+				}
+			}
+
+			return nil
+		})
 }