import {
  attestedCompute,
  AttestedComputeSupportedOps,
} from '@inco/solana-sdk/attested-compute';
import { handleToBuffer, plaintextToBuffer } from '@inco/solana-sdk/utils';
import { Transaction, SYSVAR_INSTRUCTIONS_PUBKEY } from '@solana/web3.js';

import {
  attestedCompute,
  AttestedComputeSupportedOps,
} from '@inco/solana-sdk/attested-compute';
import { Transaction } from '@solana/web3.js';

// Off-chain: is encryptedBalance > 100?
const result = await attestedCompute(
  {
    lhsHandle: balanceHandle, // decimal string u128 handle
    op: AttestedComputeSupportedOps.Gt,
    rhsPlaintext: 100n,
  },
  {
    address: wallet.publicKey,
    signMessage: wallet.signMessage,
  }
);

console.log(result.result); // "1" or "0"

// Optional: verify the attested result on-chain
const tx = new Transaction();
tx.add(result.ed25519Instruction);
tx.add(yourProgramInstruction);

import {
  attestedCompute,
  AttestedComputeSupportedOps,
} from '@inco/solana-sdk/attested-compute';
import { handleToBuffer, plaintextToBuffer } from '@inco/solana-sdk/utils';
import { Transaction, SYSVAR_INSTRUCTIONS_PUBKEY } from '@solana/web3.js';

// creditScoreHandle must already be allowed for wallet.publicKey
const result = await attestedCompute(
  {
    lhsHandle: creditScoreHandle,
    op: AttestedComputeSupportedOps.Ge,
    rhsPlaintext: 700n,
  },
  {
    address: wallet.publicKey,
    signMessage: wallet.signMessage,
  }
);

if (result.result !== '1') {
  throw new Error('Credit check failed');
}

// Build on-chain verification (program verifies Ed25519 via instructions sysvar)
const programInstruction = await program.methods
  .verifyDecryption(
    1,
    [handleToBuffer(result.handle)],
    [plaintextToBuffer(result.result)]
  )
  .accounts({
    authority: wallet.publicKey,
    instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
  })
  .instruction();

const tx = new Transaction();
tx.add(result.ed25519Instruction);
tx.add(programInstruction);

const { blockhash } = await connection.getLatestBlockhash();
tx.recentBlockhash = blockhash;
tx.feePayer = wallet.publicKey;

const signedTx = await wallet.signTransaction(tx);
const signature = await connection.sendRawTransaction(signedTx.serialize());
await connection.confirmTransaction(signature, 'confirmed');

import { useWallet } from '@solana/wallet-adapter-react';
import {
  attestedCompute,
  AttestedComputeError,
  AttestedComputeSupportedOps,
} from '@inco/solana-sdk/attested-compute';
import { useState } from 'react';

function CreditCheck({ handle }: { handle: string }) {
  const wallet = useWallet();
  const [passed, setPassed] = useState<boolean | null>(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const runCheck = async () => {
    if (!wallet.publicKey || !wallet.signMessage) {
      setError('Please connect your wallet');
      return;
    }

    setLoading(true);
    setError(null);

    try {
      const result = await attestedCompute(
        {
          lhsHandle: handle,
          op: AttestedComputeSupportedOps.Ge,
          rhsPlaintext: 700n,
        },
        {
          address: wallet.publicKey,
          signMessage: wallet.signMessage,
        }
      );
      setPassed(result.result === '1');
    } catch (err) {
      if (err instanceof AttestedComputeError) {
        setError(err.message);
      } else {
        setError('Attested compute failed');
      }
    } finally {
      setLoading(false);
    }
  };

  return (
    <div>
      <button onClick={runCheck} disabled={loading || !wallet.connected}>
        {loading ? 'Checking...' : 'Check eligibility'}
      </button>
      {passed !== null && (
        <p>{passed ? 'Eligible' : 'Not eligible'}</p>
      )}
      {error && <p>{error}</p>}
    </div>
  );
}

interface AttestedComputeArgs {
  lhsHandle: string;                 // Decimal u128 handle string
  op: AttestedComputeOP;             // eq | ne | ge | gt | le | lt
  rhsPlaintext: bigint | boolean;    // Scalar right-hand side
}

interface AttestedComputeOptions {
  address: string | PublicKey;
  signMessage: (message: Uint8Array) => Promise<Uint8Array>;
  endpoint?: string; // Optional covalidator URL override (local testing)
}

interface AttestedComputeResult {
  result: string;                    // "0" | "1"
  handle: string;
  op: AttestedComputeOP;
  rhsPlaintext: bigint;
  ed25519Instruction: TransactionInstruction;
  signature: string;                 // base58 covalidator signature
}

import nacl from 'tweetnacl';

signMessage: async (msg) => nacl.sign.detached(msg, keypair.secretKey)

import {
  attestedCompute,
  AttestedComputeError,
  AttestedComputeSupportedOps,
} from '@inco/solana-sdk/attested-compute';

try {
  const result = await attestedCompute(
    { lhsHandle, op: AttestedComputeSupportedOps.Gt, rhsPlaintext: 100n },
    { address: wallet.publicKey, signMessage: wallet.signMessage }
  );
} catch (error) {
  if (error instanceof AttestedComputeError) {
    console.error('Attested compute failed:', error.message);
  }
}

import { Keypair } from '@solana/web3.js';
import { AttestedComputeSupportedOps } from '@inco/solana-sdk/attested-compute';
import {
  grantSessionKeyAllowanceVoucher,
  attestedComputeWithVoucher,
  signMessageFromKeypair,
} from '@inco/solana-sdk/voucher';

const sessionKeypair = Keypair.generate();
const voucherWithSig = await grantSessionKeyAllowanceVoucher(
  { address: wallet.publicKey, signMessage: wallet.signMessage },
  sessionKeypair.publicKey,
  new Date(Date.now() + 60 * 60 * 1000)
);

const result = await attestedComputeWithVoucher(
  {
    lhsHandle: handle,
    op: AttestedComputeSupportedOps.Ge,
    rhsPlaintext: 700n,
  },
  {
    address: sessionKeypair.publicKey,
    signMessage: signMessageFromKeypair(sessionKeypair),
    voucherWithSig,
  }
);

console.log(result.result); // "1" or "0"