Proxy operator fleet

import "dotenv/config";
import { PeaqosClient } from "@peaqos/peaq-os-sdk";

const proxy = PeaqosClient.fromEnv();
const proxyMachineId = 7; // the proxy's own machineId from its self-registration
const FLEET_SIZE = 10;
const FAUCET_URL = "https://depinstation.peaq.network";

const fleet = [];

for (let i = 0; i < FLEET_SIZE; i++) {
  const machine = PeaqosClient.generateKeypair();

  try {
    const machineId = await proxy.registerFor(machine.address);
    await proxy.mintNft(machineId, machine.address);
    const nftTokenId = await proxy.tokenIdOf(machineId);

    await proxy.fundFromGasStation(
      {
        ownerAddress: proxy.address,
        targetWalletAddress: machine.address,
        chainId: "peaq",
        twoFactorCode: "654321", // Fresh TOTP code per call
      },
      FAUCET_URL,
    );

    const machineClient = new PeaqosClient({
      rpcUrl: proxy.rpcUrl,
      privateKey: machine.privateKey,
      contracts: proxy.contracts,
    });
    await machineClient.writeMachineDIDAttributes({
      machineId,
      nftTokenId,
      operatorDid: `did:peaq:${proxy.address}`,
      documentationUrl: "https://example.com/docs",
      dataApi: "https://example.com/events",
      dataVisibility: "public",
    });

    fleet.push({
      address: machine.address,
      privateKey: machine.privateKey,
      machineId,
    });
    console.log(`[${i + 1}/${FLEET_SIZE}] Activated ${machine.address} (machineId ${machineId})`);
  } catch (err) {
    console.error(`[${i + 1}/${FLEET_SIZE}] Failed for ${machine.address}:`, err);
    // Decide: skip this machine and continue, or abort the batch.
  }
}

// Publish the proxy's full fleet in one DID write.
await proxy.writeProxyDIDAttributes({
  proxyMachineId,
  machineIds: fleet.map((m) => m.machineId),
});

console.log("Fleet:", fleet.length, "machines activated");
// Persist fleet to a JSON file or database for later use.

from peaq_os_sdk import PeaqosClient

proxy = PeaqosClient.from_env()
proxy_machine_id = 7  # the proxy's own machineId from its self-registration
FLEET_SIZE = 10
FAUCET_URL = "https://depinstation.peaq.network"

fleet = []

for i in range(FLEET_SIZE):
    machine_address, machine_key = PeaqosClient.generate_keypair()

    try:
        machine_id = proxy.register_for(machine_address)
        proxy.mint_nft(machine_id, machine_address)
        nft_token_id = proxy.token_id_of(machine_id)

        proxy.fund_from_gas_station(
            owner_address=proxy.address,
            target_wallet_address=machine_address,
            chain_id="peaq",
            two_factor_code="654321",  # Fresh TOTP code per call
            faucet_base_url=FAUCET_URL,
        )

        # Build a per-machine client directly: same RPC and contracts
        # as the proxy, but signed with the machine's own key.
        machine_client = PeaqosClient(
            rpc_url=proxy.rpc_url,
            private_key=machine_key,
            identity_registry=proxy.contracts.identity_registry,
            identity_staking=proxy.contracts.identity_staking,
            event_registry=proxy.contracts.event_registry,
            machine_nft=proxy.contracts.machine_nft,
            did_registry=proxy.contracts.did_registry,
            batch_precompile=proxy.contracts.batch_precompile,
        )
        machine_client.write_machine_did_attributes(
            machine_id=machine_id,
            nft_token_id=nft_token_id,
            operator_did=f"did:peaq:{proxy.address}",
            documentation_url="https://example.com/docs",
            data_api="https://example.com/events",
            data_visibility="public",
        )

        fleet.append({
            "address": machine_address,
            "private_key": machine_key,
            "machine_id": machine_id,
        })
        print(f"[{i + 1}/{FLEET_SIZE}] Activated {machine_address} (machine_id {machine_id})")
    except Exception as err:
        print(f"[{i + 1}/{FLEET_SIZE}] Failed for {machine_address}: {err}")
        # Decide: skip this machine and continue, or abort the batch.

# Publish the proxy's full fleet in one DID write.
proxy.write_proxy_did_attributes(
    proxy_machine_id=proxy_machine_id,
    machine_ids=[m["machine_id"] for m in fleet],
)

print(f"Fleet: {len(fleet)} machines activated")
# Persist fleet to a JSON file or database for later use.