Fast Break - Address Mapping (#242)

* added helper mapping for third parties & oracle

* assets.go

contracts/FastBreak.cdc

@@ -123,6 +123,7 @@ pub contract FastBreak: NonFungibleToken {
     access(self) let fastBreakGameByID:     {String: FastBreakGame}
     access(self) let fastBreakPlayerByID:   {UInt64: PlayerData}
     access(self) let playerAccountMapping:  {UInt64: Address}
+    access(self) let accountPlayerMapping:  {Address: UInt64}
 
     /// A top-level Fast Break Run, the container for Fast Break Games
     /// A Fast Break Run contains many Fast Break games & is a mini-season.
@@ -388,6 +389,7 @@ pub contract FastBreak: NonFungibleToken {
             /// Update player address mapping
             if let ownerAddress = self.owner?.address {
                 FastBreak.playerAccountMapping[self.id] = ownerAddress
+                FastBreak.accountPlayerMapping[ownerAddress] = self.id
             }
 
             /// Validate Top Shots
@@ -455,6 +457,12 @@ pub contract FastBreak: NonFungibleToken {
         }
     }
 
+    /// Get a Fast Break Run by Id
+    ///
+    pub fun getPlayerIdByAccount(accountAddress: Address): UInt64 {
+        return FastBreak.accountPlayerMapping[accountAddress]!
+    }
+
     /// Validate Fast Break Submission topShots
     ///
     pub fun validatePlaySubmission(fastBreakGame: FastBreakGame, topShots: [UInt64]): Bool {
@@ -797,6 +805,7 @@ pub contract FastBreak: NonFungibleToken {
         self.fastBreakGameByID = {}
         self.fastBreakPlayerByID = {}
         self.playerAccountMapping = {}
+        self.accountPlayerMapping = {}
 
         let oracle <- create FastBreakDaemon()
         self.account.save(<-oracle, to: self.OracleStoragePath)

lib/go/test/fast_break_test.go

@@ -417,6 +417,7 @@ func TestFastBreak(t *testing.T) {
 		arg1Err := tx.AddArgument(cdcState)
 		assert.Nil(t, arg1Err)
 
+		// winner
 		arg2Err := tx.AddArgument(cadence.NewUInt64(playerId))
 		assert.Nil(t, arg2Err)
 
@@ -435,7 +436,7 @@ func TestFastBreak(t *testing.T) {
 		arg0Err := tx.AddArgument(cdcId)
 		assert.Nil(t, arg0Err)
 
-		arg1Err := tx.AddArgument(cadence.NewUInt64(playerId))
+		arg1Err := tx.AddArgument(cadence.NewAddress(jerAddress))
 		assert.Nil(t, arg1Err)
 
 		arg2Err := tx.AddArgument(cadence.NewUInt64(100))
@@ -454,7 +455,7 @@ func TestFastBreak(t *testing.T) {
 			t,
 			b,
 			templates.GenerateGetPlayerScoreScript(env),
-			[][]byte{jsoncdc.MustEncode(cdcId), jsoncdc.MustEncode(cadence.UInt64(playerId))},
+			[][]byte{jsoncdc.MustEncode(cdcId), jsoncdc.MustEncode(cadence.NewAddress(jerAddress))},
 		)
 		assert.Equal(t, cadence.NewUInt64(100), result)
 	})

transactions/fastbreak/oracle/score_fast_break_submission.cdc

@@ -1,19 +1,22 @@
 import FastBreak from 0xFASTBREAKADDRESS
 
-transaction(fastBreakGameID: String, playerId: UInt64, points: UInt64, win: Bool) {
+transaction(fastBreakGameID: String, playerAddress: Address, points: UInt64, win: Bool) {
 
     let oracleRef: &FastBreak.FastBreakDaemon
+    let playerId: UInt64
 
     prepare(acct: AuthAccount) {
         self.oracleRef = acct.borrow<&FastBreak.FastBreakDaemon>(from: FastBreak.OracleStoragePath)
             ?? panic("could not borrow a reference to the oracle resource")
+
+        self.playerId = FastBreak.getPlayerIdByAccount(accountAddress: playerAddress)
     }
 
     execute {
 
         self.oracleRef.updateFastBreakScore(
             fastBreakGameID: fastBreakGameID,
-            playerId: playerId,
+            playerId: self.playerId,
             points: points,
             win: win
         )

transactions/fastbreak/scripts/get_player_score.cdc

@@ -1,6 +1,7 @@
 import FastBreak from 0xFASTBREAKADDRESS
 
-pub fun main(id: String, playerId: UInt64): UInt64 {
+pub fun main(id: String, playerAddress: Address): UInt64 {
+    let playerId = FastBreak.getPlayerIdByAccount(accountAddress: playerAddress)
     let fastBreak = FastBreak.getFastBreakGame(id: id)!
     let submission : FastBreak.FastBreakSubmission = fastBreak.getFastBreakSubmissionByPlayerId(playerId: playerId)!