SDK Examples

Real-world code examples for common SDK tasks.

All examples are verified against the actual chain-sdk source code.

Setup and Initialization

Initialize SDK Client

package main

import (
    "context"
    
    sdkclient "github.com/cosmos/cosmos-sdk/client"
    "github.com/cosmos/cosmos-sdk/crypto/hd"
    "github.com/cosmos/cosmos-sdk/crypto/keyring"
    
    "pkg.akt.dev/go/node/client/discovery"
    "pkg.akt.dev/go/node/client/v1beta3"
)

func main() {
    ctx := context.Background()
    
    // Create client context
    cctx := sdkclient.Context{
        ChainID: "akashnet-2",
        NodeURI: "https://rpc.akashnet.net:443",
    }
    
    // Initialize keyring
    kr, _ := keyring.New("akash", keyring.BackendOS, "/path/to/.akash", nil)
    cctx = cctx.WithKeyring(kr)
    
    // Discover and create client
    client, err := discovery.DiscoverClient(ctx, cctx)
    if err != nil {
        panic(err)
    }
    
    // Client is ready to use
    _ = client
}

SDL Operations

Parse and Validate SDL

package main

import (
    "fmt"
    
    "pkg.akt.dev/go/sdl"
)

func main() {
    // Read SDL from file
    sdlDoc, err := sdl.ReadFile("deploy.yaml")
    if err != nil {
        panic(err)
    }
    
    // Get deployment groups
    groups, err := sdlDoc.DeploymentGroups()
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Deployment has %d groups\n", len(groups))
    
    // Get manifest
    manifest, err := sdlDoc.Manifest()
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Manifest has %d services\n", len(manifest))
}

Query Operations

Query Deployments

package main

import (
    "context"
    "fmt"
    
    dtypes "pkg.akt.dev/go/node/deployment/v1beta4"
)

func queryDeployments(ctx context.Context, client v1beta3.Client, owner string) {
    // Query all deployments for owner
    res, err := client.Query().Deployment().Deployments(ctx, &dtypes.QueryDeploymentsRequest{
        Filters: dtypes.DeploymentFilters{
            Owner: owner,
            State: "active",
        },
    })
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Found %d deployments\n", len(res.Deployments))
    
    for _, dep := range res.Deployments {
        fmt.Printf("Deployment %d: %s\n", dep.Deployment.DeploymentId.DSeq, dep.Deployment.State)
    }
}

Query Providers

package main

import (
    "context"
    "fmt"
    
    ptypes "pkg.akt.dev/go/node/provider/v1beta4"
)

func queryProviders(ctx context.Context, client v1beta3.Client) {
    // Query all providers
    res, err := client.Query().Provider().Providers(ctx, &ptypes.QueryProvidersRequest{})
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Found %d providers\n", len(res.Providers))
    
    for _, provider := range res.Providers {
        fmt.Printf("Provider: %s - %s\n", provider.Owner, provider.HostUri)
    }
}

Query Account Balance

package main

import (
    "context"
    "fmt"
    
    banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
)

func queryBalance(ctx context.Context, client v1beta3.Client, address string) {
    // Query account balance
    res, err := client.Query().Bank().Balance(ctx, &banktypes.QueryBalanceRequest{
        Address: address,
        Denom:   "uakt",
    })
    if err != nil {
        panic(err)
    }
    
    // Convert from uakt to AKT (1 AKT = 1,000,000 uakt)
    akt := float64(res.Balance.Amount.Int64()) / 1000000.0
    fmt.Printf("Balance: %.6f AKT\n", akt)
}

Transaction Operations

Create Deployment

package main

import (
    "context"
    
    sdk "github.com/cosmos/cosmos-sdk/types"
    dtypes "pkg.akt.dev/go/node/deployment/v1beta4"
    "pkg.akt.dev/go/sdl"
)

func createDeployment(ctx context.Context, client v1beta3.Client, sdlPath string) {
    // Parse SDL
    sdlDoc, err := sdl.ReadFile(sdlPath)
    if err != nil {
        panic(err)
    }
    
    // Get deployment groups
    groups, err := sdlDoc.DeploymentGroups()
    if err != nil {
        panic(err)
    }
    
    // Get SDL version hash
    version, err := sdlDoc.Version()
    if err != nil {
        panic(err)
    }
    
    // Get current block height for dseq
    syncInfo, err := client.Node().SyncInfo(ctx)
    if err != nil {
        panic(err)
    }
    
    // Create deployment message
    msg := &dtypes.MsgCreateDeployment{
        ID: dtypes.DeploymentID{
            Owner: client.ClientContext().FromAddress.String(),
            DSeq:  uint64(syncInfo.LatestBlockHeight),
        },
        Hash:    version,
        Groups:  groups,
        Deposit: sdk.NewCoin("uakt", sdk.NewInt(5000000)), // 5 AKT
    }
    
    // Broadcast transaction
    resp, err := client.Tx().BroadcastMsgs(ctx, []sdk.Msg{msg})
    if err != nil {
        panic(err)
    }
    
    client.PrintMessage(resp)
}

Close Deployment

package main

import (
    "context"
    
    sdk "github.com/cosmos/cosmos-sdk/types"
    dtypes "pkg.akt.dev/go/node/deployment/v1beta4"
)

func closeDeployment(ctx context.Context, client v1beta3.Client, dseq uint64) {
    // Create close deployment message
    msg := &dtypes.MsgCloseDeployment{
        ID: dtypes.DeploymentID{
            Owner: client.ClientContext().FromAddress.String(),
            DSeq:  dseq,
        },
    }
    
    // Broadcast transaction
    resp, err := client.Tx().BroadcastMsgs(ctx, []sdk.Msg{msg})
    if err != nil {
        panic(err)
    }
    
    client.PrintMessage(resp)
}

Create Lease

package main

import (
    "context"
    
    sdk "github.com/cosmos/cosmos-sdk/types"
    mtypes "pkg.akt.dev/go/node/market/v1beta5"
)

func createLease(ctx context.Context, client v1beta3.Client, dseq uint64, provider string) {
    // Create lease message
    msg := &mtypes.MsgCreateLease{
        BidID: mtypes.BidID{
            Owner:    client.ClientContext().FromAddress.String(),
            DSeq:     dseq,
            GSeq:     1,
            OSeq:     1,
            Provider: provider,
        },
    }
    
    // Broadcast transaction
    resp, err := client.Tx().BroadcastMsgs(ctx, []sdk.Msg{msg})
    if err != nil {
        panic(err)
    }
    
    client.PrintMessage(resp)
}

Certificate Operations

Generate and Publish Certificate

package main

import (
    "context"
    
    sdk "github.com/cosmos/cosmos-sdk/types"
    ctypes "pkg.akt.dev/go/node/cert/v1"
    cutils "pkg.akt.dev/go/util/tls"
)

func createCertificate(ctx context.Context, client v1beta3.Client) {
    cctx := client.ClientContext()
    
    // Generate certificate
    cert, err := cutils.NewCertificate(cctx.FromAddress.String())
    if err != nil {
        panic(err)
    }
    
    // Create message to publish certificate
    msg := &ctypes.MsgCreateCertificate{
        Owner:  cctx.FromAddress.String(),
        Cert:   cert.PEM.Cert,
        Pubkey: cert.PEM.Pub,
    }
    
    // Broadcast transaction
    resp, err := client.Tx().BroadcastMsgs(ctx, []sdk.Msg{msg})
    if err != nil {
        panic(err)
    }
    
    client.PrintMessage(resp)
}

Provider API Operations

Query Provider Status

package main

import (
    "context"
    "fmt"
    
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    
    ptypes "pkg.akt.dev/go/provider/v1"
)

func getProviderStatus(ctx context.Context, providerURL string) {
    // Connect to provider gRPC endpoint
    conn, err := grpc.Dial(providerURL, grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        panic(err)
    }
    defer conn.Close()
    
    // Create provider client
    client := ptypes.NewProviderRPCClient(conn)
    
    // Get provider status
    status, err := client.GetStatus(ctx, &ptypes.GetStatusRequest{})
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Provider Status:\n")
    fmt.Printf("  Cluster Public Hostname: %s\n", status.ClusterPublicHostname)
    fmt.Printf("  Available Resources: %+v\n", status.AvailableResources)
}

JWT Authentication (Provider API)

Generate JWT Token

import { Secp256k1HdWallet } from "@cosmjs/amino";
import { JwtTokenManager } from "@akashnetwork/chain-sdk";

// Create wallet
const wallet = await Secp256k1HdWallet.fromMnemonic(mnemonic, { 
  prefix: "akash" 
});
const accounts = await wallet.getAccounts();

// Initialize JWT token manager
const tokenManager = new JwtTokenManager(wallet);

// Generate JWT token
const token = await tokenManager.generateToken({
  iss: accounts[0].address,
  exp: Math.floor(Date.now() / 1000) + 3600, // 1 hour expiry
  iat: Math.floor(Date.now() / 1000),
  version: "v1",
  leases: { access: "full" }
});

console.log("JWT Token:", token);

// Use token to authenticate API requests
const leaseStatus = await fetch(
  `https://provider.example.com:8443/lease/1234567/1/1/status`,
  {
    headers: {
      Authorization: `Bearer ${token}`
    }
  }
);

const data = await leaseStatus.json();
console.log("Lease Status:", data);

Note: JWT authentication is the recommended method for provider API access. It’s simpler than mTLS and works even when the blockchain is down.

Access Types:

  • Full Access (AccessTypeFull): Access to all leases for all providers
  • Scoped Access (AccessTypeScoped): Access limited to specific permission scopes
  • Granular Access (AccessTypeGranular): Fine-grained access per deployment/lease

Complete Example: Full Deployment Workflow

import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
import { createChainNodeSDK, SDL } from "@akashnetwork/chain-sdk";

async function deployToAkash() {
  // 1. Initialize wallet
  const mnemonic = "your mnemonic phrase here";
  const wallet = await DirectSecp256k1HdWallet.fromMnemonic(mnemonic, { 
    prefix: "akash" 
  });
  const accounts = await wallet.getAccounts();
  
  // 2. Initialize SDK
  const sdk = createChainNodeSDK({
    query: {
      baseUrl: "https://grpc.akashnet.net:443",
    },
    tx: {
      baseUrl: "https://rpc.akashnet.net:443",
      signer: wallet,
    },
  });
  
  // 3. Parse SDL
  const yaml = `
version: "2.0"
services:
  web:
    image: nginx:1.25.3
    expose:
      - port: 80
        as: 80
        to:
          - global: true
profiles:
  compute:
    web:
      resources:
        cpu:
          units: 0.5
        memory:
          size: 512Mi
        storage:
          size: 512Mi
  placement:
    dcloud:
      pricing:
        web:
          denom: uakt
          amount: 1000
deployment:
  web:
    dcloud:
      profile: web
      count: 1
`;
  
  const sdl = SDL.fromString(yaml, "beta3", "mainnet");
  const groups = sdl.groups();
  
  // 4. Get current block height
  const status = await sdk.cosmos.base.tendermint.v1beta1.getLatestBlock({});
  const dseq = status.block.header.height;
  
  // 5. Create deployment
  const deployment = await sdk.akash.deployment.v1beta4.createDeployment({
    id: {
      owner: accounts[0].address,
      dseq: dseq
    },
    groups: groups,
    deposit: {
      denom: "uakt",
      amount: "5000000"
    },
    depositor: accounts[0].address
  });
  
  console.log("Deployment created with dseq:", dseq);
  
  // 6. Wait for bids (in production, poll or use events)
  await new Promise(resolve => setTimeout(resolve, 30000)); // Wait 30s
  
  // 7. Query bids
  const bids = await sdk.akash.market.v1beta5.getBids({
    filters: {
      owner: accounts[0].address,
      dseq: dseq
    }
  });
  
  console.log(`Received ${bids.bids.length} bids`);
  
  // 8. Accept first bid (create lease)
  if (bids.bids.length > 0) {
    const bid = bids.bids[0];
    const lease = await sdk.akash.market.v1beta5.createLease({
      bidId: bid.bid.bidId
    });
    
    console.log("Lease created with provider:", bid.bid.bidId.provider);
  }
}

deployToAkash().catch(console.error);
Edit page on github
AuthZ & Fee Grants API Reference
footer-logo-dark

© Akash Network 2025 The Akash Network Authors Documentation Distributed under CC BY 4.0

Open-source Apache 2.0 Licensed.

GitHub v0.38.2

Privacy