SDK: JavaScript

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

const client = new PeaqosClient({
  rpcUrl: "https://peaq.api.onfinality.io/public",
  privateKey: "0xabc...def",
  contracts: {
    identityRegistry: "0x...",
    identityStaking: "0x...",
    eventRegistry: "0x...",
    machineNft: "0x...",
    didRegistry: "0x...",
    batchPrecompile: "0x...",
  },
});

console.log(client.address); // checksummed 0x address

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

const client = PeaqosClient.fromEnv();

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

const client = await PeaqosClient.fromWallet("my-machine", "s3cret", true, {
  rpcUrl: "https://peaq.api.onfinality.io/public",
  contracts: {
    identityRegistry: "0x...",
    identityStaking: "0x...",
    eventRegistry: "0x...",
    machineNft: "0x...",
    didRegistry: "0x...",
    batchPrecompile: "0x...",
  },
});

const kp = PeaqosClient.generateKeypair();
console.log(kp.address);    // 0x...
console.log(kp.privateKey); // 0x...

import {
  PeaqosClient,
  IMPORT_CHAIN_EVM,
  extractPeaqAddress,
} from "@peaqos/peaq-os-sdk";

const wallet = await PeaqosClient.createWallet("robot-001");
console.log(wallet.peaqAddress);

const imported = await PeaqosClient.importWallet(
  "legacy-machine",
  "0xabc...def",
  undefined,
  IMPORT_CHAIN_EVM,
);

const all = await PeaqosClient.listWallets();
const same = await PeaqosClient.getWallet(imported.id);
console.log(all.length, extractPeaqAddress(same.accounts));

const client = await PeaqosClient.fromWallet(imported.id, undefined, true, {
  rpcUrl: "https://quicknode1.peaq.xyz",
  contracts: {
    identityRegistry: "0x...",
    identityStaking: "0x...",
    eventRegistry: "0x...",
    machineNft: "0x...",
    didRegistry: "0x0000000000000000000000000000000000000800",
    batchPrecompile: "0x0000000000000000000000000000000000000805",
  },
});
console.log(client.address);

const client = PeaqosClient.fromEnv();
const machineId = await client.registerMachine();
console.log(machineId);

const client = PeaqosClient.fromEnv();
const { address: machineAddress } = PeaqosClient.generateKeypair();
const machineId = await client.registerFor(machineAddress);

const setup = await client.setupFaucet2FA(
  client.address,
  "https://depinstation.peaq.network",
);
console.log(setup.otpauthUri);
console.log(setup.qrImageUrl);

await client.confirmFaucet2FA(
  client.address,
  "https://depinstation.peaq.network",
  "123456",
);

const result = await client.fundFromGasStation(
  {
    ownerAddress: client.address,
    targetWalletAddress: machineAddress,
    chainId: "peaq",
    twoFactorCode: "123456",
  },
  "https://depinstation.peaq.network",
);

if (result.status === "success") {
  console.log("tx:", result.txHash, "amount:", result.fundedAmount);
} else {
  console.log("already funded; balance:", result.currentBalance);
}

const txHash = await client.mintNft(machineId, client.address);

const tokenId = await client.tokenIdOf(machineId);
if (tokenId === 0) {
  console.log("No NFT minted yet");
}

const txHash = await client.writeMachineDIDAttributes({
  machineId: 42,
  nftTokenId: 1,
  operatorDid: "",
  documentationUrl: "https://docs.example.com",
  dataApi: "https://api.example.com",
  dataVisibility: "public",
});

const txHash = await client.writeProxyDIDAttributes({
  proxyMachineId: 10,
  machineIds: [42, 43, 44],
});

const address = await client.deploySmartAccount({
  owner: client.address,
  machine: machineAddress,
  salt: 0,
});

const predicted = await client.getSmartAccountAddress({
  owner: client.address,
  machine: machineAddress,
  salt: 0,
});

const txHash = await client.bridgeNft({
  tokenId: 42,
  source: "peaq",
  destination: "base",
  recipient: "0xabc...",
});

const arrived = await PeaqosClient.waitForBridgeArrival({
  dstRpcUrl: "https://mainnet.base.org",
  dstNftAddress: "0x...",
  tokenId: 42,
  timeout: 120,
});

const { txHash, dataHash } = await client.submitEvent({
  machineId: 1024,
  eventType: EVENT_TYPE_REVENUE,
  value: 12500,                     // $125.00 in cents
  currency: "USD",
  timestamp: Math.floor(Date.now() / 1000),
  rawData: new Uint8Array([1, 2, 3]),
  trustLevel: TRUST_ON_CHAIN_VERIFIABLE,
  sourceChainId: SUPPORTED_CHAIN_IDS.peaq,
  sourceTxHash: null,
  metadata: new Uint8Array([]),
});

import {
  validateSubmitEventParams,
  EVENT_TYPE_REVENUE,
  TRUST_ON_CHAIN_VERIFIABLE,
  SUPPORTED_CHAIN_IDS,
} from "@peaqos/peaq-os-sdk";

validateSubmitEventParams({
  machineId: 1024,
  eventType: EVENT_TYPE_REVENUE,
  value: 1250,                      // $12.50 in cents
  currency: "USD",
  timestamp: Math.floor(Date.now() / 1000),
  rawData: new Uint8Array([1, 2, 3]),
  trustLevel: TRUST_ON_CHAIN_VERIFIABLE,
  sourceChainId: SUPPORTED_CHAIN_IDS.base,
  sourceTxHash: "0xabc...",
  metadata: new Uint8Array([]),
});

import { computeDataHash } from "@peaqos/peaq-os-sdk";

const dataHash = computeDataHash(new TextEncoder().encode("revenue: $12.50"));
console.log(dataHash);

import { checkOperationalLimits } from "@peaqos/peaq-os-sdk";

checkOperationalLimits(
  { machineId: 1, value: 100 },
  client.operationalLimits,
  { machineId: 1, count: 50, windowStart: Date.now() / 1000 - 1800 },
);

import { queryMcr } from "@peaqos/peaq-os-sdk";

const score = await queryMcr(client, "did:peaq:0xMachineAddress", {
  timeoutMs: 5_000,
});
console.log(`${score.mcrScore} → ${score.mcr}`);

import { queryMachine } from "@peaqos/peaq-os-sdk";

const profile = await queryMachine(client, "did:peaq:0xMachineAddress");
console.log(profile.name, profile.peaqos.mcr, profile.peaqos.mcr_score);

import { queryOperatorMachines } from "@peaqos/peaq-os-sdk";

const fleet = await queryOperatorMachines(client, "did:peaq:0xProxyAddress");
for (const m of fleet.machines) {
  console.log(`${m.did} → ${m.mcrScore} (${m.mcr}), negative=${m.negativeFlag}`);
}
console.log(`showing ${fleet.machines.length} of ${fleet.pagination.total}`);