create-dubhe 1.2.0-pre.98 → 2.0.0

package/templates/nextjs/sui-card-duel/packages/contracts/scripts/e2e-lobby.ts

@@ -0,0 +1,177 @@
+/**
+ * e2e-lobby.ts — Verify the client-side scene discovery code paths against a
+ * live indexer, using the same DubheGraphqlClient + lib/scenes.ts the Next.js
+ * lobby uses. Creates one pending duel invite and one open brawl room first,
+ * and leaves them on-chain so the lobby UI has data to render.
+ *
+ * Usage:
+ *   cd templates/nextjs/sui-card-duel/packages/contracts
+ *   pnpm tsx scripts/e2e-lobby.ts
+ */
+
+import {
+  Dubhe,
+  Transaction,
+  getFullnodeUrl,
+  Ed25519Keypair,
+  loadMetadata
+} from '@0xobelisk/sui-client';
+// Resolved from the client package, which owns the graphql-client dependency.
+import { createDubheGraphqlClient } from '../../client/node_modules/@0xobelisk/graphql-client';
+import {
+  fetchDuels,
+  fetchBrawls,
+  fetchDuelById,
+  fetchBrawlById,
+  fetchSceneType,
+  fetchArenaObjectId
+} from '../../client/src/app/lib/scenes';
+import { PackageId, DappHubId, DappStorageId, FrameworkPackageId } from './config.ts';
+
+const NETWORK = 'localnet' as const;
+const CLOCK = '0x6';
+
+async function send(dubhe: Dubhe, label: string, build: (tx: Transaction) => void) {
+  const tx = new Transaction();
+  build(tx);
+  const result = await dubhe.signAndSendTxn({ tx });
+  if ((result as any).effects?.status?.status !== 'success') {
+    throw new Error(`${label} failed: ${JSON.stringify((result as any).effects?.status)}`);
+  }
+  await dubhe.waitForTransaction(result.digest);
+  console.log(`  ✓ ${label}`);
+  return result as any;
+}
+
+async function onboard(metadata: any): Promise<{ dubhe: Dubhe; us: string }> {
+  const dubhe = new Dubhe({
+    networkType: NETWORK,
+    packageId: PackageId,
+    metadata,
+    secretKey: new Ed25519Keypair().getSecretKey(),
+    suiRpcUrl: getFullnodeUrl(NETWORK),
+    dappHubId: DappHubId,
+    dappStorageId: DappStorageId,
+    frameworkPackageId: FrameworkPackageId
+  });
+  await dubhe.requestFaucet(dubhe.getAddress(), NETWORK);
+  await new Promise((r) => setTimeout(r, 2000));
+  const result = await send(
+    dubhe,
+    `init_user_storage (${dubhe.getAddress().slice(0, 8)})`,
+    (tx) => {
+      tx.moveCall({
+        target: `${PackageId}::user_storage_init::init_user_storage`,
+        arguments: [tx.object(DappHubId), tx.object(DappStorageId)]
+      });
+    }
+  );
+  const us = (result.objectChanges ?? []).find(
+    (c: any) => c.type === 'created' && c.objectType?.endsWith('::dapp_service::UserStorage')
+  )?.objectId;
+  await send(dubhe, 'register', (tx) => {
+    tx.moveCall({
+      target: `${PackageId}::player_system::register`,
+      arguments: [tx.object(DappStorageId), tx.object(us)]
+    });
+  });
+  return { dubhe, us };
+}
+
+async function main() {
+  const metadata = await loadMetadata(NETWORK, PackageId);
+
+  // ── 1. Seed lobby data: a pending duel invite + an open brawl room ───────
+  console.log('[1] Seeding lobby data');
+  const host = await onboard(metadata);
+  const rival = await onboard(metadata);
+
+  await send(host.dubhe, 'create_duel (pending invite, stake 25)', (tx) => {
+    tx.moveCall({
+      target: `${PackageId}::duel_system::create_duel`,
+      arguments: [
+        tx.object(DappStorageId),
+        tx.object(host.us),
+        tx.pure.address(rival.dubhe.getAddress()),
+        tx.pure.u64(25n),
+        tx.object(CLOCK)
+      ]
+    });
+  });
+  await send(rival.dubhe, 'create_brawl (open room, fee 10, max 4)', (tx) => {
+    tx.moveCall({
+      target: `${PackageId}::brawl_system::create_brawl`,
+      arguments: [
+        tx.object(DappStorageId),
+        tx.object(rival.us),
+        tx.pure.u64(10n),
+        tx.pure.u64(4n),
+        tx.object(CLOCK)
+      ]
+    });
+  });
+
+  console.log('  waiting 8s for the indexer...');
+  await new Promise((r) => setTimeout(r, 8000));
+
+  // ── 2. Exercise the exact client lib against the live endpoint ───────────
+  console.log('\n[2] Client lib (lib/scenes.ts) against live GraphQL');
+  const graphqlClient = createDubheGraphqlClient({
+    endpoint: 'http://127.0.0.1:4000/graphql',
+    subscriptionEndpoint: 'ws://127.0.0.1:4000/graphql'
+  });
+
+  const duels = await fetchDuels(graphqlClient);
+  console.log(`  fetchDuels: ${duels.length} active duel(s)`);
+  const myDuel = duels.find((d) => d.challenger === host.dubhe.getAddress());
+  if (!myDuel) throw new Error('pending duel not returned by fetchDuels');
+  console.log(
+    `    challenger=${myDuel.challenger.slice(0, 8)} opponent=${myDuel.opponent.slice(
+      0,
+      8
+    )} stake=${myDuel.stake} state=${myDuel.state} gold=${myDuel.gold}`
+  );
+  if (myDuel.stake !== 25n || myDuel.state !== 0 || myDuel.gold !== 25n) {
+    throw new Error(`duel decoded incorrectly: ${JSON.stringify(myDuel, (_, v) => String(v))}`);
+  }
+
+  const brawls = await fetchBrawls(graphqlClient);
+  console.log(`  fetchBrawls: ${brawls.length} open room(s)`);
+  const myBrawl = brawls.find((b) => b.host === rival.dubhe.getAddress());
+  if (!myBrawl) throw new Error('open brawl not returned by fetchBrawls');
+  console.log(
+    `    host=${myBrawl.host.slice(0, 8)} fee=${myBrawl.entryFee} max=${
+      myBrawl.maxPlayers
+    } players=${myBrawl.players.length} state=${myBrawl.state}`
+  );
+  if (myBrawl.entryFee !== 10n || myBrawl.maxPlayers !== 4 || myBrawl.players.length !== 1) {
+    throw new Error(`brawl decoded incorrectly`);
+  }
+
+  const duelById = await fetchDuelById(graphqlClient, myDuel.sceneId);
+  if (!duelById || duelById.permitId !== myDuel.permitId) throw new Error('fetchDuelById failed');
+  console.log(`  fetchDuelById: ok (permit ${duelById.permitId.slice(0, 10)}…)`);
+
+  const brawlById = await fetchBrawlById(graphqlClient, myBrawl.sceneId);
+  if (!brawlById || brawlById.permitId !== myBrawl.permitId)
+    throw new Error('fetchBrawlById failed');
+  console.log(`  fetchBrawlById: ok (permit ${brawlById.permitId.slice(0, 10)}…)`);
+
+  const kind = await fetchSceneType(graphqlClient, myDuel.sceneId);
+  if (kind !== 'duel') throw new Error(`fetchSceneType expected 'duel', got ${kind}`);
+  console.log(`  fetchSceneType: ok ('duel')`);
+
+  const arenaId = await fetchArenaObjectId(graphqlClient);
+  if (!arenaId) throw new Error('fetchArenaObjectId failed');
+  console.log(`  fetchArenaObjectId: ok (${arenaId.slice(0, 10)}…)`);
+
+  console.log(
+    '\n✅ Lobby data paths verified! (duel invite + brawl room left on-chain for the UI)'
+  );
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/templates/nextjs/sui-card-duel/packages/contracts/scripts/e2e-market.ts

@@ -0,0 +1,219 @@
+/**
+ * e2e-market.ts — End-to-end marketplace flow on localnet (listable codegen).
+ *
+ * Usage:
+ *   cd templates/nextjs/sui-card-duel/packages/contracts
+ *   pnpm tsx scripts/e2e-market.ts
+ *
+ * Flow: onboarding x2 -> list_card (auto deck removal) -> buy_card with SUI
+ *       -> list_gold -> buy_gold -> verify via getMarketplaceListings.
+ */
+
+import {
+  Dubhe,
+  Transaction,
+  getFullnodeUrl,
+  Ed25519Keypair,
+  loadMetadata
+} from '@0xobelisk/sui-client';
+import { createDubheGraphqlClient } from '../../client/node_modules/@0xobelisk/graphql-client';
+import { PackageId, DappHubId, DappStorageId, FrameworkPackageId } from './config.ts';
+
+const NETWORK = 'localnet' as const;
+const GRAPHQL = 'http://127.0.0.1:4000/graphql';
+const CARD_PRICE = 1_000_000n; // 0.001 SUI in MIST
+const GOLD_AMOUNT = 100n;
+const GOLD_PRICE = 2_000_000n;
+
+async function gql(query: string): Promise<any> {
+  const res = await fetch(GRAPHQL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query })
+  });
+  const json = await res.json();
+  if (json.errors) throw new Error(JSON.stringify(json.errors));
+  return json.data;
+}
+
+async function send(dubhe: Dubhe, label: string, build: (tx: Transaction) => void) {
+  const tx = new Transaction();
+  build(tx);
+  const result = await dubhe.signAndSendTxn({ tx });
+  if ((result as any).effects?.status?.status !== 'success') {
+    throw new Error(`${label} failed: ${JSON.stringify((result as any).effects?.status)}`);
+  }
+  await dubhe.waitForTransaction(result.digest);
+  console.log(`  ✓ ${label}`);
+  return result as any;
+}
+
+async function onboard(metadata: any): Promise<{ dubhe: Dubhe; us: string; addr: string }> {
+  const dubhe = new Dubhe({
+    networkType: NETWORK,
+    packageId: PackageId,
+    metadata,
+    secretKey: new Ed25519Keypair().getSecretKey(),
+    suiRpcUrl: getFullnodeUrl(NETWORK),
+    dappHubId: DappHubId,
+    dappStorageId: DappStorageId,
+    frameworkPackageId: FrameworkPackageId
+  });
+  const addr = dubhe.getAddress();
+  await dubhe.requestFaucet(addr, NETWORK);
+  await new Promise((r) => setTimeout(r, 2000));
+  const result = await send(dubhe, `init_user_storage (${addr.slice(0, 8)})`, (tx) => {
+    tx.moveCall({
+      target: `${PackageId}::user_storage_init::init_user_storage`,
+      arguments: [tx.object(DappHubId), tx.object(DappStorageId)]
+    });
+  });
+  const us = (result.objectChanges ?? []).find(
+    (c: any) => c.type === 'created' && c.objectType?.endsWith('::dapp_service::UserStorage')
+  )?.objectId;
+  await send(dubhe, 'register', (tx) => {
+    tx.moveCall({
+      target: `${PackageId}::player_system::register`,
+      arguments: [tx.object(DappStorageId), tx.object(us)]
+    });
+  });
+  return { dubhe, us, addr };
+}
+
+async function main() {
+  const metadata = await loadMetadata(NETWORK, PackageId);
+  console.log('[1] Onboarding seller + buyer');
+  const seller = await onboard(metadata);
+  const buyer = await onboard(metadata);
+
+  // Card to sell: read the seller's deck from the indexer (5 starter cards).
+  let cardId = '';
+  for (let i = 0; i < 30 && !cardId; i++) {
+    const data = await gql(`{ decks { nodes { entityId cardIds } } }`);
+    const row = data.decks.nodes.find((n: any) => n.entityId === seller.addr);
+    let ids = row?.cardIds;
+    if (typeof ids === 'string') ids = JSON.parse(ids);
+    if (Array.isArray(ids) && ids.length === 5) cardId = String(ids[0]);
+    else await new Promise((r) => setTimeout(r, 2000));
+  }
+  if (!cardId) throw new Error('seller deck not indexed');
+
+  // ── 2. List a card + some gold ────────────────────────────────────────────
+  console.log('\n[2] Listing');
+  await send(seller.dubhe, 'list_card (price 0.001 SUI)', (tx) => {
+    tx.moveCall({
+      target: `${PackageId}::market_system::list_card`,
+      arguments: [
+        tx.object(DappStorageId),
+        tx.object(seller.us),
+        tx.pure.address(cardId),
+        tx.pure.u64(CARD_PRICE)
+      ]
+    });
+  });
+  await send(seller.dubhe, 'list_gold (100 gold, 0.002 SUI)', (tx) => {
+    tx.moveCall({
+      target: `${PackageId}::market_system::list_gold`,
+      arguments: [
+        tx.object(DappStorageId),
+        tx.object(seller.us),
+        tx.pure.u64(GOLD_AMOUNT),
+        tx.pure.u64(GOLD_PRICE)
+      ]
+    });
+  });
+
+  // ── 3. Discover listings the same way the market page does ───────────────
+  console.log('\n[3] getMarketplaceListings (client data path)');
+  const graphqlClient = createDubheGraphqlClient({ endpoint: GRAPHQL });
+  let cardListing: any = null;
+  let goldListing: any = null;
+  for (let i = 0; i < 30; i++) {
+    const result = await graphqlClient.getMarketplaceListings({ status: 'listed' });
+    const nodes = (result?.edges ?? []).map((e: any) => e.node);
+    cardListing = nodes.find((n: any) => n.recordType === 'card' && n.seller === seller.addr);
+    goldListing = nodes.find((n: any) => n.recordType === 'gold' && n.seller === seller.addr);
+    if (cardListing && goldListing) break;
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+  if (!cardListing || !goldListing) throw new Error('listings not indexed');
+  console.log(
+    `  card listing: id=${cardListing.listingId.slice(0, 10)}… price=${cardListing.price} dataRaw=${
+      cardListing.recordDataRaw
+    }`
+  );
+  console.log(
+    `  gold listing: id=${goldListing.listingId.slice(0, 10)}… price=${goldListing.price} dataRaw=${
+      goldListing.recordDataRaw
+    }`
+  );
+
+  // ── 4. Buyer purchases both ───────────────────────────────────────────────
+  console.log('\n[4] Buying');
+  await send(buyer.dubhe, 'buy_card', (tx) => {
+    const [payment] = tx.splitCoins(tx.gas, [tx.pure.u64(BigInt(cardListing.price))]);
+    tx.moveCall({
+      target: `${PackageId}::market_system::buy_card`,
+      arguments: [
+        tx.object(DappHubId),
+        tx.object(DappStorageId),
+        tx.object(cardListing.listingId),
+        tx.object(buyer.us),
+        payment
+      ]
+    });
+  });
+  await send(buyer.dubhe, 'buy_gold', (tx) => {
+    const [payment] = tx.splitCoins(tx.gas, [tx.pure.u64(BigInt(goldListing.price))]);
+    tx.moveCall({
+      target: `${PackageId}::market_system::buy_gold`,
+      arguments: [
+        tx.object(DappHubId),
+        tx.object(DappStorageId),
+        tx.object(goldListing.listingId),
+        tx.object(buyer.us),
+        payment
+      ]
+    });
+  });
+
+  // ── 5. Verify: buyer owns 6 cards and 600 gold; listings closed ──────────
+  console.log('\n[5] Verify');
+  let ok = false;
+  for (let i = 0; i < 30; i++) {
+    const data = await gql(
+      `{ cards { nodes { entityId cardId isDeleted } } golds { nodes { entityId amount } } }`
+    );
+    const buyerCards = data.cards.nodes.filter(
+      (n: any) => n.entityId === buyer.addr && !n.isDeleted
+    );
+    const buyerGold = BigInt(
+      data.golds.nodes.find((n: any) => n.entityId === buyer.addr)?.amount ?? 0
+    );
+    const ownsBought = buyerCards.some((n: any) => n.cardId === cardId);
+    if (buyerCards.length === 6 && ownsBought && buyerGold === 600n) {
+      console.log(`  buyer cards=${buyerCards.length} gold=${buyerGold} (bought card present)`);
+      ok = true;
+      break;
+    }
+    if (i === 29)
+      console.log(`  LAST: cards=${buyerCards.length} gold=${buyerGold} owns=${ownsBought}`);
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+  if (!ok) throw new Error('buyer state did not converge');
+
+  const after = await graphqlClient.getMarketplaceListings({ status: 'listed' });
+  const still = (after?.edges ?? [])
+    .map((e: any) => e.node)
+    .filter((n: any) => n.seller === seller.addr);
+  if (still.length !== 0) throw new Error('listings should be closed after purchase');
+  console.log('  listings closed: ok');
+
+  console.log('\n✅ E2E market flow passed!');
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});