Accept payments from
any blockchain

// Your first Assembly-BPF program
import { AssemblyBPFSDK, examples } from 'svm-pay/assembly-bpf'

const createHelloWorld = async () => {
  // Use the built-in example
  const { sdk, compilationResult, metadata } = await examples.createHelloWorld()
  
  console.log('✅ Hello World compiled successfully')
  console.log('📜 Assembly:')
  console.log(compilationResult.assembly)
  
  // Output:
  // 0000: ldi     r1, 1745172467 ; Debug: Hello from SVM-Pay Assembly-BPF SDK!
  // 0001: call    1 ; Log debug message
  // 0002: ldi     r0, 0 ; Return success
  // 0003: exit    r0 ; Exit program
}

createHelloWorld()

// Payment processor with fees
import { 
  AssemblyBPFSDK, 
  BPFTemplates, 
  SVMNetwork,
  BPFProgramConfig 
} from 'svm-pay/assembly-bpf'

const createPaymentProcessor = async () => {
  // Configure SDK
  const config: BPFProgramConfig = {
    network: SVMNetwork.SOLANA,
    debug: true
  }
  
  const sdk = new AssemblyBPFSDK(config)
  
  // Create payment processor template
  const { metadata, instructions } = BPFTemplates.createPaymentProcessor({
    networks: [SVMNetwork.SOLANA, SVMNetwork.SONIC],
    feeRate: 0.01, // 1% fee
    maxAmount: 1000000 // Max 1M tokens
  })
  
  // Compile the program
  const result = await sdk.compile(instructions, metadata)
  
  if (result.success) {
    console.log('✅ Payment processor compiled successfully')
    console.log(`📊 Instructions: ${instructions.length}`)
    console.log(`💾 Bytecode size: ${result.bytecode?.length} bytes`)
    console.log(`⚡ Estimated compute units: ${result.computeUnits}`)
  }
  
  return result
}

// Cross-chain bridge implementation
import { 
  AssemblyBPFSDK,
  BPFTemplates,
  BPFProgramBuilder,
  BPFHelpers,
  SVMNetwork
} from 'svm-pay/assembly-bpf'

const createCrossChainBridge = async () => {
  const sdk = new AssemblyBPFSDK({ 
    network: SVMNetwork.SOLANA,
    debug: true 
  })
  
  // Create bridge template
  const { metadata, instructions } = BPFTemplates.createCrossChainBridge({
    supportedNetworks: [
      SVMNetwork.SOLANA,
      SVMNetwork.SONIC,
      SVMNetwork.ECLIPSE,
      SVMNetwork.SOON
    ],
    bridgeFee: 0.005, // 0.5% bridge fee
    minAmount: 1000, // Minimum 1000 tokens
    maxAmount: 10000000 // Maximum 10M tokens
  })
  
  // Build custom program with additional validation
  const builder = sdk.createProgram(metadata)
  
  builder
    .addInstructions(BPFHelpers.createDebugLog('Starting bridge operation'))
    .addValidator() // Add validation layer
    .addInstructions(instructions) // Add bridge logic
    .addInstructions(BPFHelpers.createDebugLog('Bridge operation completed'))
  
  // Compile with optimizations
  const result = await builder.compile({
    optimize: true,
    targetNetwork: SVMNetwork.SOLANA
  })
  
  console.log('🌉 Cross-chain bridge compiled:')
  console.log(`📊 Instructions: ${result.instructionCount}`)
  console.log(`💾 Bytecode: ${result.bytecode?.length} bytes`)
  console.log(`⚡ Compute units: ${result.computeUnits}`)
  
  return result
}

// Advanced memory management
import { 
  AssemblyBPFSDK,
  BPFMemoryManager,
  BPFSyscallHelper,
  BPFInstruction,
  BPFRegister,
  SVMNetwork
} from 'svm-pay/assembly-bpf'

const createAdvancedProgram = async () => {
  const sdk = new AssemblyBPFSDK({ network: SVMNetwork.SOLANA })
  
  // Create custom memory structures
  const paymentStruct = BPFMemoryManager.createStruct([
    { name: 'amount', type: 'u64', offset: 0 },
    { name: 'recipient', type: 'pubkey', offset: 8 },
    { name: 'fee', type: 'u64', offset: 40 },
    { name: 'timestamp', type: 'u64', offset: 48 }
  ])
  
  // Allocate stack space
  const stackPtr = BPFMemoryManager.allocateStack(128)
  
  // Create syscall helper
  const syscalls = new BPFSyscallHelper(SVMNetwork.SOLANA)
  
  // Build program with custom instructions
  const instructions = [
    // Load payment amount
    {
      opcode: BPFInstruction.LOAD_IMM,
      dst: BPFRegister.R1,
      immediate: 1000000, // 1M tokens
      comment: 'Load payment amount'
    },
    
    // Validate amount using syscall
    syscalls.validateAmount(BPFRegister.R1),
    
    // Store to memory structure
    {
      opcode: BPFInstruction.STORE_MEM,
      dst: BPFRegister.R10,
      src: BPFRegister.R1,
      offset: paymentStruct.fields.amount.offset,
      comment: 'Store amount to payment struct'
    },
    
    // Get current timestamp
    syscalls.getCurrentTimestamp(BPFRegister.R2),
    
    // Store timestamp
    {
      opcode: BPFInstruction.STORE_MEM,
      dst: BPFRegister.R10,
      src: BPFRegister.R2,
      offset: paymentStruct.fields.timestamp.offset,
      comment: 'Store timestamp'
    },
    
    // Process payment
    syscalls.processPayment(stackPtr),
    
    // Return success
    {
      opcode: BPFInstruction.LOAD_IMM,
      dst: BPFRegister.R0,
      immediate: 0,
      comment: 'Return success'
    },
    
    {
      opcode: BPFInstruction.EXIT,
      src: BPFRegister.R0,
      comment: 'Exit program'
    }
  ]
  
  const metadata = {
    name: 'advanced-payment-processor',
    version: '1.0.0',
    description: 'Advanced payment processor with custom memory management',
    networks: [SVMNetwork.SOLANA],
    computeUnits: 1000
  }
  
  const result = await sdk.compile(instructions, metadata)
  console.log('🔧 Advanced program compiled:', result.success)
  
  return result
}