DEV Community: Raven Arts

Create a Simple Transaction Indexer on Juneo Supernet Using Squid SDK

Raven Arts — Sat, 16 Nov 2024 06:45:33 +0000

In this tutorial, we will create a simple transaction indexer on the Juneo Supernet using the Squid SDK.

Before we begin, some of you might be wondering: What is Juneo Supernet, and what is Squid SDK?

Juneo Supernet is a blockchain ecosystem built upon the Snowman++ consensus protocol, a highly scalable and efficient version of the Avalanche consensus. It provides a permissionless platform for deploying decentralized applications (dApps) and custom blockchains.
Squid SDK is a developer toolkit for building data indexers on blockchain networks. It streamlines the process of extracting, processing, and querying on-chain data for applications like analytics dashboards, DeFi platforms, and dApps.

Let's dive in!

Prerequisites

Docker (for running PostgreSQL)
Node.js 20

Steps to Build the Indexer

1. Initialize the Project

Create a new folder and initialize a new project:

npm init

2. Install Required Packages

Run the following commands to install the necessary dependencies:

npm i dotenv typeorm @subsquid/evm-processor @subsquid/typeorm-store @subsquid/typeorm-migration @subsquid/graphql-server @subsquid/evm-abi
npm i typescript @subsquid/typeorm-codegen @subsquid/evm-typegen --save-dev

3. Add a Minimal tsconfig.json

Create a tsconfig.json file:

{
  "compilerOptions": {
    "rootDir": "src",
    "outDir": "lib",
    "module": "commonjs",
    "target": "es2020",
    "esModuleInterop": true,
    "skipLibCheck": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

4. Create a Simple GraphQL Schema

Create a schema.graphql file with the following content:

type Transaction @entity {
  id: ID!
  from: String! @index
  to: String! @index
  value: BigInt!
}

5. Generate TypeORM Model Entity

Run the following command to generate TypeORM models based on your schema:

npx squid-typeorm-codegen

6. Set Up the Database

Create a .env file:

DB_NAME=squid
DB_PORT=23798

Create a docker-compose.yaml file:

version: "3"
services:
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: "${DB_NAME}"
      POSTGRES_PASSWORD: postgres
    ports:
      - "${DB_PORT}:5432"

Run the database container:

docker compose up -d

7. Generate and Apply Migrations

Compile the TypeORM classes:

npx tsc

Generate the migration file:

npx squid-typeorm-migration generate

Apply the migration:

npx squid-typeorm-migration apply

8. Create the Main Script

Create src/main.ts and add the following code:

import { EvmBatchProcessor } from '@subsquid/evm-processor';
import { TypeormDatabase } from '@subsquid/typeorm-store';
import { Transaction } from './model';

const ADDRESS = 'TARGET_ADDRESS EG 0x912312321hjahd123'.toLowerCase();

const processor = new EvmBatchProcessor()
    .setRpcEndpoint('https://rpc.socotra-testnet.network/ext/bc/JUNE/rpc')
    .setBlockRange({
        from: 9_083_000
    })
    .setFinalityConfirmation(75)
    .addTransaction({
        from: [ADDRESS],
        traces: true,
    })
    .addTransaction({
        to: [ADDRESS],
    })
    .setFields({
        transaction: {
            from: true,
            to: true,
            value: true,
            hash: true,
        }
    });

processor.run(new TypeormDatabase(), async (ctx) => {
    const txs: Transaction[] = [];
    for (let c of ctx.blocks) {
        for (let txn of c.transactions) {
            const tx = txn as any;
            if (tx.to === ADDRESS || tx.from === ADDRESS) {
                txs.push(new Transaction({
                    id: tx.hash,
                    from: tx.from,
                    to: tx.to,
                    value: tx.value,
                    hash: tx.hash,
                }));
            }
        }
    }

    await ctx.store.insert(txs);
});

9. Compile and Run the Indexer

Compile the code:

npx tsc

Run the indexer:

node -r dotenv/config lib/main.js

10. Check the Results

Use a database management tool like Navicat or TablePlus to verify the stored transactions.

Example :

And that's it! Your simple transaction indexer is ready. Thank you for reading!

What is Juneo Supernet and Why it will become the next big thing?

Raven Arts — Sun, 29 Sep 2024 23:22:12 +0000

Juneo Supernet is a permissionless blockchain protocol derived from Avalanche’s Snowman++ consensus. It aims to provide a highly scalable and efficient infrastructure for decentralized applications (dApps) and decentralized finance (DeFi) solutions. Here’s why Juneo Supernet has the potential to become the next big thing in blockchain:

High Scalability and Throughput

• Juneo Supernet leverages the Snowman++ consensus mechanism, which is designed to provide high scalability and low-latency transactions. This makes it ideal for high-demand applications such as decentralized exchanges (DEXes), gaming platforms, and financial services.
• It also handles thousands of transactions per second (TPS), allowing dApps to scale without compromising performance.

Interoperability with Avalanche Ecosystem

• Juneo Supernet is built with compatibility with the Avalanche ecosystem, allowing developers to easily port over applications from Avalanche to Juneo, expanding the existing DeFi, NFT, and blockchain gaming ecosystems.
• This interoperability enhances user reach and allows integration with other blockchain platforms, which increases the overall adoption potential.

Customizability for Developers

• Juneo is developer-friendly, offering tools like JuneoJS and JuneoGo libraries for easy interaction with the network.
• The flexibility in smart contract development, coupled with its support for both EVM (Ethereum Virtual Machine) and non-EVM contracts, makes it adaptable for various blockchain use cases.
• Developers can deploy custom blockchain environments on Juneo without needing permission, further enhancing its potential for innovation.

Security and Consensus

• Juneo relies on Avalanche’s Snowman++ consensus, which is known for its security, decentralized validation process, and Byzantine Fault Tolerance (BFT), ensuring the network remains robust against attacks.
• Validators in the Juneo network play a critical role in securing the network and maintaining decentralization, making it a reliable platform for DeFi and enterprise solutions.

Tokenomics and Ecosystem Growth

• Juneo has introduced a well-planned tokenomics structure, which includes airdrops and staking incentives designed to promote early participation and long-term sustainability.
• With the distribution of JUNE tokens and an organized reward structure (such as Titan, Orbital, and Odin roles in the ecosystem), the network incentivizes user engagement, liquidity provision, and ecosystem development.

Efficient Governance

• Juneo features a decentralized governance model that allows stakeholders to participate in decision-making processes regarding upgrades, tokenomics, and ecosystem developments. This community-driven governance ensures adaptability and continued growth.

Growing Developer and User Adoption

• As more developers adopt Juneo, tools such as the MCN Web Wallet, MCN Scan, and robust documentation on platforms like docs.juneo.com help streamline the onboarding process.
• Juneo’s focus on building a comprehensive ecosystem, including decentralized finance (DEXs), NFT markets, and gaming, is likely to increase its user base rapidly.

Conclusion

Juneo Supernet has all the ingredients to become a major player in the blockchain space, thanks to its scalability, security, interoperability, and developer-friendly features. Its focus on community-driven growth and innovative dApp ecosystems positions it as a competitive next-generation blockchain platform.

Utilizing JUNEO-JS to do cross chain transaction

Raven Arts — Sun, 01 Sep 2024 08:44:44 +0000

Follow these steps to perform a cross-chain transaction using the JUNEO-JS library.

Create a New Node.js Project
First, create a new Node.js project by running the following command in your terminal:

mkdir juneo-project && cd juneo-project && npm init -y && npm install typescript juneojs && npx tsc --init

Set Up Environment Variables
Next, create an environment file to securely store your mnemonic. Use the following command:

nano .env

Then, add your mnemonic to the .env file like this:

MNEMONIC=yourmnemonichere

Create a Cross-Chain Transaction Script
Create a new TypeScript file to handle the cross-chain transaction:

nano crossJvmToPlatformChain.ts

Copy and paste the following code into the crossJvmToPlatformChain.ts file:

import * as dotenv from 'dotenv'
import {
    CrossOperation,
    type ExecutableOperation,
    type JEVMBlockchain,
    type JVMBlockchain,
    MCNAccount,
    MCNProvider,
    type OperationSummary,
    PlatformBlockchain,
    SocotraNetwork,
} from 'juneojs'

dotenv.config()
async function main() {
    const provider: MCNProvider = new MCNProvider(SocotraNetwork)
    const account: MCNAccount = provider.recoverAccount(process.env.MNEMONIC!)

    // the chain which we will perform the cross from
    const sourceChain: JEVMBlockchain = provider.juneChain

    // the chain we will perform the cross to
    const destinationChain: PlatformBlockchain = provider.platformChain

    // asset id of JUNE Chain is JUNE asset id
    const assetId: string = sourceChain.assetId

    const amount = BigInt(1_000_000_000) // 1 JUNE

    // we instantiate a cross operation that we want to perform
    const cross = new CrossOperation(
        sourceChain,
        destinationChain,
        assetId,
        amount,
    )

    // estimate the operation
    const summary: OperationSummary = await account.estimate(cross)
    console.log(summary.fees)

    // execute the operation
    await account.execute(summary)
    const executable: ExecutableOperation = summary.getExecutable()

    // the receipts should contain multiple transaction ids
    // that were performed to complete the cross operation
    console.log(executable.receipts)
}

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

Save the file by pressing Ctrl + O, then exit with Ctrl + X.

Execute the Script
Finally, run the script to perform the cross-chain transaction:

ts-node crossJvmToPlatformChain.ts

Example Output

Upon successful execution, you should see output similar to the following:

[
  BaseFeeData {
    chain: JEVMBlockchain {
      name: 'JUNE-Chain',
      id: 'BUDQJ63154EiJZwwvukRB1tX3yQCDQdoEYYuCNKEruQ9MjRs4',
      vm: [ChainVM],
      asset: [JEVMGasToken],
      assetId: 'HviVNFzh2nCqyi7bQxw6pt5fUPjZC8r3DCDrt7mRmScZS2zp5',
      aliases: [Array],
      registeredAssets: [Map],
      chainId: 101003n,
      baseFee: 144000000000n,
      ethProvider: JsonRpcProvider {},
      jrc20Assets: [Array],
      wrappedAsset: [WrappedAsset],
      contractManager: [ContractManager]
    },
    asset: JEVMGasToken {
      type: 'gas',
      assetId: 'HviVNFzh2nCqyi7bQxw6pt5fUPjZC8r3DCDrt7mRmScZS2zp5',
      name: 'JUNE',
      symbol: 'JUNE',
      decimals: 18,
      nativeAsset: [JNTAsset]
    },
    amount: 1617120000000000n,
    type: 'Export transaction',
    assetId: 'HviVNFzh2nCqyi7bQxw6pt5fUPjZC8r3DCDrt7mRmScZS2zp5',
    spending: BaseSpending {
      chain: [JEVMBlockchain],
      amount: 1617120000000000n,
      assetId: 'HviVNFzh2nCqyi7bQxw6pt5fUPjZC8r3DCDrt7mRmScZS2zp5'
    }
  },
  BaseFeeData {
    chain: PlatformBlockchain {
      name: 'Platform-Chain',
      id: '11111111111111111111111111111111LpoYY',
      vm: [ChainVM],
      asset: [JNTAsset],
      assetId: 'HviVNFzh2nCqyi7bQxw6pt5fUPjZC8r3DCDrt7mRmScZS2zp5',
      aliases: [Array],
      registeredAssets: [Map],
      stakeConfig: [StakeConfig],
      rewardConfig: [RewardConfig],
      rewardCalculator: [RewardCalculator]
    },
    asset: JNTAsset {
      type: 'jnt',
      assetId: 'HviVNFzh2nCqyi7bQxw6pt5fUPjZC8r3DCDrt7mRmScZS2zp5',
      name: 'JUNE',
      symbol: 'JUNE',
      decimals: 9,
      mintable: false
    },
    amount: 10000000n,
    type: 'Import transaction',
    assetId: 'HviVNFzh2nCqyi7bQxw6pt5fUPjZC8r3DCDrt7mRmScZS2zp5',
    spending: BaseSpending {
      chain: [PlatformBlockchain],
      amount: 10000000n,
      assetId: 'HviVNFzh2nCqyi7bQxw6pt5fUPjZC8r3DCDrt7mRmScZS2zp5'
    }
  }
]
[
  TransactionReceipt {
    chainId: 'BUDQJ63154EiJZwwvukRB1tX3yQCDQdoEYYuCNKEruQ9MjRs4',
    transactionType: 'Export transaction',
    transactionStatus: 'Accepted',
    transactionId: '27KkRyMMrJKvaCNetNQ7Cba3tJABP2nRcsb1aFZm6AJpGsEeLZ'
  },
  TransactionReceipt {
    chainId: '11111111111111111111111111111111LpoYY',
    transactionType: 'Import transaction',
    transactionStatus: 'Committed',
    transactionId: '2htbcJB44LASeoHqwQNMRT5hBRvmEuLpjaJkGP4pvw5vjvEcKr'
  }
]