import { TokenService } from '@chainportal/sdk';
 
const tokenService = new TokenService(publicClient, walletClient);
 
// Create a new token
const tx = await tokenService.createToken({
  name: 'My Token',
  symbol: 'MTK',
  initialSupply: '1000000',
  decimals: 18,
  features: {
    mintable: true,
    burnable: true,
    pausable: false,
    taxable: false,
  },
});
 
// Manage existing token
await tokenService.mint(tokenAddress, recipientAddress, amount);
await tokenService.burn(tokenAddress, amount);
await tokenService.transfer(tokenAddress, to, amount);

import { NFTService } from '@chainportal/sdk';
 
const nftService = new NFTService(publicClient, walletClient);
 
// Create ERC721 collection
const tx = await nftService.createCollection({
  name: 'My NFT',
  symbol: 'MNFT',
  baseURI: 'ipfs://Qm.../metadata/',
  maxSupply: 10000,
  mintPrice: '0.05',
  royaltyBps: 500, // 5%
});
 
// Mint NFTs
await nftService.mint(collectionAddress, to, quantity);
await nftService.setMintPhase(collectionAddress, 'public');

import { AirdropService } from '@chainportal/sdk';
 
const airdropService = new AirdropService(publicClient, walletClient);
 
// Batch transfer with custom amounts
await airdropService.batchTransfer(tokenAddress, [
  { address: '0x...', amount: '1000' },
  { address: '0x...', amount: '2500' },
]);
 
// Equal distribution
await airdropService.airdropEqual(tokenAddress, addresses, '100');
 
// Parse CSV file
const rows = AirdropService.parseCSV(csvContent);

import { SolanaTokenService } from '@chainportal/sdk';
 
const service = new SolanaTokenService(connection, wallet);
 
// Create SPL token
const { mint, tx } = await service.createToken({
  name: 'My SPL Token',
  symbol: 'MSPL',
  decimals: 9,
  initialSupply: 1_000_000,
  uri: 'https://arweave.net/metadata.json',
});
 
// Mint additional tokens
await service.mintTo(mintAddress, destinationAta, amount);

import { SolanaNFTService } from '@chainportal/sdk';
 
const service = new SolanaNFTService(connection, wallet);
 
// Create collection
const { collectionMint } = await service.createCollection({
  name: 'My Collection',
  symbol: 'MCOL',
  uri: 'https://arweave.net/collection.json',
  sellerFeeBasisPoints: 500,
});
 
// Mint NFT into collection
await service.mintNFT({
  collection: collectionMint,
  name: 'NFT #1',
  uri: 'https://arweave.net/nft1.json',
});

import { CosmosTokenService } from '@chainportal/sdk';
 
const service = new CosmosTokenService(signingClient, senderAddress);
 
// Instantiate CW20 token
const { contractAddress } = await service.createToken({
  name: 'Cosmos Token',
  symbol: 'CTK',
  decimals: 6,
  initialSupply: '1000000000000',
  mintable: true,
});
 
// CW20 operations
await service.transfer(contractAddress, recipient, amount);
await service.mint(contractAddress, recipient, amount);

import { CosmosNFTService } from '@chainportal/sdk';
 
const service = new CosmosNFTService(signingClient, senderAddress);
 
const { contractAddress } = await service.createCollection({
  name: 'Cosmos NFTs',
  symbol: 'CNFT',
  minter: senderAddress,
});
 
await service.mint(contractAddress, {
  tokenId: '1',
  owner: recipient,
  tokenUri: 'ipfs://...',
});

import { AptosTokenService } from '@chainportal/sdk';
 
const service = new AptosTokenService(aptosClient);
 
const tx = await service.createFungibleAsset({
  name: 'Aptos Token',
  symbol: 'APT',
  decimals: 8,
  initialSupply: '100000000',
  iconUri: 'https://...',
  projectUri: 'https://...',
});

import { AptosNFTService } from '@chainportal/sdk';
 
const service = new AptosNFTService(aptosClient);
 
const tx = await service.createCollection({
  name: 'Aptos NFTs',
  description: 'A collection on Aptos',
  uri: 'https://...',
  maxSupply: 10000,
  royaltyBps: 500,
});

import { SuiTokenService } from '@chainportal/sdk';
 
const service = new SuiTokenService(suiClient);
 
// Register existing coin (SUI requires module deployment first)
const tx = await service.registerCoin({
  coinMetadataId: '0x...',
  name: 'SUI Coin',
  symbol: 'SC',
  decimals: 9,
});

import { SuiNFTService } from '@chainportal/sdk';
 
const service = new SuiNFTService(suiClient);
 
const tx = await service.createCollection({
  name: 'SUI NFTs',
  description: 'NFT collection on SUI',
  imageUrl: 'https://...',
  royaltyBps: 500,
});

import { NearTokenService } from '@chainportal/sdk';
 
const service = new NearTokenService(nearConnection, accountId);
 
const tx = await service.createToken({
  name: 'NEAR Token',
  symbol: 'NTK',
  decimals: 24,
  totalSupply: '1000000000000000000000000000000',
  icon: 'data:image/svg+xml,...',
});

import { NearNFTService } from '@chainportal/sdk';
 
const service = new NearNFTService(nearConnection, accountId);
 
const tx = await service.createCollection({
  name: 'NEAR NFTs',
  symbol: 'NNFT',
  baseUri: 'https://...',
});
 
await service.mint('1', recipientId, {
  title: 'NFT #1',
  description: 'First NFT',
  media: 'https://...',
});