const { StrictMode } = require("react");

module.exports = {
  StrictMode: false,
  root: true,
  extends: '@react-native',
};


module.exports = {
  arrowParens: 'avoid',
  bracketSameLine: true,
  bracketSpacing: false,
  singleQuote: true,
  trailingComma: 'all',
};


module.exports = {
  presets: ['module:@react-native/babel-preset'],
  plugins: [
    'react-native-reanimated/plugin',
    [
      'module:react-native-dotenv',
      {
        moduleName: '@env',
        path: process.env.ENVFILE || '.env.local',
        safe: false,
        allowUndefined: true,
      },
    ],
  ],
  // Enable specific transformations for web compatibility
  env: {
    production: {
      plugins: ['transform-remove-console'],
    },
  },
};


import 'fast-text-encoding';
import 'react-native-get-random-values';
import '@ethersproject/shims';

// Explicitly add text-encoding polyfill needed for ReadableStream
import 'text-encoding';

// Buffer polyfill must be loaded before other dependencies
import {Buffer} from 'buffer';
global.Buffer = Buffer;

// START --- Polyfill process object ---
if (typeof global.process === 'undefined') {
  global.process = require('process');
}
// It's also common for libraries to expect process.env
if (typeof global.process.env === 'undefined') {
  global.process.env = {};
}
// Ensure nextTick is available for some libraries
if (typeof global.process.nextTick === 'undefined') {
  global.process.nextTick = setImmediate;
}
// END --- Polyfill process object ---

// Import polyfills early - this will handle ReadableStream and EventEmitter
import './src/shared/utils/polyfills';

// Add a fallback for ReadableStream (this should be handled in polyfills.ts)
if (typeof global.ReadableStream === 'undefined') {
  console.warn('ReadableStream still not defined after polyfills - using minimal stub');
  global.ReadableStream = class MockReadableStream {
    constructor() {}
    getReader() {
      return {
        read: async () => ({ done: true, value: undefined }),
        releaseLock: () => {},
      };
    }
  };
}

if (typeof Settings === 'undefined') {
  global.Settings = {};
}

import {registerRootComponent} from 'expo';
import App from './App';

registerRootComponent(App);


// metro.config.js
const {getDefaultConfig} = require('expo/metro-config');
const path = require('path');

const config = getDefaultConfig(__dirname);
const workspaceRoot = path.resolve(__dirname, '../..');

config.transformer = {
  ...config.transformer,
  babelTransformerPath: require.resolve('react-native-svg-transformer'),
};

config.resolver = {
  ...config.resolver,
  assetExts: config.resolver.assetExts.filter(ext => ext !== 'svg'),
  sourceExts: [...config.resolver.sourceExts, 'svg'],
  extraNodeModules: {
    ...config.resolver.extraNodeModules,
    crypto: require.resolve('expo-crypto'),
    fs: path.resolve(__dirname, './src/shared/utils/fsPolyfill.js'),
    'text-encoding': require.resolve('text-encoding'),
    stream: require.resolve('stream-browserify'),
    // Add web streams API polyfill
    'web-streams-polyfill': require.resolve('web-streams-polyfill'),
    // Add events polyfill
    'events': require.resolve('events'),
  },
};

module.exports = config;


module.exports = {
  dependencies: {
    '@solana-mobile/mobile-wallet-adapter-protocol': {
      platforms: {
        ios: null, // Disable auto-linking on iOS
      },
    },
  },
};


#!/usr/bin/env node

// A script to properly handle command line arguments in yarn start
const { spawn } = require('child_process');
const args = process.argv.slice(2);

// Check if --dev flag is included
const hasDevFlag = args.includes('--dev');

// Command arguments for Expo start
const expoArgs = ['expo', 'start'];

// Add any other arguments except --dev
args.forEach(arg => {
  if (arg !== '--dev') {
    expoArgs.push(arg);
  }
});

// Set EXPO_PUBLIC_DEV_MODE environment variable
const env = {
  ...process.env,
  EXPO_PUBLIC_DEV_MODE: hasDevFlag ? 'true' : 'false'
};

// Clear console for better visibility
console.clear();

// Display prominent message about mode
if (hasDevFlag) {
  console.log('\n');
  console.log('🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢');
  console.log('🟢                                                     🟢');
  console.log('🟢              STARTING IN DEV MODE                   🟢');
  console.log('🟢                                                     🟢');
  console.log('🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢');
  console.log('\n');
} else {
  console.log('\n');
  console.log('▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️');
  console.log('▶️                                                     ▶️');
  console.log('▶️            STARTING IN STANDARD MODE                ▶️');
  console.log('▶️                                                     ▶️');
  console.log('▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️▶️');
  console.log('\n');
}

// Run expo start with the correct arguments and environment variables
const expo = spawn('npx', expoArgs, { stdio: 'inherit', env });

expo.on('close', code => {
  process.exit(code);
}); 

// This is a mock implementation of the Node.js 'fs' module for React Native
// It's specifically designed to handle @coral-xyz/anchor's needs

module.exports = {
  readFileSync: function(path, options) {
    console.warn(`fs.readFileSync called with path: ${path} - not supported in React Native`);
    // Return an empty buffer to avoid crashes
    return Buffer.from([]);
  },
  writeFileSync: function(path, data, options) {
    console.warn(`fs.writeFileSync called with path: ${path} - not supported in React Native`);
    // Do nothing
  },
  existsSync: function(path) {
    console.warn(`fs.existsSync called with path: ${path} - not supported in React Native`);
    return false;
  },
  promises: {
    readFile: async function(path, options) {
      console.warn(`fs.promises.readFile called with path: ${path} - not supported in React Native`);
      return Buffer.from([]);
    },
    writeFile: async function(path, data, options) {
      console.warn(`fs.promises.writeFile called with path: ${path} - not supported in React Native`);
      // Do nothing
    }
  }
}; 

Thread-based Social Feed

Overview

📱 Content Types

🧩 Component Structure

🔄 State Management

🎨 Customization

🆕 Highlights / New Additions

Key Features

Solana App Kit

Open-source React Native scaffold for building iOS and Android crypto mobile apps with seamless Solana protocol integrations

Introduction

Complete installation and configuration guide for setting up your Solana App Kit development environment

Setup Guide

Comprehensive guide to understanding and navigating the Solana App Kit codebase organization

Repository Structure

Complete guide to integrating and using Solana App Kit in your React Native applications

Usage Guide

Complete guide to all available modules in the Solana App Kit

Modules Overview

Comprehensive blockchain data fetching and management for Solana assets, tokens, NFTs, and market information

Data Module

Dynamic Liquidity Markets (DLMM) integration with token creation, swapping, and liquidity management

Meteora Module

Complete meme token ecosystem with token launching, trading, and automated market making via Pump.fun and PumpSwap

Pump.fun & Swap Module

Seamless fiat on-ramp integration for purchasing cryptocurrency with credit cards and Apple Pay

MoonPay Module

Complete NFT functionality for buying, selling, and managing digital collectibles with Tensor integration

NFT Module

Professional token launching and swapping with Raydium's advanced Launchpad and AMM platform

Raydium Module

AI-powered Solana interactions with intelligent chat interfaces and automated blockchain operations

Solana Agent Kit

Unified token swapping interface with multi-DEX integration for optimal trading on Solana

Swap Module

Comprehensive token creation and lifecycle management with advanced bonding curves, staking, and vesting capabilities

TokenMill Module

Unified wallet integration supporting Privy, Dynamic, Turnkey, and Mobile Wallet Adapter with comprehensive transaction management

Wallet Providers

Comprehensive backend server for the Solana App Kit, providing token management, social features, and various API endpoints for interacting with the Solana blockchain.

Introduction

Getting Started

Modules

Server

Thread

Overview

Key Features

📱 Content Types

🧩 Component Structure

🔄 State Management

🎨 Customization

🆕 Highlights / New Additions

Introduction

Getting Started

Modules

Server

​Thread-based Social Feed

​Overview

​Key Features

​📱 Content Types

​🧩 Component Structure

​🔄 State Management

​🎨 Customization

​🆕 Highlights / New Additions

Thread-based Social Feed

Overview

Key Features

📱 Content Types

🧩 Component Structure

🔄 State Management

🎨 Customization

🆕 Highlights / New Additions