Build directly on
Quantum Chain.

mkdir quantum-sandbox-demo
cd quantum-sandbox-demo
npm init -y
npm install @quantum_chain/sdk @quantum_chain/pqc
npm install --save-dev tsx typescript @types/node

@quantum_chain:registry=https://registry.npmjs.org/
//registry.npmjs.org/:_authToken=${NPM_TOKEN}

import {
  QuantumClient,
  QuantumWallet,
  formatQ,
  networks,
  parseQ,
} from "@quantum_chain/sdk";

const client = new QuantumClient(networks.sandbox);
const sender = QuantumWallet.generate();
const recipient = QuantumWallet.generate();

try {
  const identity = await client.validateNetwork();
  console.log("network", identity.network, identity.chainId.toString());
  console.log("sender", sender.address);

  const funding = await client.sandbox!.fund(sender.address);
  console.log("balance", formatQ(funding.balance), "Q");

  const submitted = await sender.sendTransaction(client, {
    to: recipient.address,
    value: parseQ("0.01"),
  });
  console.log("transaction", submitted.hash);

  const receipt = await submitted.wait({
    confirmations: 1,
    timeoutMs: 120_000,
    pollIntervalMs: 1_000,
  });
  console.log("status", receipt.status);
  console.log("block", receipt.blockNumber.toString());
  console.log("explorer", client.getExplorerTxUrl(submitted.hash));
} finally {
  sender.destroy();
  recipient.destroy();
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

contract Counter {
    uint256 public number;
    event NumberChanged(uint256 number);

    constructor(uint256 initialNumber) { number = initialNumber; }
    function increment() external {
        number += 1;
        emit NumberChanged(number);
    }
}

import { mkdir, readFile, writeFile } from "node:fs/promises";
import solc from "solc";

const source = await readFile("contracts/Counter.sol", "utf8");
const input = {
  language: "Solidity",
  sources: { "Counter.sol": { content: source } },
  settings: { outputSelection: { "*": { "*": ["abi", "evm.bytecode.object"] } } },
};
const output = JSON.parse(solc.compile(JSON.stringify(input)));
const errors = (output.errors ?? []).filter((item) => item.severity === "error");
if (errors.length) throw new Error(errors.map((item) => item.formattedMessage).join("\n"));
const result = output.contracts["Counter.sol"].Counter;
await mkdir("artifacts", { recursive: true });
await writeFile("artifacts/Counter.json", JSON.stringify({
  abi: result.abi,
  bytecode: `0x${result.evm.bytecode.object}`,
}, null, 2));

import { readFile, writeFile } from "node:fs/promises";
import {
  QuantumClient, QuantumWallet, hexToBytes, networks,
} from "@quantum_chain/sdk";
import { encodeAbiParameters } from "viem";

const artifact = JSON.parse(await readFile("artifacts/Counter.json", "utf8"));
const args = encodeAbiParameters([{ type: "uint256" }], [41n]);
const deploymentData = new Uint8Array([
  ...hexToBytes(artifact.bytecode),
  ...hexToBytes(args),
]);

const client = new QuantumClient(networks.sandbox);
const deployer = QuantumWallet.generate();

try {
  await client.validateNetwork();
  await client.sandbox!.fund(deployer.address);
  const tx = await deployer.sendTransaction(client, {
    data: deploymentData, // no `to`: contract creation
    value: 0n,
  });
  const receipt = await tx.wait({ timeoutMs: 180_000 });
  if (!receipt.contractAddress) throw new Error("missing contract address");
  const code = await client.getCode(receipt.contractAddress);
  if (!code.length) throw new Error("deployment produced no runtime code");
  const deployment = {
    network: "quantum-sandbox",
    chainId: "20804",
    transactionHash: tx.hash,
    blockNumber: receipt.blockNumber.toString(),
    contractAddress: receipt.contractAddress,
  };
  await writeFile("deployment.json", JSON.stringify(deployment, null, 2));
  console.log(deployment);
} finally {
  deployer.destroy();
}

import { readFile } from "node:fs/promises";
import {
  QuantumClient, QuantumContract, QuantumWallet, bytesToHex, networks,
} from "@quantum_chain/sdk";
import { decodeFunctionResult, encodeFunctionData } from "viem";

const artifact = JSON.parse(await readFile("artifacts/Counter.json", "utf8"));
const deployment = JSON.parse(await readFile("deployment.json", "utf8"));
const client = new QuantumClient(networks.sandbox);
const contract = new QuantumContract(deployment.contractAddress, client);
const writer = QuantumWallet.generate();

async function readNumber(): Promise<bigint> {
  const data = encodeFunctionData({ abi: artifact.abi, functionName: "number" });
  const output = await contract.call(data);
  return decodeFunctionResult({
    abi: artifact.abi,
    functionName: "number",
    data: bytesToHex(output),
  }) as bigint;
}

try {
  await client.validateNetwork();
  console.log("before", (await readNumber()).toString());
  await client.sandbox!.fund(writer.address);
  const data = encodeFunctionData({ abi: artifact.abi, functionName: "increment" });
  const submitted = await contract.send(writer, data);
  const receipt = await submitted.wait({ timeoutMs: 120_000 });
  console.log("hash", submitted.hash);
  console.log("status", receipt.status);
  console.log("after", (await readNumber()).toString());
} finally {
  writer.destroy();
}

import {
  buildAndSignTransaction, parseQ,
} from "@quantum_chain/sdk/transactions";
import { LocalPQCSigner } from "@quantum_chain/sdk/signers";

const signer = new LocalPQCSigner();
try {
  const result = await buildAndSignTransaction({
    type: "legacy",
    chainId: 20804n,
    nonce: 12n,
    gasLimit: 21_000n,
    gasPrice: 1_000_000_000n,
    to: "0x0000000000000000000000000000000000000001",
    value: parseQ("1"),
  }, signer);

  console.log(result.rawTransaction);     // submit through your RPC layer
  console.log(result.transactionHash);    // locally computed hash
  console.log(result.publicKey);          // embedded public key
  console.log(result.signature);          // embedded signature
  console.log(result.signingDigest);      // exact 32-byte digest
} finally {
  signer.destroy();
}

interface TransactionRequest {
  to?: string;                       // omit for contract creation
  value?: bigint | string;           // bigint Qwei, decimal string Q
  data?: Uint8Array | `0x${string}`;
  gasLimit?: bigint;
  gasPrice?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  nonce?: bigint;
  chainId?: bigint;
  type?: "legacy" | "dynamic";
  accessList?: readonly AccessTuple[];
}

interface SignTransactionResult {
  unsignedTransaction: UnsignedQuantumTransaction;
  signedTransaction: SignedQuantumTransaction;
  signingDigest: Uint8Array;
  signature: Uint8Array;
  publicKey: Uint8Array;
  rawTransaction: `0x${string}`;
  rawTransactionBytes: Uint8Array;
  transactionHash: `0x${string}`;
}

curl --fail-with-body https://rpc.sandbox.qustody.io \
  -H 'content-type: application/json' \
  --data '{"jsonrpc":"2.0","id":1,"method":"qc_chainId","params":[]}'

import { HttpRpcTransport } from "@quantum_chain/sdk/rpc";

const rpc = new HttpRpcTransport("https://rpc.sandbox.qustody.io", {
  timeoutMs: 15_000,
  maxResponseBytes: 8 * 1024 * 1024,
});
const logs = await rpc.request<unknown[]>("qc_getLogs", [{
  fromBlock: "0x1",
  toBlock: "latest",
  address: CONTRACT_ADDRESS,
}]);