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, generateManifest, yaml, type SDLInput } 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. Define and generate manifest from SDL
const sdl: SDLInput = 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 result = generateManifest(sdl);

if (!result.ok) {
  throw new Error("SDL validation failed: " + JSON.stringify(result.value));
}

const { groupSpecs } = result.value;

// 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: groupSpecs,
  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