toss-expo-sdk 0.1.0

package/src/intentManager.ts

@@ -0,0 +1,164 @@
+import { Transaction } from '@solana/web3.js';
+import bs58 from 'bs58';
+import type { SolanaIntent, IntentStatus } from './intent';
+
+/**
+ * Verifies the signature of a Solana intent
+ * @param intent The intent to verify
+ * @returns boolean indicating if the signature is valid
+ */
+export function verifyIntentSignature(intent: SolanaIntent): boolean {
+  try {
+    // Check if serialized transaction exists
+    if (!intent.serialized) {
+      return false;
+    }
+
+    // Reconstruct the transaction to verify signatures
+    const tx = Transaction.from(Buffer.from(bs58.decode(intent.serialized)));
+
+    // Verify all signatures in the transaction
+    return tx.verifySignatures();
+  } catch (error) {
+    console.error('Error verifying intent signature:', error);
+    return false;
+  }
+}
+
+/**
+ * Checks if an intent has expired
+ * @param intent The intent to check
+ * @returns boolean indicating if the intent has expired
+ */
+export function isIntentExpired(intent: SolanaIntent): boolean {
+  return Date.now() / 1000 > intent.expiry;
+}
+
+/**
+ * Updates the status of an intent
+ * @param intent The intent to update
+ * @param status The new status
+ * @param error Optional error message if status is 'failed'
+ * @returns A new intent with updated status
+ */
+export function updateIntentStatus(
+  intent: SolanaIntent,
+  status: IntentStatus,
+  error?: string
+): SolanaIntent {
+  return {
+    ...intent,
+    status,
+    updatedAt: Math.floor(Date.now() / 1000),
+    ...(error && { error }),
+  };
+}
+
+/**
+ * Validates an intent against current blockchain state
+ * Note: This is a placeholder - actual implementation would check against a Solana node
+ * @param intent The intent to validate
+ * @param currentBlockhash Current network blockhash
+ * @returns Validation result with success status and optional error message
+ */
+export async function validateIntent(
+  intent: SolanaIntent,
+  currentBlockhash: string
+): Promise<{ valid: boolean; error?: string }> {
+  // Check if intent has expired
+  if (isIntentExpired(intent)) {
+    return {
+      valid: false,
+      error: 'Intent has expired',
+    };
+  }
+
+  // Verify signatures
+  if (!verifyIntentSignature(intent)) {
+    return {
+      valid: false,
+      error: 'Invalid transaction signature',
+    };
+  }
+
+  // Check if blockhash is still valid
+  // In a real implementation, we'd check against the Solana cluster
+  // This is a simplified check
+  if (intent.blockhash !== currentBlockhash) {
+    return {
+      valid: false,
+      error: 'Stale blockhash',
+    };
+  }
+
+  // Additional validation logic would go here
+  // - Check account balances
+  // - Verify program-specific logic
+  // - Check for double-spend attempts
+
+  return { valid: true };
+}
+
+/**
+ * Processes a batch of intents for synchronization
+ * @param intents Array of intents to process
+ * @param connection Connection to Solana network
+ * @returns Processed intents with updated statuses
+ */
+export async function processIntentsForSync(
+  intents: SolanaIntent[],
+  connection: any // Should be Connection from @solana/web3.js in real implementation
+): Promise<SolanaIntent[]> {
+  const currentBlockhash = (await connection.getRecentBlockhash()).blockhash;
+
+  return Promise.all(
+    intents.map(async (intent) => {
+      // Skip already processed intents
+      if (intent.status !== 'pending') return intent;
+
+      const validation = await validateIntent(intent, currentBlockhash);
+
+      if (!validation.valid) {
+        return updateIntentStatus(intent, 'failed', validation.error);
+      }
+
+      try {
+        // In a real implementation, we would submit the transaction here
+        // const signature = await connection.sendRawTransaction(
+        //   Buffer.from(bs58.decode(intent.serialized))
+        // );
+        // await connection.confirmTransaction(signature);
+
+        return updateIntentStatus(intent, 'settled');
+      } catch (error) {
+        return updateIntentStatus(
+          intent,
+          'failed',
+          error instanceof Error ? error.message : 'Unknown error'
+        );
+      }
+    })
+  );
+}
+
+/**
+ * Filters out expired intents and updates their status
+ * @param intents Array of intents to check
+ * @returns Tuple of [validIntents, expiredIntents]
+ */
+export function filterExpiredIntents(
+  intents: SolanaIntent[]
+): [SolanaIntent[], SolanaIntent[]] {
+  const valid: SolanaIntent[] = [];
+  const expired: SolanaIntent[] = [];
+
+  for (const intent of intents) {
+    if (isIntentExpired(intent)) {
+      expired.push(updateIntentStatus(intent, 'expired'));
+    } else {
+      valid.push(intent);
+    }
+  }
+
+  return [valid, expired];
+}

package/src/internal/arciumHelper.ts

@@ -0,0 +1,58 @@
+// import {
+//     getArciumEnv,
+//     x25519,
+//     getMXEPublicKey,
+//     RescueCipher,
+//   } from "@arcium-hq/client";
+import * as Arcium from '@arcium-hq/client';
+import type { PublicKey } from '@solana/web3.js';
+
+/**
+ * Output from Arcium encryption (internal only)
+ */
+export type ArciumEncryptedOutput = {
+  ciphertext: number[][];
+  publicKey: Uint8Array;
+  nonce: Uint8Array;
+};
+/**
+ * Internal helper to encrypt a set of numeric values with Arcium.
+ * Does not leak anything about Arcium to the SDK consumer.
+ *
+ * @param mxeProgramId PublicKey of the MXE
+ * @param plaintextValues numeric values for encryption
+ * @param provider Solana provider (e.g., AnchorProvider)
+ */
+export async function encryptForArciumInternal(
+  mxeProgramId: PublicKey,
+  plaintextValues: bigint[],
+  provider: any // AnchorProvider or similar
+): Promise<ArciumEncryptedOutput> {
+  // Required by the Arcium client before encryption
+  Arcium.getArciumEnv();
+
+  // 1) Generate a random x25519 keypair
+  const privateKey = Arcium.x25519.utils.randomSecretKey();
+  const publicKey = Arcium.x25519.getPublicKey(privateKey);
+
+  // 2) Fetch the MXE's public encryption key using the provided provider
+  const mxePubKey = await Arcium.getMXEPublicKey(provider, mxeProgramId);
+
+  if (!mxePubKey) {
+    throw new Error('MXE public key not found for Arcium encryption');
+  }
+
+  // 3) Derive DH shared secret
+  const sharedSecret = Arcium.x25519.getSharedSecret(privateKey, mxePubKey);
+
+  // 4) Build the cipher and encrypt the data
+  const cipher = new Arcium.RescueCipher(sharedSecret);
+  const nonce = crypto.getRandomValues(new Uint8Array(16));
+  const ciphertext = cipher.encrypt(plaintextValues, nonce);
+
+  return {
+    ciphertext,
+    publicKey,
+    nonce,
+  };
+}

package/src/nfc.ts

@@ -0,0 +1,57 @@
+// src/nfc.ts
+import NfcManager, { NfcTech, Ndef } from "react-native-nfc-manager";
+import type { TossUser } from './types/tossUser';
+import type { SolanaIntent } from './intent';
+
+// Start the manager
+export function initNFC() {
+  return NfcManager.start();
+}
+
+// Read NFC tag containing a TossUser
+export async function readNFCUser(): Promise<TossUser> {
+  try {
+    await NfcManager.requestTechnology(NfcTech.Ndef);
+    const tag = await NfcManager.getTag();
+    await NfcManager.cancelTechnologyRequest();
+    
+    if (!tag?.ndefMessage?.[0]?.payload) {
+      throw new Error('No NDEF message found');
+    }
+    
+    const message = Ndef.uri.decodePayload(tag.ndefMessage[0].payload as any);
+    return JSON.parse(message) as TossUser;
+  } catch (ex: unknown) {
+    await NfcManager.cancelTechnologyRequest();
+    throw new Error(`Failed to read user from NFC: ${String(ex)}`);
+  }
+}
+
+export async function writeUserToNFC(user: TossUser): Promise<boolean> {
+  try {
+    await NfcManager.requestTechnology(NfcTech.Ndef);
+    const jsonUser = JSON.stringify(user);
+    const bytes = Ndef.encodeMessage([Ndef.uriRecord(jsonUser)]);
+    await NfcManager.ndefHandler.writeNdefMessage(bytes);
+    await NfcManager.cancelTechnologyRequest();
+    return true;
+  } catch (ex: unknown) {
+    await NfcManager.cancelTechnologyRequest();
+    throw new Error(`Failed to write user to NFC: ${String(ex)}`);
+  }
+}
+
+// Write SolanaIntent to NFC tag
+export async function writeIntentToNFC(intent: SolanaIntent): Promise<boolean> {
+  try {
+    await NfcManager.requestTechnology(NfcTech.Ndef);
+    const jsonIntent = JSON.stringify(intent);
+    const bytes = Ndef.encodeMessage([Ndef.uriRecord(jsonIntent)]);
+    await NfcManager.ndefHandler.writeNdefMessage(bytes);
+    await NfcManager.cancelTechnologyRequest();
+    return true;
+  } catch (ex: unknown) {
+    await NfcManager.cancelTechnologyRequest();
+    throw new Error(`Failed to write intent to NFC: ${String(ex)}`);
+  }
+}

package/src/noise.ts

@@ -0,0 +1,9 @@
+import { noise } from "@chainsafe/libp2p-noise";
+
+/**
+ * Initialize Noise secure session with a static key.
+ */
+export function initNoiseSession(staticKey: Uint8Array) {
+  const ns = noise({ staticNoiseKey: staticKey });
+  return ns;
+}

package/src/qr.tsx

@@ -0,0 +1,65 @@
+import { View, StyleSheet, Text } from 'react-native';
+import {
+  Camera,
+  useCameraDevice,
+  useCameraPermission,
+  useCodeScanner,
+  type Code,
+} from 'react-native-vision-camera';
+
+type QRScannerProps = {
+  onScan: (data: string) => void;
+};
+
+export function QRScanner({ onScan }: QRScannerProps) {
+  const device = useCameraDevice('back');
+  const permission = useCameraPermission();
+
+  const codeScanner = useCodeScanner({
+    codeTypes: ['qr'], // ✅ correct CodeType
+    onCodeScanned: (codes: Code[]) => {
+      const code = codes[0];
+      if (!code?.value) return; // ✅ undefined-safe
+
+      onScan(code.value);
+    },
+  });
+
+  if (!permission.hasPermission) {
+    return (
+      <View style={styles.center}>
+        <Text>Camera permission not granted</Text>
+      </View>
+    );
+  }
+
+  if (!device) {
+    return (
+      <View style={styles.center}>
+        <Text>Camera not available</Text>
+      </View>
+    );
+  }
+
+  return (
+    <View style={styles.container}>
+      <Camera
+        style={StyleSheet.absoluteFill}
+        device={device}
+        isActive
+        codeScanner={codeScanner}
+      />
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  center: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+});