undefined

undefined

import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import { mplCore } from '@metaplex-foundation/mpl-core';
import {
  keypairIdentity,
  generateSigner
} from '@metaplex-foundation/umi';

// Create Umi instance
const umi = createUmi('https://api.mainnet-beta.solana.com')
  .use(mplCore());

// Option 1: Use generated keypair
const signer = generateSigner(umi);
umi.use(keypairIdentity(signer));

// Option 2: Use existing keypair
import { createSignerFromKeypair } from '@metaplex-foundation/umi';
const keypair = umi.eddsa.createKeypairFromSecretKey(secretKeyBytes);
const signer = createSignerFromKeypair(umi, keypair);
umi.use(keypairIdentity(signer));

// Option 3: Use wallet adapter (browser)
import { walletAdapterIdentity } from '@metaplex-foundation/umi-signer-wallet-adapters';
umi.use(walletAdapterIdentity(wallet));

import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import {
  mplCore,
  create,
  fetchAsset
} from '@metaplex-foundation/mpl-core';
import {
  generateSigner,
  keypairIdentity
} from '@metaplex-foundation/umi';
import { irysUploader } from '@metaplex-foundation/umi-uploader-irys';

// Setup
const umi = createUmi('https://api.mainnet-beta.solana.com')
  .use(mplCore())
  .use(irysUploader());

// Upload metadata
const metadata = {
  name: 'My Core NFT',
  description: 'A next-gen NFT on Solana',
  image: 'https://arweave.net/your-image',
  attributes: [
    { trait_type: 'Background', value: 'Blue' },
    { trait_type: 'Rarity', value: 'Legendary' }
  ]
};
const metadataUri = await umi.uploader.uploadJson(metadata);

// Create NFT
const asset = generateSigner(umi);
await create(umi, {
  asset,
  name: 'My Core NFT',
  uri: metadataUri,
}).sendAndConfirm(umi);

console.log('Asset created:', asset.publicKey);

// Fetch the asset
const fetchedAsset = await fetchAsset(umi, asset.publicKey);
console.log('Asset data:', fetchedAsset);

import {
  create,
  ruleSet,
  plugin,
} from '@metaplex-foundation/mpl-core';

// Create with royalty enforcement
await create(umi, {
  asset,
  name: 'Royalty Enforced NFT',
  uri: metadataUri,
  plugins: [
    {
      type: 'Royalties',
      basisPoints: 500, // 5%
      creators: [
        { address: creatorAddress, percentage: 100 }
      ],
      ruleSet: ruleSet('None'), // or 'ProgramAllowList', 'ProgramDenyList'
    },
    {
      type: 'FreezeDelegate',
      frozen: false,
      authority: { type: 'Owner' },
    },
    {
      type: 'TransferDelegate',
      authority: { type: 'Owner' },
    },
  ],
}).sendAndConfirm(umi);

import {
  createCollection,
  create,
  fetchCollection,
} from '@metaplex-foundation/mpl-core';

// Create collection
const collection = generateSigner(umi);
await createCollection(umi, {
  collection,
  name: 'My Collection',
  uri: collectionUri,
}).sendAndConfirm(umi);

// Create asset in collection
const asset = generateSigner(umi);
await create(umi, {
  asset,
  name: 'Collection Item #1',
  uri: assetUri,
  collection: collection.publicKey,
}).sendAndConfirm(umi);

import { transfer, burn } from '@metaplex-foundation/mpl-core';

// Transfer
await transfer(umi, {
  asset: assetPublicKey,
  newOwner: recipientPublicKey,
}).sendAndConfirm(umi);

// Burn
await burn(umi, {
  asset: assetPublicKey,
}).sendAndConfirm(umi);

import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import {
  mplTokenMetadata,
  createNft,
  fetchDigitalAsset,
} from '@metaplex-foundation/mpl-token-metadata';
import { generateSigner, percentAmount } from '@metaplex-foundation/umi';

const umi = createUmi('https://api.mainnet-beta.solana.com')
  .use(mplTokenMetadata());

// Create NFT
const mint = generateSigner(umi);
await createNft(umi, {
  mint,
  name: 'My NFT',
  symbol: 'MNFT',
  uri: 'https://arweave.net/metadata.json',
  sellerFeeBasisPoints: percentAmount(5.5), // 5.5% royalty
  creators: [
    { address: umi.identity.publicKey, share: 100, verified: true }
  ],
}).sendAndConfirm(umi);

// Fetch NFT
const asset = await fetchDigitalAsset(umi, mint.publicKey);
console.log(asset);

import {
  createProgrammableNft,
  TokenStandard,
} from '@metaplex-foundation/mpl-token-metadata';

// pNFTs have enforced royalties
const mint = generateSigner(umi);
await createProgrammableNft(umi, {
  mint,
  name: 'My pNFT',
  uri: metadataUri,
  sellerFeeBasisPoints: percentAmount(10), // 10% royalty
  ruleSet: ruleSetPublicKey, // Optional: custom rules
}).sendAndConfirm(umi);

import {
  createFungible,
  mintV1,
  TokenStandard,
} from '@metaplex-foundation/mpl-token-metadata';

// Create fungible token
const mint = generateSigner(umi);
await createFungible(umi, {
  mint,
  name: 'My Token',
  symbol: 'MTK',
  uri: 'https://arweave.net/token-metadata.json',
  sellerFeeBasisPoints: percentAmount(0),
  decimals: 9,
}).sendAndConfirm(umi);

// Mint tokens
await mintV1(umi, {
  mint: mint.publicKey,
  amount: 1_000_000_000n, // 1 token with 9 decimals
  tokenOwner: recipientPublicKey,
  tokenStandard: TokenStandard.Fungible,
}).sendAndConfirm(umi);

import { updateV1 } from '@metaplex-foundation/mpl-token-metadata';

await updateV1(umi, {
  mint: mintPublicKey,
  data: {
    name: 'Updated Name',
    symbol: 'UPDT',
    uri: 'https://arweave.net/new-metadata.json',
    sellerFeeBasisPoints: 500,
    creators: null, // Keep existing
  },
}).sendAndConfirm(umi);

import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import {
  mplBubblegum,
  createTree,
} from '@metaplex-foundation/mpl-bubblegum';
import { generateSigner } from '@metaplex-foundation/umi';

const umi = createUmi('https://api.mainnet-beta.solana.com')
  .use(mplBubblegum());

// Create tree (max depth determines capacity)
// maxDepth 14 = 16,384 NFTs, maxDepth 20 = 1,048,576 NFTs
const merkleTree = generateSigner(umi);
await createTree(umi, {
  merkleTree,
  maxDepth: 14,
  maxBufferSize: 64,
}).sendAndConfirm(umi);

console.log('Tree created:', merkleTree.publicKey);

import { mintV1 } from '@metaplex-foundation/mpl-bubblegum';

await mintV1(umi, {
  leafOwner: recipientPublicKey,
  merkleTree: merkleTreePublicKey,
  metadata: {
    name: 'Compressed NFT #1',
    symbol: 'CNFT',
    uri: 'https://arweave.net/metadata.json',
    sellerFeeBasisPoints: 500,
    collection: { key: collectionMint, verified: false },
    creators: [
      { address: umi.identity.publicKey, share: 100, verified: true }
    ],
  },
}).sendAndConfirm(umi);

import { mintToCollectionV1 } from '@metaplex-foundation/mpl-bubblegum';

await mintToCollectionV1(umi, {
  leafOwner: recipientPublicKey,
  merkleTree: merkleTreePublicKey,
  collectionMint: collectionMintPublicKey,
  metadata: {
    name: 'Collection cNFT #1',
    symbol: 'CCNFT',
    uri: metadataUri,
    sellerFeeBasisPoints: 500,
    creators: [
      { address: umi.identity.publicKey, share: 100, verified: true }
    ],
  },
}).sendAndConfirm(umi);

import { transfer } from '@metaplex-foundation/mpl-bubblegum';
import { getAssetWithProof } from '@metaplex-foundation/mpl-bubblegum';

// Get asset with proof from DAS API
const assetWithProof = await getAssetWithProof(umi, assetId);

await transfer(umi, {
  ...assetWithProof,
  leafOwner: currentOwner,
  newLeafOwner: newOwner,
}).sendAndConfirm(umi);

import { decompressV1 } from '@metaplex-foundation/mpl-bubblegum';

// Decompress creates on-chain Token Metadata NFT
await decompressV1(umi, {
  ...assetWithProof,
  mint: mintSigner,
}).sendAndConfirm(umi);

import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import {
  mplCandyMachine,
  create,
  addConfigLines,
} from '@metaplex-foundation/mpl-candy-machine';
import { generateSigner, some, sol, dateTime } from '@metaplex-foundation/umi';

const umi = createUmi('https://api.mainnet-beta.solana.com')
  .use(mplCandyMachine());

// Create candy machine
const candyMachine = generateSigner(umi);
const collection = generateSigner(umi);

await create(umi, {
  candyMachine,
  collection: collection.publicKey,
  collectionUpdateAuthority: umi.identity,
  itemsAvailable: 1000,
  sellerFeeBasisPoints: percentAmount(5),
  creators: [
    { address: umi.identity.publicKey, percentageShare: 100, verified: true }
  ],
  configLineSettings: some({
    prefixName: 'My NFT #',
    nameLength: 4,
    prefixUri: 'https://arweave.net/',
    uriLength: 43,
    isSequential: false,
  }),
  guards: {
    botTax: some({ lamports: sol(0.01), lastInstruction: true }),
    solPayment: some({ lamports: sol(0.5), destination: treasury }),
    startDate: some({ date: dateTime('2024-01-01T00:00:00Z') }),
    mintLimit: some({ id: 1, limit: 3 }),
  },
}).sendAndConfirm(umi);

await addConfigLines(umi, {
  candyMachine: candyMachine.publicKey,
  index: 0,
  configLines: [
    { name: '0001', uri: 'abc123...' },
    { name: '0002', uri: 'def456...' },
    { name: '0003', uri: 'ghi789...' },
  ],
}).sendAndConfirm(umi);

import {
  mintV1,
  fetchCandyMachine,
  fetchCandyGuard,
} from '@metaplex-foundation/mpl-candy-machine';

const candyMachine = await fetchCandyMachine(umi, candyMachinePublicKey);
const candyGuard = await fetchCandyGuard(umi, candyMachine.mintAuthority);

const nftMint = generateSigner(umi);

await mintV1(umi, {
  candyMachine: candyMachine.publicKey,
  candyGuard: candyGuard.publicKey,
  nftMint,
  collectionMint: candyMachine.collectionMint,
  collectionUpdateAuthority: candyMachine.authority,
  mintArgs: {
    solPayment: some({ destination: treasury }),
    mintLimit: some({ id: 1 }),
  },
}).sendAndConfirm(umi);

import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import {
  mplGenesis,
  createGenesis,
  addBucket,
  finalize,
} from '@metaplex-foundation/mpl-genesis';

const umi = createUmi('https://api.mainnet-beta.solana.com')
  .use(mplGenesis());

// Create genesis account
const genesis = generateSigner(umi);
await createGenesis(umi, {
  genesis,
  name: 'My Token',
  symbol: 'MTK',
  uri: 'https://arweave.net/token-metadata.json',
  decimals: 9,
  totalSupply: 1_000_000_000n * 10n ** 9n, // 1 billion tokens
}).sendAndConfirm(umi);

// Add presale bucket
await addBucket(umi, {
  genesis: genesis.publicKey,
  bucket: {
    type: 'Presale',
    price: sol(0.001), // 0.001 SOL per token
    maxTokens: 100_000_000n * 10n ** 9n, // 100M tokens
    startTime: dateTime('2024-06-01T00:00:00Z'),
    endTime: dateTime('2024-06-07T00:00:00Z'),
  },
}).sendAndConfirm(umi);

// Finalize (locks configuration)
await finalize(umi, {
  genesis: genesis.publicKey,
}).sendAndConfirm(umi);

import { deposit, claim } from '@metaplex-foundation/mpl-genesis';

// Deposit SOL
await deposit(umi, {
  genesis: genesisPublicKey,
  amount: sol(10), // 10 SOL
}).sendAndConfirm(umi);

// After launch ends, claim tokens
await claim(umi, {
  genesis: genesisPublicKey,
}).sendAndConfirm(umi);

import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import {
  mplHybrid,
  createEscrow,
  swapNftToToken,
  swapTokenToNft,
} from '@metaplex-foundation/mpl-hybrid';

const umi = createUmi('https://api.mainnet-beta.solana.com')
  .use(mplHybrid());

// Create escrow for swapping
await createEscrow(umi, {
  escrow: escrowSigner,
  collection: collectionPublicKey,
  token: tokenMint,
  feeWallet: feeWallet,
  name: 'My Hybrid Collection',
  uri: 'https://arweave.net/escrow-metadata.json',
  max: 10000n,
  min: 0n,
  amount: 1000n, // Tokens per NFT
  feeAmount: sol(0.005),
  path: 0,
}).sendAndConfirm(umi);

// Swap NFT for tokens
await swapNftToToken(umi, {
  escrow: escrowPublicKey,
  asset: nftPublicKey,
}).sendAndConfirm(umi);

// Swap tokens for NFT
await swapTokenToNft(umi, {
  escrow: escrowPublicKey,
}).sendAndConfirm(umi);