Add revealed event (#129)

lib/go/events/revealed.go

@@ -0,0 +1,59 @@
+package events
+
+import (
+ "fmt"
+ "github.com/onflow/cadence"
+ jsoncdc "github.com/onflow/cadence/encoding/json"
+ "strings"
+)
+
+const (
+ // EventRevealed specifies that there is a Revealed Event on a PackNFT Contract located at the address
+ EventRevealed = "PackNFT.Revealed"
+)
+
+type RevealedEvent interface {
+ Id() uint64
+ Salt() string
+ NFTs() string
+}
+
+type revealedEvent cadence.Event
+
+var _ RevealedEvent = (*revealedEvent)(nil)
+
+func (evt revealedEvent) Id() uint64 {
+ return uint64(evt.Fields[0].(cadence.UInt64))
+}
+
+func (evt revealedEvent) Salt() string {
+ return string(evt.Fields[1].(cadence.String))
+}
+
+func (evt revealedEvent) NFTs() string {
+ return string(evt.Fields[2].(cadence.String))
+}
+
+func (evt revealedEvent) validate() error {
+ if evt.EventType.QualifiedIdentifier != EventRevealed {
+ return fmt.Errorf("error validating event: event is not a valid revealed event, expected type %s, got %s",
+ EventRevealed, evt.EventType.QualifiedIdentifier)
+ }
+ return nil
+}
+
+func parseNFTs(nft string) []string {
+ return strings.Split(nft, ",")
+}
+
+func DecodeRevealedEvent(b []byte) (RevealedEvent, error) {
+ value, err := jsoncdc.Decode(b)
+ if err != nil {
+ return nil, err
+ }
+ event := revealedEvent(value.(cadence.Event))
+ if err := event.validate(); err != nil {
+ return nil, fmt.Errorf("error decoding event: %w", err)
+ }
+ return event, nil
+}

lib/go/events/revealed_test.go

@@ -0,0 +1,60 @@
+package events
+
+import (
+ "fmt"
+ "github.com/stretchr/testify/require"
+ "testing"
+
+ "github.com/onflow/cadence"
+ jsoncdc "github.com/onflow/cadence/encoding/json"
+ "github.com/onflow/cadence/runtime/tests/utils"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestCadenceEvents_Reveal(t *testing.T) {
+ var (
+ packID = uint64(10)
+ salt = "salt"
+
+ momentID1 = uint64(1)
+ momentID2 = uint64(2)
+ momentID3 = uint64(3)
+ momentIDs = fmt.Sprintf(`%d,%d,%d`, momentID1, momentID2, momentID3)
+ )
+
+ revealedEventType := cadence.EventType{
+ Location: utils.TestLocation,
+ QualifiedIdentifier: "PackNFT.Revealed",
+ Fields: []cadence.Field{
+ {
+ Identifier: "id",
+ Type: cadence.UInt32Type{},
+ },
+ {
+ Identifier: "salt",
+ Type: cadence.StringType{},
+ },
+ {
+ Identifier: "nfts",
+ Type: cadence.StringType{},
+ },
+ },
+ }
+
+ revealedEvent := cadence.NewEvent([]cadence.Value{
+ cadence.NewUInt64(packID),
+ cadence.NewString(salt),
+ cadence.NewString(momentIDs),
+ }).WithType(&revealedEventType)
+
+ revealedPayload, err := jsoncdc.Encode(revealedEvent)
+ require.NoError(t, err, "failed to encode revealed cadence event")
+
+ decodedRevealedEventType, err := DecodeRevealedEvent(revealedPayload)
+ require.NoError(t, err, "failed to decode revealed cadence event")
+
+ assert.Equal(t, packID, decodedRevealedEventType.Id())
+ assert.Equal(t, salt, decodedRevealedEventType.Salt())
+ assert.Equal(t, momentIDs, decodedRevealedEventType.NFTs())
+
+}