Decks Onchain

packages/contracts/src/DeckAirdrop.sol

@@ -61,6 +61,6 @@ contract DeckAirdrop is Ownable {
             cards[i] = first + i;
         }
 
-        inventory.addDeck(msg.sender, Inventory.Deck(cards));
+        inventory.addDeck(msg.sender, Inventory.Deck("Starter Deck", cards));
     }
 }

packages/contracts/src/Game.sol

@@ -527,6 +527,8 @@ contract Game {
             revert Errors.NotAllowedToJoin();
         }
 
+        inventory.checkDeck(msg.sender, deckID);
+
         // Update gdata.players, but not gdata.livePlayers, which is used to determine if the
         // game is ready to start (all players have joined & drawn their initial hand).
         gdata.players.push(msg.sender);
@@ -547,7 +549,7 @@ contract Game {
         uint256[] storage cards = gdata.cards;
         pdata.deckStart = uint8(cards.length);
         inventory.checkDeck(msg.sender, deckID);
-        uint256[] memory deck = inventory.getDeck(msg.sender, deckID);
+        uint256[] memory deck = inventory.getDeckCards(msg.sender, deckID);
 
         for (uint256 i = 0; i < deck.length; i++) {
             cards.push(deck[i]);

packages/contracts/src/Inventory.sol

@@ -78,6 +78,7 @@ contract Inventory is Ownable {
     // We need a struct because Solidity is unable to copy an array from memory to storage
     // directly, but can do it when the array is embedded in a struct.
     struct Deck {
+        string name;
         uint256[] cards;
     }
 
@@ -188,6 +189,9 @@ contract Inventory is Ownable {
     // ---------------------------------------------------------------------------------------------
 
     function checkDeckSize(Deck storage deck) internal view {
+        if (deck.cards.length < MIN_DECK_SIZE) {
+            revert SmallDeckEnergy();
+        }
         if (deck.cards.length > MAX_DECK_SIZE) {
             revert BigDeckEnergy();
         }
@@ -215,8 +219,7 @@ contract Inventory is Ownable {
             revert OutOfDeckIDs();
         }
         deckID = uint8(longDeckID);
-        decks[player].push();
-        _addDeck(player, deckID, deck);
+        decks[player].push(deck);
         emit DeckAdded(player, deckID);
     }
 
@@ -243,7 +246,7 @@ contract Inventory is Ownable {
         exists(player, deckID)
         notInGame(player)
     {
-        _addDeck(player, deckID, deck);
+        decks[player][deckID] = deck;
         emit DeckRemoved(player, deckID);
         emit DeckAdded(player, deckID);
     }
@@ -328,7 +331,7 @@ contract Inventory is Ownable {
     // ---------------------------------------------------------------------------------------------
 
     // Returns the list of cards in the given deck of the given player.
-    function getDeck(address player, uint8 deckID)
+    function getDeckCards(address player, uint8 deckID)
         external
         view
         exists(player, deckID)
@@ -339,13 +342,41 @@ contract Inventory is Ownable {
 
     // ---------------------------------------------------------------------------------------------
 
+    // Returns the list of cards in the given deck of the given player.
+    function getDeck(address player, uint8 deckID) external view exists(player, deckID) returns (Deck memory) {
+        return decks[player][deckID];
+    }
+
+    // ---------------------------------------------------------------------------------------------
+
+    // Returns the decks of a given player.
+    function getAllDecks(address player) external view returns (Deck[] memory) {
+        return decks[player];
+    }
+
+    // ---------------------------------------------------------------------------------------------
+
     // Returns the number of deck a player has created.
     function getNumDecks(address player) external view returns (uint8) {
         return uint8(decks[player].length);
     }
 
     // ---------------------------------------------------------------------------------------------
 
+    // Returns the names of all decks for a given player.
+    function getDeckNames(address player) external view returns (string[] memory) {
+        uint256 deckCount = decks[player].length;
+        string[] memory deckNames = new string[](deckCount);
+
+        for (uint256 i = 0; i < deckCount; i++) {
+            deckNames[i] = decks[player][i].name;
+        }
+
+        return deckNames;
+    }
+
+    // ---------------------------------------------------------------------------------------------
+
     function getCardTypes(uint256[] memory cardIDArr) public view returns (uint256[] memory) {
         uint256 len = cardIDArr.length;
         uint256[] memory cardTypeArr = new uint256[](len);

packages/contracts/src/test/Integration.t.sol

@@ -71,8 +71,8 @@ contract Integration is Test {
         game.createGame(2);
 
         // IDs don't start at 1 because the deploy script currently airdrops some addresses, might change.
-        inventory.getDeck(player2, 0); // player1 has card id of 49-72 inclusive
-        inventory.getDeck(player2, 0); // player2 has card id of 73-96 inclusive
+        inventory.getDeckCards(player2, 0); // player1 has card id of 49-72 inclusive
+        inventory.getDeckCards(player2, 0); // player2 has card id of 73-96 inclusive
 
         vm.startPrank(player1);
         game.joinGame(gameID, DECK_ID, SALT_HASH, JOIN_DATA);

packages/contracts/src/test/Inventory.t.sol

@@ -33,7 +33,7 @@ contract InventoryTest is Test {
     // expect revert if player's deck contains a card with more than `MAX_CARD_COPY` copies.
     function testCheckDeckExceedsMaxCopy() public {
         uint8 deckId = 0;
-        uint256 randomCard = inventory.getDeck(player1, deckId)[2];
+        uint256 randomCard = inventory.getDeckCards(player1, deckId)[2];
 
         // increase card `randomCard` copies to 4
         vm.startPrank(player1);

packages/webapp/src/actions/getDeck.ts

@@ -0,0 +1,158 @@
+import { defaultErrorHandling } from "src/actions/errors"
+import { contractWriteThrowing } from "src/actions/libContractWrite"
+import { Address } from "src/chain"
+import { deployment } from "src/deployment"
+import { inventoryABI } from "src/generated"
+
+// =================================================================================================
+
+export type GetDeckArgs = {
+    playerAddress: Address
+    onSuccess: () => void
+}
+
+export type GetDeckAtArgs = {
+    playerAddress: Address
+    onSuccess: () => void
+    index: number
+}
+
+// -------------------------------------------------------------------------------------------------
+
+/**
+ * Fetches all decks of the given player by sending the `getAllDecks` transaction.
+ *
+ * Returns `true` iff the transaction is successful.
+ */
+export async function getAllDecks(args: GetDeckArgs): Promise<any> {
+    try {
+        return await getAllDecksImpl(args)
+    } catch (err) {
+        defaultErrorHandling("getAllDecks", err)
+        return false
+    }
+}
+
+/**
+ * Fetches the deck of the given player of a given ID by sending the `getDeck` transaction.
+ *
+ * Returns `true` iff the transaction is successful.
+ */
+export async function getDeck(args: GetDeckAtArgs): Promise<any> {
+    try {
+        return await getDeckImpl(args)
+    } catch (err) {
+        defaultErrorHandling("getDeck", err)
+        return false
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+
+/**
+ * Fetches deck count of the given player by sending the `getNumDecks` transaction.
+ *
+ * Returns `true` iff the transaction is successful.
+ */
+export async function getNumDecks(args: GetDeckArgs): Promise<any> {
+    try {
+        return await getNumDecksImpl(args)
+    } catch (err) {
+        defaultErrorHandling("getNumDecks", err)
+        return false
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+
+/**
+ * Fetches deck count of the given player by sending the `getNumDecks` transaction.
+ *
+ * Returns `true` iff the transaction is successful.
+ */
+export async function getDeckNames(args: GetDeckArgs): Promise<any> {
+    try {
+        return await getDeckNamesImpl(args)
+    } catch (err) {
+        defaultErrorHandling("getDeckNames", err)
+        return false
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+
+async function getAllDecksImpl(args: GetDeckArgs): Promise<any> {
+    try {
+        const result = await contractWriteThrowing({
+            contract: deployment.Inventory,
+            abi: inventoryABI,
+            functionName: "getAllDecks",
+            args: [args.playerAddress],
+        })
+
+        args.onSuccess()
+        return result
+    } catch (error) {
+        console.error("Error fetching decks:", error)
+        return null
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+
+async function getDeckImpl(args: GetDeckAtArgs): Promise<any> {
+    try {
+        const result = await contractWriteThrowing({
+            contract: deployment.Inventory,
+            abi: inventoryABI,
+            functionName: "getDeck",
+            args: [args.playerAddress, args.index],
+        })
+
+        args.onSuccess()
+        return result
+    } catch (error) {
+        console.error("Error fetching deck:", error)
+        return null
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+
+async function getNumDecksImpl(args: GetDeckArgs): Promise<any> {
+    try {
+        const result = await contractWriteThrowing({
+            contract: deployment.Inventory,
+            abi: inventoryABI,
+            functionName: "getNumDecks",
+            args: [args.playerAddress],
+        })
+
+        args.onSuccess()
+        return result
+    } catch (error) {
+        console.error("Error fetching decks:", error)
+        return null
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+
+async function getDeckNamesImpl(args: GetDeckArgs): Promise<any> {
+    try {
+        const result = await contractWriteThrowing({
+            contract: deployment.Inventory,
+            abi: inventoryABI,
+            functionName: "getDeckNames",
+            args: [args.playerAddress],
+        })
+
+        args.onSuccess()
+        return result
+    } catch (error) {
+        console.error("Error fetching decks:", error)
+        return null
+    }
+}
+
+// =================================================================================================

packages/webapp/src/actions/setDeck.ts

@@ -0,0 +1,90 @@
+import { defaultErrorHandling } from "src/actions/errors"
+import { contractWriteThrowing } from "src/actions/libContractWrite"
+import { Address } from "src/chain"
+import { deployment } from "src/deployment"
+import { inventoryABI } from "src/generated"
+import { checkFresh, freshWrap } from "src/store/checkFresh"
+import { Deck } from "src/store/types"
+
+// =================================================================================================
+
+export type SaveArgs = {
+    deck: Deck
+    playerAddress: Address
+    onSuccess: () => void
+}
+
+export type ModifyArgs = {
+    deck: Deck
+    playerAddress: Address
+    index: number
+    onSuccess: () => void
+}
+
+// -------------------------------------------------------------------------------------------------
+
+/**
+ * Saves a deck created by the player by sending the `saveDeck` transaction.
+ *
+ * Returns `true` iff the transaction is successful.
+ */
+export async function save(args: SaveArgs): Promise<boolean> {
+    try {
+        return await saveImpl(args)
+    } catch (err) {
+        return defaultErrorHandling("save", err)
+    }
+}
+
+/**
+ * Modifies a deck owned by the player by sending the `modifyDeck` transaction.
+ *
+ * Returns `true` iff the transaction is successful.
+ */
+export async function modify(args: ModifyArgs): Promise<boolean> {
+    try {
+        return await modifyImpl(args)
+    } catch (err) {
+        return defaultErrorHandling("modify", err)
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+
+async function saveImpl(args: SaveArgs): Promise<boolean> {
+    const cardBigInts = args.deck.cards.map((card) => card.id)
+
+    checkFresh(
+        await freshWrap(
+            contractWriteThrowing({
+                contract: deployment.Inventory,
+                abi: inventoryABI,
+                functionName: "addDeck",
+                args: [args.playerAddress, { name: args.deck.name, cards: cardBigInts }],
+            })
+        )
+    )
+
+    args.onSuccess()
+    return true
+}
+
+async function modifyImpl(args: ModifyArgs): Promise<boolean> {
+    const cardBigInts = args.deck.cards.map((card) => card.id)
+    console.log("INDEX: " + args.index)
+    checkFresh(
+        await freshWrap(
+            contractWriteThrowing({
+                contract: deployment.Inventory,
+                abi: inventoryABI,
+                functionName: "replaceDeck",
+                args: [args.playerAddress, args.index, { name: args.deck.name, cards: cardBigInts }],
+            })
+        )
+    )
+
+    args.onSuccess()
+    return true
+}
+
+// =================================================================================================