Trophies for studios

import { SuiGrpcClient } from "@mysten/sui/grpc";
import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
import { Transaction } from "@mysten/sui/transactions";

const P = "0x...";        // rare_trophies package id
const GAME = "0x...";     // your shared Game
const GAME_CAP = "0x..."; // your GameCap

const client = new SuiGrpcClient({ network: "mainnet", baseUrl: "https://fullnode.mainnet.sui.io:443" });
const studio = Ed25519Keypair.fromSecretKey(process.env.STUDIO_KEY!); // the address that holds the GameCap

const BRONZE = 0, SILVER = 1, GOLD = 2;
const trophies = [
  { key: "first_win", name: "First Win", description: "Win your first match.", image: "https://mygame.example/t/first-win.png", tier: BRONZE },
  { key: "ten_wins", name: "Regular", description: "Win ten matches.", image: "https://mygame.example/t/ten-wins.png", tier: SILVER },
  { key: "boss", name: "Giant Slayer", description: "Beat the final boss.", image: "https://mygame.example/t/boss.png", tier: GOLD },
];

const tx = new Transaction();
const cap = tx.object(GAME_CAP);
const game = tx.object(GAME);
for (const t of trophies) {
  tx.moveCall({
    target: `${P}::game::add_trophy`,
    arguments: [cap, game, tx.pure.string(t.key), tx.pure.string(t.name), tx.pure.string(t.description), tx.pure.string(t.image), tx.pure.u8(t.tier), tx.pure.bool(false)],
  });
}
// A new game's ids start at 0, so the set is [0, 1, 2].
tx.moveCall({
  target: `${P}::game::set_platinum`,
  arguments: [cap, game, tx.pure.string("platinum"), tx.pure.string("Completionist"), tx.pure.string("Earn every trophy."), tx.pure.string("https://mygame.example/t/platinum.png"), tx.pure.vector("u64", [0, 1, 2])],
});

const res = await client.signAndExecuteTransaction({ transaction: tx, signer: studio });
const done = res.Transaction ?? res.FailedTransaction;
if (!done.status.success) throw new Error(JSON.stringify(done.status.error));
console.log("defined", done.digest);

P::game::mint(cap: &GameCap, reg: &Registry, game: &mut Game, profile: &mut Profile, trophy_id: u64, clock: &Clock): ID

p = P::profile::create(REG, player)     // EProfileExists if one exists
P::game::mint(cap, REG, G, p, trophy_id, 0x6)
P::profile::share(p)

import { bcs } from "@mysten/sui/bcs";
import { SuiGrpcClient } from "@mysten/sui/grpc";
import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
import { Transaction } from "@mysten/sui/transactions";
import { deriveDynamicFieldID, normalizeSuiAddress } from "@mysten/sui/utils";

const P = "0x...";        // rare_trophies package id
const REG = "0x...";      // shared Registry
const GAME = "0x...";     // your shared Game
const GAME_CAP = "0x..."; // your GameCap

const client = new SuiGrpcClient({ network: "mainnet", baseUrl: "https://fullnode.mainnet.sui.io:443" });
const studio = Ed25519Keypair.fromSecretKey(process.env.STUDIO_KEY!);

const TABLE = bcs.struct("Table", { id: bcs.Address, size: bcs.u64() });
const REGISTRY = bcs.struct("Registry", {
  id: bcs.Address,
  version: bcs.u64(),
  paused: bcs.bool(),
  issuer_key: bcs.vector(bcs.u8()),
  games: TABLE,
  profiles: TABLE,
});
const PROFILE_FIELD = bcs.struct("Field", { id: bcs.Address, name: bcs.Address, value: bcs.Address });

async function content(id: string): Promise<Uint8Array | null> {
  try {
    const { object } = await client.core.getObject({ objectId: id, include: { content: true } });
    return object.content ?? null;
  } catch {
    return null;
  }
}

/** The player's shared Profile id, or null before their first trophy. */
async function profileOf(player: string): Promise<string | null> {
  const reg = REGISTRY.parse((await content(REG))!);
  const fieldId = deriveDynamicFieldID(reg.profiles.id, "address", bcs.Address.serialize(player).toBytes());
  const field = await content(fieldId);
  return field ? PROFILE_FIELD.parse(field).value : null;
}

export async function unlock(playerAddress: string, trophyId: number) {
  const player = normalizeSuiAddress(playerAddress);
  const profileId = await profileOf(player);

  const tx = new Transaction();
  const reg = tx.object(REG);
  const profile = profileId
    ? tx.object(profileId)
    : tx.moveCall({ target: `${P}::profile::create`, arguments: [reg, tx.pure.address(player)] });
  tx.moveCall({
    target: `${P}::game::mint`,
    arguments: [tx.object(GAME_CAP), reg, tx.object(GAME), profile, tx.pure.u64(trophyId), tx.object.clock()],
  });
  if (!profileId) tx.moveCall({ target: `${P}::profile::share`, arguments: [profile] });

  const res = await client.signAndExecuteTransaction({ transaction: tx, signer: studio });
  const done = res.Transaction ?? res.FailedTransaction;
  if (!done.status.success) throw new Error(JSON.stringify(done.status.error));
  return done.digest;
}

module my_game::rewards;

use rare_trophies::game::{Self, Game, GameCap};
use rare_trophies::profile::Profile;
use rare_trophies::registry::Registry;
use sui::clock::Clock;

const ENotYourProfile: u64 = 1;
const ENotBeaten: u64 = 2;

/// Holds the studio's GameCap so the game's own rules decide who gets a trophy.
public struct TrophyVault has key {
    id: UID,
    cap: GameCap,
    boss_trophy: u64,
}

/// A player's run, written by the rest of your game.
public struct Run has key {
    id: UID,
    player: address,
    boss_beaten: bool,
}

public fun create_vault(cap: GameCap, boss_trophy: u64, ctx: &mut TxContext) {
    transfer::share_object(TrophyVault { id: object::new(ctx), cap, boss_trophy });
}

/// The player claims the boss trophy once their run shows the boss beaten.
public fun claim_boss_trophy(
    vault: &TrophyVault,
    run: &Run,
    reg: &Registry,
    game: &mut Game,
    profile: &mut Profile,
    clock: &Clock,
    ctx: &mut TxContext,
): ID {
    assert!(profile.player() == ctx.sender() && run.player == ctx.sender(), ENotYourProfile);
    assert!(run.boss_beaten, ENotBeaten);
    game::mint(&vault.cap, reg, game, profile, vault.boss_trophy, clock, ctx)
}

P::game::mint_attested(reg: &Registry, game: &mut Game, profile: &mut Profile, trophy_id: u64, nonce: u64, expires_ms: u64, signature: vector<u8>, clock: &Clock): ID

"RARE_TROPHY_V1" || registry id (32) || player (32) || game id (32) || trophy_id (u64 LE) || nonce (u64 LE) || expires_ms (u64 LE)

const DOMAIN = new TextEncoder().encode("RARE_TROPHY_V1");

function addressBytes(a: string): Uint8Array {
  const hex = a.toLowerCase().replace(/^0x/, "").padStart(64, "0");
  return Uint8Array.from({ length: 32 }, (_, i) => parseInt(hex.slice(i * 2, i * 2 + 2), 16));
}

function u64le(v: bigint): Uint8Array {
  const out = new Uint8Array(8);
  for (let i = 0; i < 8; i++) out[i] = Number((v >> BigInt(8 * i)) & 0xffn);
  return out;
}

export function attestationMessage(a: { registry: string; player: string; game: string; trophyId: bigint; nonce: bigint; expiresMs: bigint }): Uint8Array {
  const parts = [DOMAIN, addressBytes(a.registry), addressBytes(a.player), addressBytes(a.game), u64le(a.trophyId), u64le(a.nonce), u64le(a.expiresMs)];
  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
  let o = 0;
  for (const p of parts) {
    out.set(p, o);
    o += p.length;
  }
  return out;
}

import { Transaction } from "@mysten/sui/transactions";

type Attestation = { trophyId: bigint; nonce: bigint; expiresMs: bigint; signature: Uint8Array };

export function buildClaimTx(o: { pkg: string; registry: string; game: string; player: string; profileId: string | null; attestations: Attestation[] }) {
  const tx = new Transaction();
  tx.setSender(o.player);
  const reg = tx.object(o.registry);
  const game = tx.object(o.game);
  const profile = o.profileId
    ? tx.object(o.profileId)
    : tx.moveCall({ target: `${o.pkg}::profile::create`, arguments: [reg, tx.pure.address(o.player)] });
  for (const a of o.attestations) {
    tx.moveCall({
      target: `${o.pkg}::game::mint_attested`,
      arguments: [reg, game, profile, tx.pure.u64(a.trophyId), tx.pure.u64(a.nonce), tx.pure.u64(a.expiresMs), tx.pure.vector("u8", Array.from(a.signature)), tx.object.clock()],
    });
  }
  if (!o.profileId) tx.moveCall({ target: `${o.pkg}::profile::share`, arguments: [profile] });
  return tx;
}