Advanced Uploading with Turbo

import { TurboFactory } from '@ardrive/turbo-sdk'
import fs from 'fs'

// Load your Arweave JWK file
const jwk = JSON.parse(fs.readFileSync('wallet.json', 'utf-8'))
const turbo = await TurboFactory.authenticated({
  privateKey: jwk, // ArweaveJWK type
  token: 'arweave', // Default token type
})

import { TurboFactory, EthereumSigner } from '@ardrive/turbo-sdk'

// Your Ethereum private key (with 0x prefix)
const privateKey = '0x1234...' // EthPrivateKey type

// Create an Ethereum signer instance
const signer = new EthereumSigner(privateKey)
const turbo = await TurboFactory.authenticated({
  signer,
  token: 'ethereum',
})

import { TurboFactory } from '@ardrive/turbo-sdk'
import bs58 from 'bs58'

// Your Solana secret key (as Uint8Array)
const secretKey = new Uint8Array([...]) // SolSecretKey type

const turbo = await TurboFactory.authenticated({
  privateKey: bs58.encode(secretKey),
  token: 'solana'
})

import { TurboFactory, EthereumSigner } from '@ardrive/turbo-sdk'

// Your Polygon private key (with 0x prefix)
const privateKey = '0x1234...' // EthPrivateKey type

// Create an Ethereum signer instance for Polygon
const signer = new EthereumSigner(privateKey)
const turbo = await TurboFactory.authenticated({
  signer,
  token: 'matic', // or 'pol'
})

import { TurboFactory } from '@ardrive/turbo-sdk'

// Your KYVE private key (hexadecimal)
const privateKey = '0x1234...' // KyvePrivateKey type

const turbo = await TurboFactory.authenticated({
  privateKey,
  token: 'kyve',
})

import { TurboFactory, ArConnectSigner } from '@ardrive/turbo-sdk/web'

async function initializeTurbo() {
  await window.arweaveWallet.connect([
    'ACCESS_ADDRESS',
    'ACCESS_PUBLIC_KEY',
    'SIGN_TRANSACTIONS',
    'SIGN_MESSAGE',
    'SIGNATURE',
  ])

  const turbo = await TurboFactory.authenticated({
    signer: new ArConnectSigner(window.arweaveWallet),
  })
}

import { TurboFactory } from '@ardrive/turbo-sdk/web'
import { InjectedEthereumSigner } from '@dha-team/arbundles'
import { getAccount, signMessage } from 'wagmi/actions'
import { hashMessage, recoverPublicKey, toBytes } from 'viem'

// Global variables for Wagmi config and connector
let config = null
let connector = null
let turboInstance = null

// Function to set up Wagmi configuration
export function setWagmiConfig(wagmiConfig, wagmiConnector) {
  config = wagmiConfig
  connector = wagmiConnector
}

// Function to initialize Turbo with Wagmi
export async function initializeTurbo(userAddress) {
  try {
    if (!config || !connector) {
      throw new Error(
        'Wagmi config and connector not set. Call setWagmiConfig first.',
      )
    }

    console.log('Initializing Turbo client...')

    // Create a provider that uses wagmi's signMessage
    const provider = {
      getSigner: () => ({
        signMessage: async (message) => {
          const arg = message instanceof String ? message : { raw: message }
          const ethAccount = getAccount(config)
          return await signMessage(config, {
            message: arg,
            account: ethAccount.address,
            connector: connector,
          })
        },
      }),
    }

    // Create the Turbo signer
    const signer = new InjectedEthereumSigner(provider)

    // Set up the public key
    signer.setPublicKey = async () => {
      const message = 'Sign this message to connect to Turbo'
      const ethAccount = getAccount(config)
      const signature = await signMessage(config, {
        message: message,
        account: ethAccount.address,
        connector: connector,
      })
      const hash = await hashMessage(message)
      const recoveredKey = await recoverPublicKey({
        hash,
        signature,
      })
      signer.publicKey = Buffer.from(toBytes(recoveredKey))
    }

    // Initialize the signer
    await signer.setPublicKey()

    turboInstance = await TurboFactory.authenticated({
      signer: signer,
      token: 'base-eth', // Can be changed to 'ethereum' or 'matic', etc.
    })

    console.log('Turbo client initialized successfully')
    return turboInstance
  } catch (error) {
    console.error('Error initializing Turbo client:', error)
    turboInstance = null
    throw error
  }
}

import { BrowserProvider } from 'ethers'
import { TurboFactory } from '@ardrive/turbo-sdk/web'
import { InjectedEthereumSigner } from '@dha-team/arbundles'

export const connectToMetaMask = async () => {
  if (!window.ethereum) {
    throw new Error('Please install MetaMask to use this application')
  }

  try {
    const accounts = await window.ethereum.request({
      method: 'eth_requestAccounts',
    })

    const metaMaskProvider = window.ethereum.providers?.find(
      (p) => p.isMetaMask,
    )
    const provider = new BrowserProvider(metaMaskProvider ?? window.ethereum)
    const signer = await provider.getSigner()

    const turbo = TurboFactory.authenticated({
      signer: new InjectedEthereumSigner({ getSigner: () => signer }),
      token: 'ethereum',
    })

    return { turbo, address: accounts[0] }
  } catch (error) {
    console.error('Connection failed:', error)
    throw error
  }
}

import { TurboFactory, SolanaWalletAdapter } from '@ardrive/turbo-sdk/web'
import { PublicKey } from '@solana/web3.js'

export async function initializeSolanaTurbo() {
  try {
    // Check if Phantom is installed
    if (window.solana) {
      const provider = window.solana
      const publicKey = new PublicKey((await provider.connect()).publicKey)

      const wallet: SolanaWalletAdapter = {
        publicKey,
        signMessage: async (message: Uint8Array) => {
          // Call Phantom's signMessage method
          const { signature } = await provider.signMessage(message)
          return signature
        },
      }

      solanaTurboInstance = TurboFactory.authenticated({
        token: 'solana',
        walletAdapter: wallet,
      })
    }
  } catch (err) {
    console.error(err)
  }
}

import { TurboFactory, WinstonToTokenAmount } from '@ardrive/turbo-sdk'

// Initialize authenticated client
const turbo = await TurboFactory.authenticated({
  privateKey: jwk
})

// Top up with AR tokens
const topUpResult = await turbo.topUpWithTokens({
  tokenAmount: WinstonToTokenAmount(100_000_000), // 0.0001 AR
})

import { TurboFactory, EthereumSigner } from '@ardrive/turbo-sdk'

// Initialize authenticated client
const turbo = await TurboFactory.authenticated({
  signer: new EthereumSigner(privateKey),
  token: 'ethereum',
})

// Top up with ETH tokens
const topUpResult = await turbo.topUpWithTokens({
  tokenAmount: 0.001, // 0.001 ETH
})

import { TurboFactory } from '@ardrive/turbo-sdk'

// Initialize authenticated client
const turbo = await TurboFactory.authenticated({
  privateKey: bs58.encode(secretKey),
  token: 'solana'
})

// Top up with SOL tokens
const topUpResult = await turbo.topUpWithTokens({
  tokenAmount: 0.1, // 0.1 SOL
})

import { TurboFactory, EthereumSigner } from '@ardrive/turbo-sdk'

// Initialize authenticated client
const turbo = await TurboFactory.authenticated({
  signer: new EthereumSigner(privateKey),
  token: 'matic',
})

// Top up with MATIC tokens
const topUpResult = await turbo.topUpWithTokens({
  tokenAmount: 1.0, // 1.0 MATIC
})

import { TurboFactory } from '@ardrive/turbo-sdk'

// Initialize authenticated client
const turbo = await TurboFactory.authenticated({
  privateKey,
  token: 'kyve',
})

// Top up with KYVE tokens
const topUpResult = await turbo.topUpWithTokens({
  tokenAmount: 100, // 100 KYVE
})