UserLink Transact SDK Reference

import SwiftUI
import AtomicTransact

struct ContentView: View {
    @State var showingTransact = false
    
    var body: some View {
        Button("Launch Transact") {
            showingTransact = true
        }.atomicTransact(
            isPresented: $showingTransact,
            config: {
              AtomicConfig(
                publicToken: "PUBLIC_TOKEN", 
                scope: .userLink, 
                tasks: [.init(operation: .deposit)],
                theme: Theme(
                  brandColor: "#9460FE",
                  overlayColor: "#000000", 
                  dark: false,
                  navigationOptions: NavigationOptions(
                    showBackButton: true,
                    showBackButtonText: false,
                    showCloseButton: true
                  )
                ),
                language: "en",
                deeplink: Deeplink(
                  step: "login-company",
                  companyId: "5e4c4d18b7d75c37aac54a8f"
                ),
                search: Search(
                  ruleId: "67571ed7b278a518d7d8abdf"
                ),
                metadata: [
                  "version": "1.2.1",
                  "test": "New User Experience", 
                  "testVariant": "B"
                ]
             )},
            onDataRequest: { request in
              // Handle data request for account/payment information
              print("Data request: \(request.fields)")
              return TransactDataResponse(/* provide required data */)
            },
            onCompletion: { result in
              switch result {
              case .finished(let response):
                print("Finish event: \(response.taskId) \(response.handoff)")
              case .closed(let response):
                print("Close event: \(response.reason)")
              case .error(let error):
                print("Transact returned with error: \(error)")
              default:
                print("Default case")
              }
            })
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

import AtomicTransact

let config = AtomicConfig(
  publicToken: "PUBLIC_TOKEN", 
  scope: .userLink,
  tasks: [.init(operation: .deposit)],
  theme: Theme(
    brandColor: "#9460FE", 
    overlayColor: "#000000",
    dark: false,
    navigationOptions: NavigationOptions(
      showBackButton: true,
      showBackButtonText: false,
      showCloseButton: true
    )
  ),
  language: "en",
  deeplink: Deeplink(
    step: "login-company",
    companyId: "5e4c4d18b7d75c37aac54a8f"
  ),
  search: Search(
    ruleId: "67571ed7b278a518d7d8abdf"
  ),
  metadata: [
    "version": "1.2.1",
    "test": "New User Experience",
    "testVariant": "B"
  ]
)

Atomic.presentTransact(
    from: self, 
    config: config,
    onDataRequest: { request in
      // Handle data request for account/payment information
      print("Data request: \(request.fields)")
      return TransactDataResponse(/* provide required data */)
    },
    onInteraction: { interaction in
      print("Interaction event: \(interaction.name) \(interaction.value)")
  }, 
  onCompletion: { result in
    switch result {
      case .finished(let response):
        print("Finish event: \(response.taskId) \(response.handoff)")
      case .closed(let response):
        print("Close event: \(response.reason)")
      case .error(let error):
        print("Transact returned with error: \(error)")
  }
})

import org.json.JSONObject
import financial.atomic.transact.*
import financial.atomic.transact.receiver.TransactBroadcastReceiver

val config = Config(
  publicToken = "PUBLIC_TOKEN",
  scope = Config.Scope.USER_LINK,
  tasks = listOf(Config.Task(operation = Config.Operation.DEPOSIT)),
  theme = Config.Theme(
    brandColor = "#9460FE",
    overlayColor = "#000000",
    dark = false,
    navigationOptions = Config.NavigationOptions(
      showBackButton = true,
      showBackButtonText = false,
      showCloseButton = true
    )
  ),
  language = "en",
  deeplink = Config.Deeplink(
    step = "login-company",
    companyId = "5e4c4d18b7d75c37aac54a8f"
  ),
  search = Config.Search(
    ruleId = "67571ed7b278a518d7d8abdf"
  ),
  metadata = mapOf(
    "version" to "1.2.1",
    "test" to "New User Experience",
    "testVariant" to "B"
  )
)

Transact.registerReceiver(context, object: TransactBroadcastReceiver() {
  override fun onDataRequest(data: JSONObject) {
    // Handle data request for account/payment information
    Log.d("APP", "Data request: ${data.getJSONArray("fields")}")
    // Return required data
  }
  override fun onInteraction(data: JSONObject) {
    Log.d("APP", "Interaction event: ${data.getString("name")} ${data.getJSONObject("value")}")
  }
  override fun onFinish(data: JSONObject) {
    Log.d("APP", "Finish event: ${data.getString("taskId")} ${data.optString("handoff")}")
  }
  override fun onClose(data: JSONObject) {
    Log.d("APP", "Close event: ${data.getString("reason")}")
  }
})

Transact.present(context, config)

import android.content.Context;
import android.util.Log;
import org.json.JSONObject;
import java.util.Arrays;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import financial.atomic.transact.*;
import financial.atomic.transact.receiver.TransactBroadcastReceiver;

public class TransactJavaImplementation {
   public static void initializeTransact(Context context) {
    Map<String, String> metadata = new HashMap<>();
    metadata.put("version", "1.2.1");
    metadata.put("test", "New User Experience");
    metadata.put("testVariant", "B");

    Config config = new Config(
        "PUBLIC_TOKEN",
        Config.Scope.USER_LINK,
        Arrays.asList(new Config.Task(Config.Operation.DEPOSIT)),
        new Config.Theme("#9460FE", "#000000", false, 
            new Config.NavigationOptions(true, false, true)),
        "en",
        new Config.Deeplink("login-company", "5e4c4d18b7d75c37aac54a8f"),
        new Config.Search("67571ed7b278a518d7d8abdf"),
        metadata
    );

    Transact.Companion.registerReceiver(context, new TransactBroadcastReceiver() {
        @Override
        public void onDataRequest(JSONObject data) {
            // Handle data request for account/payment information
            Log.d("APP", "Data request: " + data.optJSONArray("fields"));
            // Return required data
        }

        @Override
        public void onInteraction(JSONObject data) {
            Log.d("APP", "Interaction event: " + data.optString("name") + " " + data.optJSONObject("value"));
        }

        @Override
        public void onFinish(JSONObject data) {
            Log.d("APP", "Finish event: " + data.optString("taskId") + " " + data.optString("handoff"));
        }

        @Override
        public void onClose(JSONObject data) {
            Log.d("APP", "Close event: " + data.optString("reason"));
        }
    });

    Transact.Companion.present(context, config);
  }
}

import { Atomic, Product } from "@atomicfi/transact-react-native"

Atomic.transact({
  config: {
    publicToken: "PUBLIC_TOKEN",
    scope: "user-link",
    tasks: [{ operation: "deposit" }],
    theme: {
      brandColor: "#9460FE",
      overlayColor: "#000000",
      dark: false,
      navigationOptions: {
        showBackButton: true,
        showBackButtonText: false,
        showCloseButton: true
      }
    },
    language: "en",
    deeplink: {
      step: "login-company",
      companyId: "5e4c4d18b7d75c37aac54a8f"
    },
    search: {
      ruleId: "67571ed7b278a518d7d8abdf"
    },
    metadata: {
      version: "1.2.1",
      test: "New User Experience",
      testVariant: "B"
    }
  },
  onDataRequest: request => {
    // Handle data request for account/payment information
    console.log('Data request:', request.fields)
    return { /* provide required data */ }
  },
  onInteraction: interaction => {
    console.log('Interaction event:', interaction.name, interaction.value)
  },
  onFinish: data => {
    console.log('Finish event:', data.taskId, data.handoff)
  },
  onClose: data => {
    console.log('Close event:', data.reason)
  }
})

import 'package:atomic_transact_flutter/atomic_transact_flutter.dart';

Atomic.transact(
  config: AtomicConfig(
    publicToken: "PUBLIC_TOKEN",
    scope: AtomicScope.userLink,
    tasks: [AtomicTask( product: AtomicProductType.deposit)],
    theme: AtomicTheme(
      brandColor: "#9460FE",
      overlayColor: "#000000",
      dark: false,
      navigationOptions: AtomicNavigationOptions(
        showBackButton: true,
        showBackButtonText: false,
        showCloseButton: true,
      ),
    ),
    language: "en",
    deeplink: AtomicDeeplink(
      step: "login-company",
      companyId: "5e4c4d18b7d75c37aac54a8f",
    ),
    search: AtomicSearch(
      ruleId: "67571ed7b278a518d7d8abdf",
    ),
    metadata: {
      "version": "1.2.1",
      "test": "New User Experience",
      "testVariant": "B",
    },
  ),
  onDataRequest: (AtomicTransactDataRequest request) {
    // Handle data request for account/payment information
    print("Data request: ${request.fields}");
    // Return required data
    return AtomicTransactDataResponse(/* provide required data */);
  },
  onInteraction: (AtomicTransactInteraction interaction) {
    print("Interaction event: ${interaction.name} ${interaction.value}");
  },
  onCompletion: (AtomicTransactCompletionType type,
      AtomicTransactResponse? response, AtomicTransactError? error) {
    if (type == AtomicTransactCompletionType.finished && response != null) {
      print("Finish event: ${response.taskId} ${response.handoff}");
    } else if (type == AtomicTransactCompletionType.closed && response != null) {
      print("Close event: ${response.reason}");
    } else if (error != null) {
      print("Error: ${error.message}");
    }
  },
);

import { Atomic, Product } from "@atomicfi/transact-javascript"

Atomic.transact({
  config: {
    publicToken: "PUBLIC_TOKEN",
    scope: "user-link",
    tasks: [{ operation: "deposit" }],
    theme: {
      brandColor: "#9460FE",
      overlayColor: "#000000",
      dark: false,
      navigationOptions: {
        showBackButton: true,
        showBackButtonText: false,
        showCloseButton: true
      }
    },
    language: "en",
    deeplink: {
      step: "login-company",
      companyId: "5e4c4d18b7d75c37aac54a8f"
    },
    search: {
      ruleId: "67571ed7b278a518d7d8abdf"
    },
    metadata: {
      version: "1.2.1",
      test: "New User Experience",
      testVariant: "B"
    }
  },
  onDataRequest: request => {
    // Handle data request for account/payment information
    console.log('Data request:', request.fields)
    return { /* provide required data */ }
  },
  onInteraction: interaction => {
    console.log('Interaction event:', interaction.name, interaction.value)
  },
  onFinish: data => {
    console.log('Finish event:', data.taskId, data.handoff)
  },
  onClose: data => {
    console.log('Close event:', data.reason)
  }
})

{
  "publicToken": "PUBLIC_TOKEN",
  "tasks": [
    {
      "operation": "deposit"
    }
  ]
}

https://transact.atomicfi.com/initialize/YOUR_BASE64_ENCODED_STRING