0G Zero Gravity

Step 1: Install Dependencies

bun install @0glabs/0g-ts-sdk ethers crypto fs @0glabs/0g-serving-broker dotenv

npm install @0glabs/0g-ts-sdk ethers crypto fs @0glabs/0g-serving-broker dotenv

Step 2: Prepare Your Private Key

• Generate a Private Key: You can generate a private key using tools like MetaMask, Ethers.js, or any Ethereum-compatible wallet. For example, using Ethers.js:

  const wallet = ethers.Wallet.createRandom(); console.log('Private Key:', wallet.privateKey);

• Store Your Private Key Securely: Never hardcode your private key directly in your scripts. Instead, use environment variables or a secure vault. For example, create a `.env` file:

  PRIVATE_KEY=your_private_key_here

  Then, load it in your script using `dotenv`:

  import dotenv from 'dotenv'; dotenv.config(); const privateKey = process.env.PRIVATE_KEY;

Step 3: Run the Scripts

bun upload0g.mts YOUR_PRIVATE_KEY

bun inference.mts YOUR_PRIVATE_KEY

Step 1: Import Required Modules

import { ZgFile, Indexer } from '@0glabs/0g-ts-sdk';
import { ethers } from 'ethers';
import { createHash, randomBytes } from 'crypto';
import { writeFileSync, unlinkSync } from 'fs';
import { promisify } from 'util';

Step 2: Define RPC List and Indexer RPC

The script defines a list of RPCs and the indexer RPC URL. These are used to connect to the 0g network. Here's the code:

const RPC_LIST = [
  "https://16600.rpc.thirdweb.com",
  "https://rpc.ankr.com/0g_newton",
  "https://evmrpc-testnet.0g.ai",
  "https://0g-json-rpc-public.originstake.com",
  "https://0g-rpc-evm01.validatorvn.com",
  "https://0g-evmrpc.zstake.xyz/",
  "https://0g-evm-rpc.murphynode.net"
];

const INDEXER_RPC = 'https://indexer-storage-testnet-turbo.0g.ai';

The script randomly selects an RPC from the list to ensure redundancy and reliability.

Step 3: Generate a File with Hashes

The script generates a file containing random hashes. This file is used for testing the upload functionality. Here's the code:

async function generateHashFile(): Promise<string> {
  const randomNumber = Math.floor(Math.random() * 100000);
  const fileName = `encrypted-hash-${randomNumber}.txt`;

  let data = '=== HASH DATA WITH MERKLE ROOT ===\n';
  let hashes: string[] = [];

  for (let i = 0; i < 1024 * 1024 / 128; i++) {
    const hash = createHash('sha512').update(randomBytes(128)).digest('hex');
    hashes.push(hash);
    data += `Hash: ${hash}\n`;
  }

  writeFileSync(fileName, data);
  return fileName;
}

The file is created with a unique name and contains a large number of random hashes.

Step 4: Upload File with Private Key

The script uploads the generated file to the 0g network using your private key. Here's the code:

async function uploadFileWithPrivateKey(privateKey: string) {
  let filePath = "";

  try {
    console.log(`\n🔑 Using Private Key: ${privateKey.slice(0, 10)}...`);

    const rpcUrl = getRandomRpc();
    console.log(`🌐 Using RPC: ${rpcUrl}`);

    const provider = new ethers.JsonRpcProvider(rpcUrl);
    const signer = new ethers.Wallet(privateKey, provider);
    const indexer = new Indexer(INDEXER_RPC);

    filePath = await generateHashFile();
    console.log(`📂 Generated file: ${filePath}`);

    const file = await ZgFile.fromFilePath(filePath);

    const [tree, treeErr] = await file.merkleTree();
    if (treeErr !== null) throw new Error(`❌ Merkle tree error: ${treeErr}`);

    const rootHash = tree?.rootHash() ?? '';
    console.log("🌳 File Root Hash:", rootHash);

    writeFileSync(filePath, `\nMerkle Root: ${rootHash}\n`, { flag: 'a' });

    console.log("📡 Uploading file to indexer...");

    const [tx, uploadErr] = await indexer.upload(file, rpcUrl, signer);

    if (uploadErr) throw new Error(`❌ Upload error: ${uploadErr}`);

    console.log("✅ Upload successful! Transaction Hash:", tx);

    await file.close();
  } catch (error) {
    console.error("❌ Error:", error instanceof Error ? error.message : error);
  } finally {
    if (filePath) {
      try {
        unlinkSync(filePath);
        console.log(`🗑️ File ${filePath} has been deleted.`);
      } catch (err) {
        console.error(`⚠️ Failed to delete file ${filePath}:`, err);
      }
    }
  }
}

The file is uploaded to the 0g network, and the transaction hash is logged. The file is deleted after the upload to clean up resources.

Step 5: Run the Script

The script is executed with the provided private key. It uploads the file and exits after completion. Here's the code:

(async () => {
  const args = process.argv.slice(2);
  if (args.length === 0) {
    console.error("❌ No private keys provided. Usage: node script.js <privateKey>");
    process.exit(1);
  }

  const privateKey = args[0];
  await uploadFileWithPrivateKey(privateKey);
  console.log("🎉 File upload completed. Exiting...");
})();

The script that performs upload.

Step 1: Import Required Modules

import { JsonRpcProvider, Wallet } from "ethers";
import { createZGComputeNetworkBroker } from "@0glabs/0g-serving-broker";
import dotenv from "dotenv";
dotenv.config();

Step 2: Initialize Broker

async function initializeBrokerWithPrivateKey(privateKey: string) {
  const provider = new JsonRpcProvider(RPC_URL);
  const wallet = new Wallet(privateKey, provider);

  const broker = await createZGComputeNetworkBroker(wallet);
  console.log("✅ Broker successfully initialized!");
  return broker;
}

Step 3: Make AI Inference Request

async function requestInference(broker: ReturnType<typeof createZGComputeNetworkBroker>, providerAddress: string, content: string) {
  const { endpoint, model } = await broker.inference.getServiceMetadata(providerAddress);
  const headers = await broker.inference.getRequestHeaders(providerAddress, content);

  const response = await fetch(`${endpoint}/chat/completions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      ...headers,
    },
    body: JSON.stringify({
      messages: [{ role: "system", content }],
      model: model,
    }),
  });

  const data = await response.json();
  console.log("📩 AI Response:", data);

  if (data.choices && data.choices.length > 0) {
    const valid = await broker.inference.processResponse(providerAddress, data.choices[0].message.content);
    console.log("✅ Response Validation:", valid);
  } else {
    console.error("❌ Invalid AI response:", data);
  }

  return data;
}

Step 4: Run the Script

(async () => {
  const args = process.argv.slice(2);
  if (args.length === 0) {
    console.error("❌ No private keys provided. Usage: node script.js <privateKey>");
    process.exit(1);
  }

  const privateKey = args[0];
  const broker = await initializeBrokerWithPrivateKey(privateKey);

  const services = await broker.inference.listService();
  if (services.length === 0) {
    console.log("❌ No available AI services!");
    return;
  }

  const selectedService = services[0];
  console.log("🆔 Using service:", selectedService.model);

  const prompt = "Hello, how are you?";
  console.log(`📨 Sending prompt: "${prompt}"`);

  const response = await requestInference(broker, selectedService.provider, prompt);
  console.log("🎉 AI request completed. Exiting...");
})();

Step 1: Install Hardhat and Dependencies

npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox @openzeppelin/contracts

Step 2: Initialize a Hardhat Project

npx hardhat

Step 3: Configure Hardhat for 0g Chain Testnet

require("@nomicfoundation/hardhat-toolbox");

module.exports = {
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200,
      },
    },
  },
  networks: {
    "0g-testnet": {
      url: "https://evmrpc-testnet.0g.ai",
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};

Step 4: Create Secure ERC20 Contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyToken is ERC20, Ownable {
    constructor() ERC20("MyToken", "MTK") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }

    // Add a function to allow the owner to mint tokens
    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    // Add a function to allow the owner to burn tokens
    function burn(uint256 amount) public onlyOwner {
        _burn(msg.sender, amount);
    }
}

Step 5: Create Secure ERC721 Contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyNFT is ERC721, Ownable {
    uint256 private _nextTokenId;

    constructor() ERC721("MyNFT", "MNFT") {}

    // Mint NFTs securely
    function safeMint(address to) public onlyOwner {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
    }

    // Prevent unauthorized transfers
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId,
        uint256 batchSize
    ) internal override {
        require(from == address(0) || to == address(0), "Transfers are disabled");
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
    }
}

Step 6: Deploy Contracts

const hre = require("hardhat");

async function main() {
  const [deployer] = await hre.ethers.getSigners();

  console.log("Deploying contracts with the account:", deployer.address);

  // Deploy ERC20 Token
  const ERC20Token = await hre.ethers.getContractFactory("MyToken");
  const erc20Token = await ERC20Token.deploy();
  await erc20Token.waitForDeployment();
  console.log("ERC20 Token deployed to:", erc20Token.target);

  // Deploy ERC721 Token
  const ERC721Token = await hre.ethers.getContractFactory("MyNFT");
  const erc721Token = await ERC721Token.deploy();
  await erc721Token.waitForDeployment();
  console.log("ERC721 Token deployed to:", erc721Token.target);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

npx hardhat run scripts/deploy.js --network 0g-testnet

Official Documentation

• 0g Storage SDK Documentation
• 0g TypeScript SDK GitHub Repository
• OpenZeppelin Documentation
• Hardhat Documentation
• Remix Ethereum IDE