JavaScript SDK

npm install @kabila-tech/kabila-sdk-js

import { KabilaSdk } from '@kabila-tech/kabila-sdk-js';

const kabilaSdk = new KabilaSdk();

const result = await kabilaSdk.marketManager.nftItems.getItems(
  {
    limit: 10,
    skip: 0,
    orderBy: 'serialNumber',
    fields: ['tokenId', 'name', 'price', 'serialNumber', 'sellerId']
  },
  {
    tokenId: '0.0.2179656',
    filterAttributes: {
      Body: ['Green', 'X Ray'],
      Feet: ['Barefoot']
    }
  }
);

import { KabilaSdk, AuthUtils } from '@kabila-tech/kabila-sdk-js';
import { DAppConnector, SignMessageParams } from '@hashgraph/hedera-wallet-connect';

// ⚠️  IMPORTANT: Initialize your own DAppConnector instance
// const dAppConnector = new DAppConnector(...);
// await dAppConnector.init({ logger: 'error' });

/* 🔑 Step 1: Sign message */
const address = '0.0.1234';
const params: SignMessageParams = {
  signerAccountId: 'hedera:mainnet:' + address,
  message: AuthUtils.getKabilaAuthMessage()
};

const { signatureMap } = await dAppConnector.signMessage(params);

/* 🔐 Step 2: Login */
const {
  data: { token, publicKey }
} = await kabilaSdk.users.login(address, signatureMap);
kabilaSdk.setAuth(token);

/* 📋 Step 3: Get offers */
const result = await kabilaSdk.marketManager.userOffers.getOffersReceived(address, { limit: 10 });

import { KabilaSdk } from '@kabila-tech/kabila-sdk-js';
import { DAppConnector, SignTransactionParams } from '@hashgraph/hedera-wallet-connect';
import { AccountAllowanceApproveTransaction, NftId, TokenId } from '@hashgraph/sdk';

const tokenId = '0.0.123';
const serialNumber = 155;

/* 🛒 Step 1: Get purchase transaction */
const { data: transaction } = await kabilaSdk.marketManager.nftItems.getNftItemsPurchaseTransaction([
  { tokenId, serialNumber }
]);

/* ✍️ Step 2: Sign transaction */
const params: SignTransactionParams = {
  signerAccountId: 'hedera:mainnet:' + address,
  transactionBody: transaction.transaction
};

const { signatureMap } = await dAppConnector.signTransaction(params);

/* ✅ Step 3: Execute transaction */
await kabilaSdk.marketManager.nftItems.executeNftItemsPurchaseTransaction(signatureMap);

import { KabilaSdk, WHBAR_TOKEN_ID, MARKET_ACCOUNT_ID } from '@kabila-tech/kabila-sdk-js';
import { DAppConnector, SignTransactionParams } from '@hashgraph/hedera-wallet-connect';

const nftItemsToList: NftItemCreation[] = [
  {
    tokenId: '0.0.2179656',
    serialNumber: 1000,
    allowOffers: true,
    currency: WHBAR_TOKEN_ID,
    minOfferPrice: 300,
    price: 500
  }
];

/* 🔐 Step 1: Give allowance to MARKET_ACCOUNT_ID */
const client = Client.forTestnet();
const signer = dAppConnector.getSigner(AccountId.fromString(buyerAccountId));

const allowanceTx = new AccountAllowanceApproveTransaction()
  .approveTokenNftAllowance(
    new NftId(TokenId.fromString(nftItemsToList[0].tokenId), nftItemsToList[0].serialNumber),
    AccountId.fromString(buyerAccountId),
    AccountId.fromString(MARKET_ACCOUNT_ID)
  )
  .setTransactionId(TransactionId.generate(accountId))
  .setNodeAccountIds([<nodeAccountId>])
  .freeze();

const allowanceTxSigned = await signer.signTransaction(allowanceTx);
await allowanceTxSigned.execute(client);

/* 📋 Step 2: List NFT */
const { data: nftItemsListed } = await kabilaSdk.marketManager.nftItems.listNftItem(nftItemsToList);

import { AuthUtils } from '@kabila-tech/kabila-sdk-js';

/* 🔑 Get signature for sensitive operations */
const params: SignMessageParams = {
  signerAccountId: 'hedera:mainnet:' + address,
  message: AuthUtils.getKabilaAuthMessage5min()
};

const { signatureMap } = await dAppConnector.signMessage(params);
const signature = signatureMap; // Use this signature in the methods below

/* 🏷️ Update NFT price */
const priceUpdate = {
  signature: signatureMap,
  price: 100,
  currency: WHBAR_TOKEN_ID,
  allowOffers: true,
  minOfferPrice: 50
};
await kabilaSdk.marketManager.nftItems.updateNftItemPrice(tokenId, serialNumber, priceUpdate);

/* 🗑️ Delist NFT */
const delistData = {
  signature: signatureMap,
  nftItems: [{ tokenId, serialNumber }]
};
await kabilaSdk.marketManager.nftItems.delistNftItem(delistData);

/* 💰 Update offer */
// Buyer updates offer (requires allowance, no signature)
const buyerOfferUpdate = {
  price: 80,
  signature: undefined
};
await kabilaSdk.marketManager.nftItemsOffers.updateNftItemOffer(offerId, buyerOfferUpdate);

// Seller updates offer (requires signature, no allowance)
const sellerOfferUpdate = {
  price: 90,
  signature: signatureMap
};
await kabilaSdk.marketManager.nftItemsOffers.updateNftItemOffer(offerId, sellerOfferUpdate);

login(accountId: string, signature: string): ApiResult<{ token: string; publicKey: string }>

getActivity(requestOptions?: RequestOptions, extraFilters?: Object): ApiResult<NftItemActivity[]>

WHBAR_TOKEN_ID = '0.0.1062664';

interface ApiResult<T> {
  data: T; // The actual response data
  status: number; // HTTP status code
  statusText: string; // HTTP status text
  headers: {}; // Response headers
}

interface RequestOptions {
  limit: number; // Number of items to return
  skip: number; // Number of items to skip (for pagination)
  fields: string[]; // Specific fields to return
  search: string; // Search term for filtering
  orderBy: string | string[]; // Field(s) to order by
  orderDir: string | string[]; // Order direction ('asc' or 'desc')
  format: Format; // Response format
  auth: string; // Authentication token (Bearer token)
}

enum Format {
  WITH_PAGINATION = 'WITH_PAGINATION', // Include pagination metadata
  NO_PAGINATION = 'NO_PAGINATION' // Return only data without pagination
}

interface NftItem {
  _id?: string; // Database ID
  allowOffers: boolean; // Whether offers are allowed
  attributes?: {
    // NFT attributes/traits
    traitType: string; // Attribute category
    value: string; // Attribute value
  };
  buyerId?: string; // Current buyer ID
  createdAt: Date; // Listing creation date
  currency: string; // Currency token ID
  description?: string; // NFT description
  endDate?: Date; // Auction end date
  imageCid?: string; // Image CID
  imageType?: string; // Image MIME type
  metadataCid?: string; // Metadata CID
  minOfferPrice?: number; // Minimum offer price
  name?: string; // NFT name
  price: number; // Current price
  rarity?: {
    // Rarity information
    rank?: number; // Rarity rank
    rarityScore?: number; // Rarity score
  };
  sellerId: string; // Seller account ID
  serialNumber: number; // NFT serial number
  status?: string; // Current status
  statusDate: Date; // Status update date
  tokenId: string; // Token ID
}

interface NftItemCreation {
  allowOffers: boolean; // Whether offers are allowed
  currency: string; // Currency token ID
  minOfferPrice: number; // Minimum offer price
  price: number; // Listing price
  serialNumber: number; // NFT serial number
  tokenId: string; // Token ID
}

interface NftItemId {
  serialNumber: number; // NFT serial number
  tokenId: string; // Token ID
}

interface NftItemPriceEdition {
  signature: string; // Required signature for price updates
  allowOffers: boolean; // Whether offers are allowed
  currency: string; // Currency token ID
  minOfferPrice?: number; // Minimum offer price
  price: number; // New price
}

interface NftItemDelist {
  signature: string; // Required signature for delisting
  nftItems: NftItemId[]; // Array of NFTs to delist
}

interface NftCollection {
  _id?: string; // Database ID
  attributes?: Attribute[]; // Collection attributes
  createdAt?: Date; // Creation date
  creatorId?: string; // Creator account ID
  creatorName?: string; // Creator name
  description?: string; // Collection description
  highestCollectionOffer?: number; // Highest offer received
  holders?: number; // Number of holders
  imageCid: string; // Collection image CID
  imageType: string; // Image MIME type
  mainTag?: string; // Main category tag
  minPrice?: number; // Minimum price in collection
  minted?: number; // Number of minted NFTs
  name?: string; // Collection name
  networkVolume?: number; // Total trading volume
  nftsListed?: number; // Number of listed NFTs
  salesVolume: NftCollectionSalesVolume; // Network sales volume
  slug?: string; // Collection slug
  socialNetworks?: Array<string>; // Social media links
  supply?: number; // Total supply
  tokenId?: string; // Token ID
  verificationType?: number; // Verification status
}

interface Attribute {
  count: number; // Number of NFTs with this attribute
  currency?: string; // Currency for pricing
  minPrice?: number; // Minimum price for this attribute
  rarityPct?: number; // Rarity percentage
  total?: number; // Total count
  traitType: string; // Attribute category
  value: string; // Attribute value
}

interface Attributes {
  attribute: Array<Attribute>; // Array of attributes
}

interface NftCollectionNftItemsRarity {
  _id?: string; // Database ID
  nftItemsRarityMap?: NftItemsRarityMap[]; // Rarity mappings
  tokenId?: string; // Token ID
}

interface NftItemsRarity {
  rank: number; // Rarity rank
  rarityScore: number; // Rarity score
}

interface NftItemsRarityMap {
  serialNumber: NftItemsRarity; // Serial number mapped to rarity
}

interface NftStatusMap {
  [key: number]: boolean; // Serial number to status mapping
}

interface NftCollectionSalesVolume {
  updatedAt: Date; // Last update date
  last24h: number; // Sales volume in the last 24 hours
  previous24h: number; // Sales volume in the previous 24 hours
  last7d: number; // Sales volume in the last 7 days
  previous7d: number; // Sales volume in the previous 7 days
  last30d: number; // Sales volume in the last 30 days
  previous30d: number; // Sales volume in the previous 30 days
}

interface NftItemOffer {
  _id?: string; // Database ID
  buyerId: string; // Buyer account ID
  buyerPrice: number; // Buyer's offer price
  createdAt: Date; // Offer creation date
  currency: string; // Currency token ID
  initialPrice: number; // Initial offer price
  lastBidder: 'BUYER' | 'SELLER'; // Who made the last bid
  nftItem?: {
    // Associated NFT information
    imageCid: string; // NFT image CID
    imageType: string; // Image MIME type
    name: string; // NFT name
  };
  sellerId?: string; // Seller account ID
  sellerPrice?: number; // Seller's counter-offer
  serialNumber: number; // NFT serial number
  tokenId: string; // Token ID
  updatedAt: Date; // Last update date
}

interface NftItemOfferCreation {
  currency: string; // Currency token ID
  price: number; // Offer price
  serialNumber: number; // NFT serial number
  tokenId: string; // Token ID
}

interface NftItemOfferEdition {
  buyerId: string; // Buyer account ID
  buyerPrice: number; // Buyer's offer price
  currency: string; // Currency token ID
  sellerId: string; // Seller account ID
  sellerPrice: number; // Seller's counter-offer
  tokenId: string; // Token ID
}

interface NftCollectionOffer {
  _id?: string; // Database ID
  buyerId: string; // Buyer account ID
  tokenId: string; // Token ID
  price: number; // Offer price
  currency: string; // Currency token ID
  createdAt: string; // Creation date
  status?: string; // Offer status
  statusDate?: string; // Status update date
}

interface NftCollectionOfferCreation {
  tokenId: string; // Token ID
  price: number; // Offer price
  currency: string; // Currency token ID
}

interface NftCollectionOfferAcceptance {
  id: string; // Offer ID
  serialNumber: number; // NFT serial number
}

interface UserOffer extends NftItemOffer {
  totalBuyerPrice: number; // Total price from buyer
  nftItemListed: NftItem; // Associated NFT item
}

interface UserOfferPrice {
  totalPriceCollectionsOffers: number; // Total collection offers
  totalPriceNftItemsOffers: number; // Total NFT item offers
  totalPrice: number; // Combined total
}

interface NftItemActivity {
  tokenId: string; // Token ID
  serialNumber: number; // Serial number
  collectionName: string; // Collection name
  verificationType: number; // Verification type
  name: string; // NFT name
  imageCid: string; // Image CID
  imageType: string; // Image type
  rank: number; // Rarity rank
  activityType: string; // Activity type
  subactivityType: string; // Sub-activity type
  price: number; // Price
  currency: string; // Currency
  priceUsd: number; // Price in USD
  buyerId: string; // Buyer ID
  sellerId: string; // Seller ID
  createdAt: string; // Creation date
  listedAt: string; // Listing date
  additionalId: number; // Additional ID
  transactionId: string; // Transaction ID
}