Payments

dependencies {
  implementation 'com.meshconnect:link:2.0.0'
  implementation 'com.squareup.okhttp3:okhttp:4.12.0'
}

import okhttp3.*
import org.json.JSONObject
import java.io.IOException

// Function to request a link token
fun requestLinkToken() {
    val client = OkHttpClient()

    // Construct the JSON body
    val transferOptions = JSONObject().apply {
        put("toAddresses", listOf(
            JSONObject().apply {
                put("networkId", "<Network Id>")
                put("symbol", "<Currency Symbol (e.g. USDC)>")
                put("address", "<Address>")
                put("amount", "<Amount to transfer (e.g. 5)>")
            }
        ))
        put("clientFee", "<Client Fee (e.g. 0.001)>")
    }

    val jsonBody = JSONObject().apply {
        put("userId", "Mesh")
        put("restrictMultipleAccounts", "<true/false>")
        put("transferOptions", transferOptions)
    }

    val requestBody = RequestBody.create(
        "application/json; charset=utf-8".toMediaTypeOrNull(),
        jsonBody.toString()
    )

    val request = Request.Builder()
        .url("https://sandbox-integration-api.meshconnect.com/api/v1/linktoken")
        .addHeader("X-Client-Secret", "<Mesh Client Secret>")
        .addHeader("X-Client-Id", "<Mesh Client Id>")
        .addHeader("Content-Type", "application/json")
        .post(requestBody)
        .build()

    client.newCall(request).enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            // Handle error
            e.printStackTrace()
        }

        override fun onResponse(call: Call, response: Response) {
            response.use {
                if (!response.isSuccessful) {
                    // Handle unsuccessful response
                    println("Unexpected code $response")
                } else {
                    val responseBody = response.body?.string()
                    val json = JSONObject(responseBody)
                    val linkToken = json.getString("link_token")
                    // Use linkToken as needed
                    println("Link Token: $linkToken")
                }
            }
        }
    })
}

val configuration = LinkConfiguration(  
  linkToken = linkToken,  
  onIntegrationConnected = { payload ->  
    secureStorage.saveToken(payload.accessToken)
  },  
  onTransferFinished = { payload ->  
    when (payload.status) {  
      "success" -> processSuccess(payload as TransferFinishedSuccessPayload)  
      "error" -> handleError(payload as TransferFinishedErrorPayload)  
    }  
  }  
)  

private val onIntegrationConnected = { payload: LinkPayload ->
  when (payload) {
    is AccessTokenPayload -> {
        // Store auth_token securely
        Log.d("Mesh", "Connected: ${payload.accessToken}")
    }
    is DelayedAuthPayload -> {
        // Handle delayed authentication
    }
  }
}

private val onTransferFinished = { payload: TransferFinishedPayload ->
  when (payload.status) {
    "success" -> {
        val success = payload as TransferFinishedSuccessPayload
        Log.d("Mesh", "Transfer ID: ${success.transferId}")
    }
    "error" -> {
        val error = payload as TransferFinishedErrorPayload
        Log.e("Mesh", "Transfer failed: ${error.message}")
    }
  }
}

private val linkLauncher = registerForActivityResult(LaunchLink()) { result ->
  when (result) {
    is LinkSuccess -> handlePayloads(result.payloads)
    is LinkExit -> handleExit(result.errorMessage)
  }
}

private fun handlePayloads(payloads: List<LinkPayload>) {
  payloads.forEach { 
    when (it) {
      is AccessTokenPayload -> onIntegrationConnected(it)
      is TransferFinishedPayload -> onTransferFinished(it)
    }
  }
}

private fun handleExit(error: String?) {
  error?.let { Log.e("Mesh", "Flow exited: $it") }
}

fun initiatePaymentFlow() {
  try {
    linkLauncher.launch(configuration)
  } catch (e: Exception) {
    Log.e("Mesh", "Launch failed: ${e.message}")
  }
}

private val onEvent: (String, Map<String, Any>?) -> Unit = { event, data ->
when (event) {
    "transferStarted" ->
      Log.d("Mesh", "Transfer initiated")
    "transferPreviewed" ->
      Log.d("Mesh", "User reviewed transfer details")
    "credentialsEntered" ->
      Log.d("Mesh", "Exchange authentication in progress")
    else -> {}
  }
}

import Foundation
let url = URL(string: "https://sandbox-integration-api.meshconnect.com/api/v1/linktoken")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("<Mesh Client Secret>", forHTTPHeaderField: "X-Client-Secret")
request.addValue("<Mesh Client Id>", forHTTPHeaderField: "X-Client-Id")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

let body: [String: Any] = [
    "userId": "Mesh",
    "restrictMultipleAccounts": "<true/false>",
    "transferOptions": [
        "toAddresses": [
            [
                "networkId": "<Network Id>",
                "symbol": "<Currency Symbol (e.g. USDC)>",
                "address": "<Address>",
                "amount": "<Amount to transfer (e.g. 5)>"
            ]
        ],
        "clientFee": "<Client Fee (e.g. 0.001)>"
    ]
]

request.httpBody = try? JSONSerialization.data(withJSONObject: body)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else {
        print("Error:", error ?? "Unknown error")
        return
    }
    if let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
       let linkToken = json["link_token"] as? String {
        print("Link Token:", linkToken)
    } else {
        print("Invalid response")
    }
}

task.resume()

let configuration = LinkConfiguration(
linkToken: linkToken,
settings: LinkSettings?, // optional
onIntegrationConnected: onIntegrationConnected,
onTransferFinished: onTransferFinished,
onEvent: onEvent, // optional
onExit: onExit // optional
)

// callbacks
let onIntegrationConnected: (LinkPayload)->() = { linkPayload in
  switch linkPayload {
  case .accessToken(let accessTokenPayload):
    print(accessTokenPayload)
    // Store access token securely for transfers
  case .delayedAuth(let delayedAuthPayload):
    print(delayedAuthPayload)
  }
}

private val onTransferFinished = { payloads: List<LinkPayload> ->
  payloads.forEach { payload ->
    when (payload) {
      is TransferFinishedSuccessPayload -> {
        Log.d("Mesh", "Transfer ID: ${payload.transferId}")
        // Handle successful transfer
      }
      is TransferFinishedErrorPayload -> {
        Log.e("Mesh", "Error: ${payload.message}")
        // Handle transfer failure
      }
    }
  }
}

let onEvent: (String) -> Void = { event in
switch event {
case "transferStarted":
    print("Transfer initiated")
case "transferPreviewed":
    print("Transfer details reviewed")
case "credentialsEntered":
    print("Exchange authentication started")
default:
    break
}
}

let handler = try LinkHandler(  
  configuration: LinkConfiguration(  
    linkToken: linkToken,  
    onEvent: { event in  
      switch event {  
        case .transferExecutionError(let error):  
          Analytics.track(.transferFailed(error))  
        default: break  
      }  
    }  
  )  
)  
handler.present(in: self)

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<String> requestLinkToken() async {
  final response = await http.post(
    Uri.parse('https://sandbox-integration-api.meshconnect.com/api/v1/linktoken'),
    headers: {
      'X-Client-Secret': '<Mesh Client Secret>',
      'X-Client-Id': '<Mesh Client Id>',
      'Content-Type': 'application/json',
    },
    body: jsonEncode({
      'userId': 'Mesh',
      'restrictMultipleAccounts': true,
      'transferOptions': {
        'toAddresses': [
          {
            'networkId': '<Network Id>',
            'symbol': '<Currency Symbol (e.g. USDC)>',
            'address': '<Address>',
            'amount': '<Amount to transfer (e.g. 5)>',
          }
        ],
        'clientFee': '<Client Fee (e.g. 0.001)>',
      },
    }),
  );

  final json = jsonDecode(response.body);
  return json['content']['linkToken'];
}

import 'package:mesh_sdk_flutter/mesh_sdk_flutter.dart';

Future<void> initiatePaymentFlow(String linkToken) async {
  final result = await MeshSdk.show(
    context,
    configuration: MeshConfiguration(
      linkToken: linkToken,
      onIntegrationConnected: (integration) {
        // Store access token securely for future transfers
        print('Connected: ${integration.accessToken}');
      },
      onTransferFinished: (transfer) {
        print('Transfer finished: $transfer');
      },
      onEvent: (event) {
        // Track user progress
        print('Event: $event');
      },
      onExit: (error) {
        if (error != null) {
          print('Exit with error: $error');
        }
      },
    ),
  );

  switch (result) {
    case MeshSuccess():
      print('Payment flow completed successfully');
    case MeshError():
      print('Payment flow error: ${result.type}');
  }
}