Asteria

Explore a web implementation to execute transactions for the Asteria challenge, built with the Tx3 toolkit.

CREATE SHIP

This is the first step in order to play the game.

This transaction creates a ShipState UTxO locking min ada, a ShipToken (minted in this tx) and an INITIAL_FUEL amount of fuel tokens (minted in this tx), specifying in the datum the initial pos_x and pos_y coordinates of the ship, the ship and pilot token names and the last_move_latest_time as the upper bound of the transaction's validity range (posix time). Also adds to the AsteriaUTxO value the SHIP_MINT_LOVELACE_FEE paid by the user.

Rules to take into account:

the ship number has to be exactly +1 of the last ship minted
the tip slot must be recent because it's used during validation of the tx
the start position has to be at a certain distance (manhattan distance) of coordinates (0,0). For the mainnet challenge the minimum distance is 50.

You can query the next available ship and pilot token names using the following curl:

curl --location 'https://8000-ethereal-audience-bb83g6.us1.demeter.run/graphql' \
--header 'Content-Type: application/json' \
--data '{"query":"query { nextShipTokenName(spacetimePolicyId: \"0291ae7aebaf064b785542093c2b13169effb34462301e68d4b44f43\", spacetimeAddress: \"addr1wypfrtn6awhsvjmc24pqj0ptzvtfalang33rq8ng6j6y7scnlkytx\") { shipName pilotName } }","variables":{}}'

You can query the tip of the chain using the following curl:

curl --location 'https://8000-ethereal-audience-bb83g6.us1.demeter.run/graphql' \
--header 'Content-Type: application/json' \
--data '{"query":"query { lastSlot { slot } }","variables":{}}'

Diagram

createShip diagram

tx create_ship(
  p_pos_x: Int, // Ship Position X
  p_pos_y: Int, // Ship Position Y
  ship_name: Bytes, // Name of the ship
  pilot_name: Bytes, // Name of the pilot
  tip_slot: Int, // TODO: remove when tip_slot() implemented
  last_move_timestamp: Int,
) {
  locals {
    initial_fuel: 5, // Should be taken from spaceTime datum
    ship_mint_lovelace_fee: 1000000, // Should be taken from asteria script datum
    spacetime_policy_hash: 0x0291ae7aebaf064b785542093c2b13169effb34462301e68d4b44f43,
    spacetime_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#1,
    asteria_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#0,
    pellet_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#2,
  }

  validity {
    until_slot: tip_slot, // tip_slot() + 300
  }

  reference SpacetimeRef {
    ref: spacetime_policy_ref,
  }

  reference AsteriaRef {
    ref: asteria_policy_ref,
  }

  reference PelletRef {
    ref: pellet_policy_ref,
  }

  input* gas {
    from: Player,
    min_amount: fees + Ada(ship_mint_lovelace_fee) + min_utxo(pilot_token) + min_utxo(new_ship) + min_utxo(gas_change),
  }

  input asteria {
    from: AsteriaPolicy,
    min_amount: AdminToken(1),
    datum_is: AsteriaDatum,
    redeemer: AsteriaRedeemer::AddNewShip {},
  }
  
  mint {
    amount: AnyAsset(spacetime_policy_hash, pilot_name, 1) + AnyAsset(spacetime_policy_hash, ship_name, 1),
    redeemer: ShipyardRedeemer::MintShip {},
  }

  mint {
    amount: Fuel(initial_fuel),
    redeemer: FuelRedeemer::MintFuel {},
  }

  output pilot_token {
    to: Player,
    amount: AnyAsset(spacetime_policy_hash, pilot_name, 1) + min_utxo(pilot_token),
  }

  output updated_asteria {
    to: AsteriaPolicy,
    amount: asteria + Ada(ship_mint_lovelace_fee),
    datum: AsteriaDatum {
      ship_counter: asteria.ship_counter + 1,
      shipyard_policy: asteria.shipyard_policy,
    },
  }

  output new_ship {
    to: SpacetimePolicy,
    amount: AnyAsset(spacetime_policy_hash, ship_name, 1) + Fuel(initial_fuel) + min_utxo(new_ship),
    datum: ShipDatum {
      pos_x: p_pos_x,
      pos_y: p_pos_y,
      ship_token_name: ship_name,
      pilot_token_name: pilot_name,
      last_move_latest_time: last_move_timestamp,
    },
  }

  output gas_change {
    to: Player,
    amount: gas - fees - Ada(ship_mint_lovelace_fee) - min_utxo(pilot_token) - min_utxo(new_ship),
  }

  collateral {
    from: Player,
    min_amount: fees,
  }
}

const playerAddress = process.env.PLAYER_ADDRESS;
const positionX = 4; // Replace with your desired start X position
const positionY = -50; // Replace with your desired start Y position
const shipName = "SHIP0"; // Replace 0 with the next ship number
const pilotName = "PILOT0"; // Replace 0 with the next ship number
const tipSlot = 165246231; // Replace with the latest block slot
const lastMoveTimestamp = Date.now() + 300_000;

const args: CreateShipParams = {
  player: playerAddress,
  pPosX: positionX,
  pPosY: positionY,
  pilotName: new TextEncoder().encode(pilotName),
  shipName: new TextEncoder().encode(shipName),
  tipSlot: tipSlot + 300, // 5 minutes from last block
  lastMoveTimestamp,
};

const response = await client.createShipTx(args);

MOVE SHIP

With this transaction you can move the ship through the space.

This transaction updates the pos_x, pos_y and fuel datum fields of the ShipState UTxO by adding the delta_x and delta_y values specified in the redeemer, and subtracts from the ship value the amount of fuel tokens needed for the displacement (which are burnt in this tx). Also updates the last_move_latest_time field with the transaction's validity range latest posix time.

Rules to take into account:

the ship number has to be the one controlled by the pilot token in your wallet.
the total distance you travel is constrained by the number of slots between your tx validity range (ttl end - ttl start).
the amount of fuel you pass is proportional to the total distance you travel (deltaX + deltaY).

Diagram

moveShip diagram

tx move_ship(
  p_delta_x: Int,
  p_delta_y: Int,
  ship_name: Bytes,
  pilot_name: Bytes,
  required_fuel: Int,
  since_slot: Int,
  until_slot: Int,
  last_move_timestamp: Int,
) {
  locals {
    spacetime_policy_hash: 0x0291ae7aebaf064b785542093c2b13169effb34462301e68d4b44f43,
    spacetime_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#1,
    pellet_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#2,
  }

  validity {
    since_slot: since_slot, 
    until_slot: until_slot,
  }

  reference SpacetimeRef {
    ref: spacetime_policy_ref,
  }

  reference PelletRef {
    ref: pellet_policy_ref,
  }

  collateral {
    from: Player,
    min_amount: fees,
  }

  input ship {
    from: SpacetimePolicy,
    datum_is: ShipDatum,
    min_amount: AnyAsset(spacetime_policy_hash, ship_name, 1),
    redeemer: ShipRedeemer::MoveShip { 
      delta_x: p_delta_x,
      delta_y: p_delta_y,
    },
  }

  input* pilot {
    from: Player,
    min_amount: AnyAsset(spacetime_policy_hash, pilot_name, 1) + fees + min_utxo(pilot_change),
  }

  mint {
    amount: Fuel(required_fuel) - Fuel(required_fuel) - Fuel(required_fuel),
    redeemer: FuelRedeemer::BurnFuel {},
  }

  output {
    to: SpacetimePolicy,
    amount: ship - Fuel(required_fuel),
    datum: ShipDatum {
      pos_x: ship.pos_x + p_delta_x,
      pos_y: ship.pos_y + p_delta_y,
      last_move_latest_time: last_move_timestamp,
      ...ship
    },
  }

  output pilot_change {
    to: Player,
    amount: pilot - fees,
  }

}

const slotRequiredPerStep = 12096;
const playerAddress = process.env.PLAYER_ADDRESS;
const deltaX = 0; // Replace with your desired X movement units
const deltaY = 5; // Replace with your desired Y movement units
const requiredFuel = 5; // Replace with the required fuel for the movement
const shipName = "SHIP0"; // Replace with your ship name
const pilotName = "PILOT0"; // Replace with your pilot name
const tipSlot = 165246300; // Replace with the latest block slot

// computed values
const distance = Math.abs(deltaX) + Math.abs(deltaY);
const sinceSlot = tipSlot - 100; // 100 is just to be safe;
const untilSlot = tipSlot + slotRequiredPerStep * distance;
const lastMoveTimestamp = Date.now() + slotRequiredPerStep * distance * 1000;

const args: MoveShipParams = {
  player: playerAddress,
  pDeltaX: deltaX,
  pDeltaY: deltaY,
  requiredFuel: requiredFuel,
  pilotName: new TextEncoder().encode(pilotName),
  shipName: new TextEncoder().encode(shipName),
  sinceSlot,
  untilSlot,
  lastMoveTimestamp,
};

const response = await client.moveShipTx(args);

GATHER FUEL

With this transaction you can gather fuel from the fuel pellets for your ship.

Updates the amount of fuel tokens in both ShipState and PelletState UTxOs, adding the amount (specified in the redeemer) from the first and subtracting it from the latter. Also allows the ship owner to get any amount of the prize tokens held in the pellet.

Rules to take into account:

the ship number has to be the one controlled by the pilot token in your wallet.
the ship has to be in the same position than the pellet
the ship can't have more than 5 fuel units

Diagram

gatherFuel diagram

tx gather_fuel(
  p_amount: Int,
  ship_name: Bytes,
  pilot_name: Bytes,
  pellet_ref: UtxoRef,
  since_slot: Int,
) {
  locals {
    spacetime_policy_hash: 0x0291ae7aebaf064b785542093c2b13169effb34462301e68d4b44f43,
    spacetime_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#1,
    pellet_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#2,
  }

  validity {
    since_slot: since_slot,
  }

  reference SpacetimeRef {
    ref: spacetime_policy_ref,
  }

  reference PelletRef {
    ref: pellet_policy_ref,
  }

  input pellet {
    ref: pellet_ref,
    redeemer: PelletRedeemer::Provide { 
      amount: p_amount,
    },
  }

  input ship {
    from: SpacetimePolicy,
    datum_is: ShipDatum,
    min_amount: AnyAsset(spacetime_policy_hash, ship_name, 1),
    redeemer: ShipRedeemer::GatherFuel { 
      amount: p_amount,
    },
  }

  input* pilot {
    from: Player,
    min_amount: AnyAsset(spacetime_policy_hash, pilot_name, 1) + fees + min_utxo(pilot_change),
  }

  output {
    to: PelletPolicy,
    amount: pellet - Fuel(p_amount),
    datum: PelletDatum {...pellet},
  }

  output {
    to: SpacetimePolicy,
    amount: ship + Fuel(p_amount),
    datum: ShipDatum {...ship},
  }

  output pilot_change {
    to: Player,
    amount: pilot - fees,
  }

  collateral {
    from: Player,
    min_amount: fees,
  }

}

const fuelAmount = 4; // Replace with the desired fuel to gather
const shipName = "SHIP0"; // Replace with your ship name
const pilotName = "PILOT0"; // Replace with your pilot name
const pelletRef = "acbb34e95c67bc4432557088138dbcc00d957756ebac6480e2499d1088b0b7be#13"; // Pellet UTxO reference

const playerAddress = process.env.PLAYER_ADDRESS;
const tipSlot = 165453127; // Replace with the latest block slot

const sinceSlot = tipSlot - 100; // 100 is just to be safe

const args: GatherFuelParams = {
  player: playerAddress,
  pAmount: fuelAmount,
  pilotName: new TextEncoder().encode(pilotName),
  shipName: new TextEncoder().encode(shipName),
  pelletRef,
  sinceSlot,
};

const response = await client.gatherFuelTx(args);

GATHER TOKEN

With this transaction you can gather fuel from the fuel pellets for your ship and retrieve tokens from the pellet.

Rules to take into account:

the ship number has to be the one controlled by the pilot token in your wallet.
the ship has to be in the same position than the pellet
the ship can't have more than 5 fuel units

Diagram

gatherFuel diagram

tx gather_token(
  ship_name: Bytes,
  pilot_name: Bytes,
  pellet_ref: UtxoRef,
  fuel_amount: Int,
  token_name: Bytes,
  token_amount: Int,
  token_policy_hash: Bytes,
  since_slot: Int,
) {
  locals {
    spacetime_policy_hash: 0x0291ae7aebaf064b785542093c2b13169effb34462301e68d4b44f43,
    spacetime_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#1,
    pellet_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#2,
  }

  validity {
    since_slot: since_slot,
  }

  reference SpacetimeRef {
    ref: spacetime_policy_ref,
  }

  reference PelletRef {
    ref: pellet_policy_ref,
  }

  input pellet {
    ref: pellet_ref,
    redeemer: PelletRedeemer::Provide { 
      amount: fuel_amount,
    },
  }

  input ship {
    from: SpacetimePolicy,
    datum_is: ShipDatum,
    min_amount: AnyAsset(spacetime_policy_hash, ship_name, 1),
    redeemer: ShipRedeemer::GatherFuel { 
      amount: fuel_amount,
    },
  }

  input* pilot {
    from: Player,
    min_amount: AnyAsset(spacetime_policy_hash, pilot_name, 1) + fees + min_utxo(pilot_change),
  }

  output {
    to: PelletPolicy,
    amount: pellet - Fuel(fuel_amount) - AnyAsset(token_policy_hash, token_name, token_amount),
    datum: PelletDatum {...pellet},
  }

  output {
    to: SpacetimePolicy,
    amount: ship + Fuel(fuel_amount),
    datum: ShipDatum {...ship},
  }

  output pilot_change {
    to: Player,
    amount: pilot - fees + AnyAsset(token_policy_hash, token_name, token_amount),
  }

  collateral {
    from: Player,
    min_amount: fees,
  }

}

const fuelAmount = 3; // Replace with the desired fuel to gather
const shipName = "SHIP0"; // Replace with your ship name
const pilotName = "PILOT0"; // Replace with your pilot name
const pelletRef = "2853b765da3e75237f1d6d70c0db3315d67afcc3c20812775ccf74246b383b6b#62"; // Pellet UTxO reference

const tokenAmount = 1; // Token amount to gather
const tokenName = "AS09361"; // Token name
const tokenPolicyHash = Uint8Array.from(Buffer.from("b4df23876be7207fe26e0cddfb08d6a73ff83754075efafb53446234", "hex")); // Token policy hash

const playerAddress = process.env.PLAYER_ADDRESS;
const tipSlot = 165470021; // Replace with the latest block slot

const sinceSlot = tipSlot - 100; // 100 is just to be safe

const args: GatherTokenParams = {
  player: playerAddress,
  pilotName: new TextEncoder().encode(pilotName),
  shipName: new TextEncoder().encode(shipName),
  pelletRef,
  fuelAmount: fuelAmount,
  tokenAmount,
  tokenName: new TextEncoder().encode(tokenName),
  tokenPolicyHash,
  sinceSlot,
};

const response = await client.gatherTokenTx(args);

MINE ASTERIA

With this transaction you can retrieve the asteria prize.

Subtracts from the AsteriaUTxO at most MAX_ASTERIA_MINING% of the ada value, and pays that amount to the owner of the ship that reached Asteria, together with the min ada locked in the ShipState UTxO. The ShipToken and the remaining fuel tokens are burnt.

Rules to take into account:

the ship number has to be the one controlled by the pilot token in your wallet.
the ship has to be in the position (0,0)

Diagram

mineAsteria diagram

tx mine_asteria(
  ship_name: Bytes,
  pilot_name: Bytes,
  ship_fuel: Int,
  mine_amount: Int,
  since_slot: Int,
) {
  locals {
    spacetime_policy_hash: 0x0291ae7aebaf064b785542093c2b13169effb34462301e68d4b44f43,
    spacetime_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#1,
    asteria_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#0,
    pellet_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#2,
  }

  validity {
    since_slot: since_slot,
  }

  reference SpacetimeRef {
    ref: spacetime_policy_ref,
  }

  reference AsteriaRef {
    ref: asteria_policy_ref,
  }

  reference PelletRef {
    ref: pellet_policy_ref,
  }

  input asteria {
    from: AsteriaPolicy,
    min_amount: AdminToken(1),
    datum_is: AsteriaDatum,
    redeemer: AsteriaRedeemer::Mine {},
  }

  input ship {
    from: SpacetimePolicy,
    datum_is: ShipDatum,
    min_amount: AnyAsset(spacetime_policy_hash, ship_name, 1),
    redeemer: ShipRedeemer::MineAsteria {},
  }

  input* pilot {
    from: Player,
    min_amount: AnyAsset(spacetime_policy_hash, pilot_name, 1) + fees + min_utxo(pilot_change),
  }

  mint {
    amount: Fuel(ship_fuel) - Fuel(ship_fuel) - Fuel(ship_fuel),
    redeemer: FuelRedeemer::BurnFuel {},
  }

  mint {
    amount: AnyAsset(spacetime_policy_hash, ship_name, 1) - AnyAsset(spacetime_policy_hash, ship_name, 1) - AnyAsset(spacetime_policy_hash, ship_name, 1),
    redeemer: ShipyardRedeemer::BurnShip {},
  }

  output {
    to: AsteriaPolicy,
    amount: asteria - Ada(mine_amount),
    datum: AsteriaDatum {...asteria},
  }

  output {
    to: SpacetimePolicy,
    amount: ship - AnyAsset(spacetime_policy_hash, ship_name, 1) - Fuel(ship_fuel),
    datum: ShipDatum {...ship},
  }

  output pilot_change {
    to: Player,
    amount: pilot - fees + Ada(mine_amount),
  }

  collateral {
    from: Player,
    min_amount: fees,
  }

}

const shipName = "SHIP0"; // Replace with your ship name
const pilotName = "PILOT0"; // Replace with your pilot name
const shipFuel = 3; // Replace with the ship fuel
const mineAmount = 11_500_000; // Replace with the mine amount -- it should be 50% of asteria ada

const playerAddress = process.env.PLAYER_ADDRESS;
const tipSlot = 165470021; // Replace with the latest block slot

const sinceSlot = tipSlot - 100; // 100 is just to be safe

const args: MineAsteriaParams = {
  player: playerAddress,
  pilotName: new TextEncoder().encode(pilotName),
  shipName: new TextEncoder().encode(shipName),
  shipFuel,
  mineAmount,
  sinceSlot,
};

const response = await client.mineAsteriaTx(args);

QUIT GAME

With this transaction you can remove your ship from the game.

Pays the min ada locked in the ShipState UTxO back to the ship owner. Also burns the ShipToken and the remaining fuel tokens.

Rules to take into account:

the ship number has to be the one controlled by the pilot token in your wallet.

tx quit_game(
  ship_name: Bytes,
  pilot_name: Bytes,
  ship_fuel: Int,
  since_slot: Int,
) {
  locals {
    spacetime_policy_hash: 0x0291ae7aebaf064b785542093c2b13169effb34462301e68d4b44f43,
    spacetime_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#1,
    pellet_policy_ref: 0x3d308c0f3deb1eff764cbb765452c53d30704748681d7acd61c7775aeb8a8e46#2,
  }

  validity {
    since_slot: since_slot,
  }

  reference SpacetimeRef {
    ref: spacetime_policy_ref,
  }

  reference PelletRef {
    ref: pellet_policy_ref,
  }

  input ship {
    from: SpacetimePolicy,
    datum_is: ShipDatum,
    min_amount: AnyAsset(spacetime_policy_hash, ship_name, 1),
    redeemer: ShipRedeemer::Quit {},
  }

  input* pilot {
    from: Player,
    min_amount: AnyAsset(spacetime_policy_hash, pilot_name, 1) + fees + min_utxo(pilot_change),
  }

  mint {
    amount: Fuel(ship_fuel) - Fuel(ship_fuel) - Fuel(ship_fuel),
    redeemer: FuelRedeemer::BurnFuel {},
  }

  mint {
    amount: AnyAsset(spacetime_policy_hash, ship_name, 1) - AnyAsset(spacetime_policy_hash, ship_name, 1) - AnyAsset(spacetime_policy_hash, ship_name, 1),
    redeemer: ShipyardRedeemer::BurnShip {},
  }

  output {
    to: SpacetimePolicy,
    amount: ship - AnyAsset(spacetime_policy_hash, ship_name, 1) - Fuel(ship_fuel),
    datum: ShipDatum {...ship},
  }

  output pilot_change {
    to: Player,
    amount: pilot - fees,
  }

  collateral {
    from: Player,
    min_amount: fees,
  }

}

const shipName = "SHIP0"; // Replace with your ship name
const pilotName = "PILOT0"; // Replace with your pilot name
const shipFuel = 3; // Replace with the ship fuel

const playerAddress = process.env.PLAYER_ADDRESS;
const tipSlot = 165470021; // Replace with the latest block slot

const sinceSlot = tipSlot - 100; // 100 is just to be safe

const args: QuitGameParams = {
  player: playerAddress,
  pilotName: new TextEncoder().encode(pilotName),
  shipName: new TextEncoder().encode(shipName),
  shipFuel,
  sinceSlot,
};

const response = await client.quitGameTx(args);

CREATE SHIP
MOVE SHIP
GATHER FUEL
GATHER TOKEN
MINE ASTERIA
QUIT GAME