Onboard a machine on Solana

​

What you need

​

Configure

mkdir -p solana-onboarding && cd solana-onboarding   # one directory per attempt, keep it
export PEAQOS_NETWORK=peaq
export TOKENOMICS_DEPLOYMENT_ID=peaq-mainnet
export PEAQOS_RPC_URL=https://peaq.api.onfinality.io/public
export PEAQOS_SVM_NETWORK=mainnet-beta
export PEAQOS_SVM_RPC_URL=https://api.mainnet-beta.solana.com

peaqos wallet create svm-operator     # peaq address pays gas and the bond
peaqos wallet create svm-owner        # Solana address pays fees and rent
peaqos wallet show svm-owner --json
unset PEAQOS_PRIVATE_KEY              # let the selected OWS wallet sign

​

The DID document

{
  "verificationMethods": [
    {
      "id": "#key-1",
      "methodType": "Ed25519",
      "controller": "<base58 Solana public key>",
      "publicKeyMultibase": "<multibase public key>"
    }
  ],
  "authentication": [0],
  "serviceEndpoints": [
    { "id": "#telemetry", "serviceType": "Telemetry", "serviceEndpoint": "https://example.com/telemetry" }
  ]
}

​

The argument set

ARGS=(
  --chain solana --json
  --solana-owner "${OWNER:?}"                       # base58, the Solana owner wallet
  --evm-operator "${OPERATOR:?}"                    # 0x…, the peaq operator wallet
  --manufacturer "${MANUFACTURER:?}"                # base58, recorded without verification
  --machine-type Sensor
  --credential-subject-hex "${CREDENTIAL_SUBJECT_HEX:?}"
  --tier basic --did-document ./native-did.json
  --payment peaq --max-net-peaq-amount "${PEAQ_CAP:?}"
  --max-native-fee-lamports "${FEE_CAP:?}"          # network + priority fees, excludes rent
  --max-native-rent-lamports "${RENT_CAP:?}"        # machine + state account rent
  --from-block "${HISTORY_START:?}"                 # inclusive peaq block where this attempt's history starts
  --compute-unit-limit "${COMPUTE_LIMIT:?}"         # 1 to 1,400,000
  --compute-unit-price-micro-lamports "${PRIORITY_PRICE:?}"
)

​

Run the three phases

peaqos activate "${ARGS[@]}" --dry-run

PEAQOS_OWS_WALLET=svm-operator peaqos activate "${ARGS[@]}" --phase reservation --yes

peaqos activate "${ARGS[@]}" --phase subscription --dry-run
PEAQOS_OWS_WALLET=svm-operator peaqos activate "${ARGS[@]}" --phase subscription --yes

peaqos activate "${ARGS[@]}" --phase native_onboarding --dry-run

PEAQOS_OWS_WALLET=svm-owner peaqos activate "${ARGS[@]}" --phase native_onboarding --yes

​

Read the state

peaqos machine status "$MACHINE_ID" --json

​

Resume after an interruption

​

The same flow in the SDKs

import { createPublicClient, http } from "viem";
import {
  previewMachineActivation, activateMachine, getMachineActivationState,
  resolveTokenomics20Deployment, resolveSvmDeployment,
  serializeSvmOnboardingProgress, type SvmActivationReadContext, type SvmOnboardingInput,
} from "@peaqos/peaq-os-sdk";

const context: SvmActivationReadContext = {
  publicClient: createPublicClient({ transport: http(process.env.PEAQOS_RPC_URL!) }),
  tokenomics20: resolveTokenomics20Deployment("peaq-mainnet"),
  svm: resolveSvmDeployment("solana-mainnet"),
  svmRpcUrl: process.env.PEAQOS_SVM_RPC_URL!,
};
const input: SvmOnboardingInput = {
  chain: "solana", owner, controller: owner, manufacturer, evmOperator,
  machineType: "Sensor", credentialSubject: "0x0102",
  verificationMethods: [], authentication: [], serviceEndpoints: [],
  tier: 1,                                                   // 1 basic, 2 pro
  funding: { payment: "peaq", maxNetPeaqAmount: 10n ** 18n },
  maxNativeFeeLamports: 100_000n, maxNativeRentLamports: 10_000_000n,
};
const preview = await previewMachineActivation(context, {
  ...input, commitment: "confirmed",
  native: { computeUnitLimit: 200_000, computeUnitPriceMicroLamports: 0n },
});
const result = await activateMachine(context, {
  chain: "solana", plan: preview.plan, phase: "reservation",   // then "subscription", then "native_onboarding"
  commitment: "confirmed", timeoutMs: 120_000,
  onProgress: (p) => persist(serializeSvmOnboardingProgress(p)),
});
const state = await getMachineActivationState(context, preview.plan.machineId, { plan: preview.plan, commitment: "confirmed" });

from dataclasses import replace
from peaq_os_sdk import (
    PeaqosClient, Tokenomics20Config,
    PreviewSolanaMachineActivationParams, ActivateSolanaMachineParams,
    SolanaMachineCurrentStateParams,
)

client = PeaqosClient.from_wallet("svm-operator", passphrase, ...,
    tokenomics20=Tokenomics20Config(deployment_id="peaq-mainnet",
                                    creation_home="solana",
                                    solana_rpc_url=SVM_RPC))
plan = client.preview_machine_activation(PreviewSolanaMachineActivationParams(
    inputs=inputs, from_block=history_start,
    compute_unit_limit=600_000, compute_unit_price_micro_lamports=0))

params = ActivateSolanaMachineParams(
    inputs=inputs, accepted_plan=plan, phase="reservation",
    expected_machine_id=plan.binding.machine_id, records=(),
    from_block=history_start, compute_unit_limit=600_000,
    compute_unit_price_micro_lamports=0, on_transaction_submitted=persist)
reservation = client.activate_machine(params)
subscription = client.activate_machine(replace(params, phase="subscription",
    records=reservation.recovery.history.records))
native = owner_client.activate_machine(replace(params, phase="native_onboarding",
    records=subscription.recovery.history.records, solana_signer=owner_signer))

current = client.get_machine_activation_state(machine_id, solana=SolanaMachineCurrentStateParams())

​

After onboarding

• Manage the machine with the same peaqos machine commands plus --chain solana (status, transfer --unsafe, suspend, resume, did set-controller, the DID setters, and the Solana-only set-evm-operator), or the same SDK methods; the SDK resolves the home chain from the machine ID and refuses the wrong chain. Transfer, controller and the peaq operator link need the Solana owner signature; DID lists, suspend and resume take owner or controller. There is no safe transfer on Solana (transfer requires --unsafe, --data-hex is refused), and approve / approve-all do not exist; the SDKs refuse approveMachine, setMachineApprovalForAll and safeTransferMachine by name. Details: SDK JS, SDK Python.
• Submit events with submitEvent / submit_event: the SDK routes a Solana-homed machine to the Solana EventRegistry program and signs with the owner’s or controller’s OWS Solana signer (the EVM operator does not qualify). In Python set client.solana_signer to an OwsSolanaSigner (for example from PeaqosClient.solana_signer_from_wallet(...)) before the call, or submit_event raises SIGNER_UNAVAILABLE; the CLI attaches it itself. The first event for a machine also pays rent for its event-log account. A confirmed event is not yet a rating; the 2.0 MCR indexes Solana events asynchronously.
• Credit rating: the 2.0 MCR scores a Solana-homed machine once its Solana indexer has the machine’s events; until then the response carries home_chain: 5 and a rating_unavailable reason (any non-empty reason means the score is a floor, not a measurement). What mcr-20.peaq.xyz returns for such a machine was not verified live at the time of writing. See the API reference.
• Monetization opt-in for a Solana-homed machine (signed by the Solana owner) is built into the SDKs but refused with SOLANA_MONETIZATION_UNVERIFIED until the server contract is confirmed.
• Relocation between peaq and Solana stays switched off on chain. Onboarding on Solana is not a relocation: the machine is created there.

​

Related

• Activate: the one-transaction flow on peaq
• Omni-chain: Solana: what is live on Solana
• Smart contracts: Solana mainnet: the eleven program IDs
• CLI: activate