Noah virtual accounts and payouts

import 'package:portal_flutter/portal_flutter.dart';
import 'package:url_launcher/url_launcher.dart';

final portal = Portal();

const allowedHosts = {
  'checkout.noah.com',
  'checkout.sandbox.noah.com',
  'staging-checkout.noah.com',
};

try {
  final response = await portal.ramps.noah.initiateKyc(
    NoahInitiateKycRequest(
      returnUrl: 'https://yourapp.example/noah/return',
      fiatOptions: [NoahFiatOption(fiatCurrencyCode: 'USD')],
      customerType: NoahCustomerType.individual.value,
    ),
  );

  final uri = Uri.tryParse(response.data.hostedUrl);
  if (uri != null && uri.scheme == 'https' && allowedHosts.contains(uri.host)) {
    await launchUrl(uri, mode: LaunchMode.externalApplication);
  } else {
    // Handle this however your app prefers — surface it, log it, or fail the flow.
    print('Noah returned an unexpected KYC URL: ${response.data.hostedUrl}');
  }
} on PortalException catch (e) {
  print('initiateKyc failed: [${e.code}] ${e.message}');
}

Future<NoahInitiateKycResponse> initiateKyc(NoahInitiateKycRequest request)

final address = (await portal.getAddress(NoahNetwork.ethereumSepolia))!; // Requires an existing wallet

final payin = await portal.ramps.noah.initiatePayin(
  NoahInitiatePayinRequest(
    fiatCurrency: 'USD',
    cryptoCurrency: 'USDC_TEST',
    network: NoahNetwork.ethereumSepolia,
    destinationAddress: address,
  ),
);

print(payin.data.payinId);
// Show payin.data.bankDetails to the user as deposit instructions — do not log it.

Future<NoahInitiatePayinResponse> initiatePayin(NoahInitiatePayinRequest request)

final response = await portal.ramps.noah.simulatePayin(
  NoahSimulatePayinRequest(
    paymentMethodId: payin.data.bankDetails.paymentMethodId,
    fiatAmount: '10',
    fiatCurrency: 'USD',
  ),
);

print(response.data.fiatDepositId);

Future<NoahSimulatePayinResponse> simulatePayin(NoahSimulatePayinRequest request)

final response = await portal.ramps.noah.getPayoutCountries();

for (final entry in response.data.countries.entries) {
  print('${entry.key}: ${entry.value.join(', ')}');
}

Future<NoahGetPayoutCountriesResponse> getPayoutCountries()

final response = await portal.ramps.noah.getPayoutChannels(
  NoahGetPayoutChannelsRequest(
    cryptoCurrency: 'USDC_TEST',
    country: 'US',
    fiatCurrency: 'USD',
    fiatAmount: '10',
    pageSize: 10,
  ),
);

final channels = response.data.items.whereType<NoahChannel>().toList();
for (final channel in channels) {
  print('${channel.id} ${channel.paymentMethodType} ${channel.rate}');
}

// Pick the channel to pay out through
final channel = channels.first;

Future<NoahGetPayoutChannelsResponse> getPayoutChannels(NoahGetPayoutChannelsRequest request)

final response = await portal.ramps.noah.getPayoutChannelForm(channel.id);

// Render form fields from `response.data.formSchema` per Noah's schema
print(response.data.formMetadata?.contentHash ?? 'no schema metadata');

Future<NoahGetPayoutChannelFormResponse> getPayoutChannelForm(String channelId)

import 'dart:convert';

// Recipient fields matching the channel's `formSchema`. The schema depends on
// the region the customer completed KYC in.
final form = <String, Object>{
  'AccountHolderName': {
    'AccountHolderType': 'Individual',
    'Name': {'FirstName': 'John', 'LastName': 'Doe'},
  },
  // ... other fields required by the schema
};

final quote = await portal.ramps.noah.getPayoutQuote(
  NoahGetPayoutQuoteRequest(
    channelId: channel.id,
    cryptoCurrency: 'USDC_TEST',
    fiatAmount: '10',
    formJson: jsonEncode(form),
  ),
);

print(quote.data.payoutId);
print(quote.data.formSessionId);
print(quote.data.cryptoAmountEstimate);
print(quote.data.cryptoAuthorizedAmount);
print(quote.data.totalFee);

Future<NoahGetPayoutQuoteResponse> getPayoutQuote(NoahGetPayoutQuoteRequest request)

// Quote a fiat amount to receive
NoahGetPayoutQuoteRequest(channelId: channel.id, cryptoCurrency: 'USDC_TEST', fiatAmount: '10');

// Quote a crypto amount to sell
NoahGetPayoutQuoteRequest(channelId: channel.id, cryptoCurrency: 'USDC_TEST', cryptoAmount: '10.5');

import 'dart:math';

final sourceAddress = (await portal.getAddress(NoahNetwork.ethereumSepolia))!; // Requires an existing wallet
final expiry = DateTime.now().toUtc().add(const Duration(days: 1)).toIso8601String();

// Use a stable nonce per payout attempt and reuse it on retries (max 36 characters)
final random = Random.secure();
final nonce = List.generate(16, (_) => random.nextInt(256).toRadixString(16).padLeft(2, '0')).join();

final response = await portal.ramps.noah.initiatePayout(
  NoahInitiatePayoutRequest(
    payoutId: quote.data.payoutId,
    sourceAddress: sourceAddress,
    expiry: expiry,
    nonce: nonce,
    network: NoahNetwork.ethereumSepolia,
  ),
);

print(response.data.destinationAddress ?? 'no destination address');
print(response.data.conditions?.length ?? 0);

Future<NoahInitiatePayoutResponse> initiatePayout(NoahInitiatePayoutRequest request)

final trigger = NoahOnchainDepositSourceTrigger(
  single: NoahSingleOnchainDepositSourceTriggerInput(
    conditions: [
      NoahSingleOnchainDepositSourceTriggerCondition(
        amountConditions: [
          NoahSingleOnchainDepositSourceTriggerAmountCondition(
            comparisonOperator: NoahComparisonOperator.eq.value,
            value: quote.data.cryptoAuthorizedAmount,
          ),
        ],
        network: NoahNetwork.ethereumSepolia,
      ),
    ],
    sourceAddress: sourceAddress,
    expiry: expiry,
    nonce: nonce,
  ),
);

final response = await portal.ramps.noah.initiatePayout(
  NoahInitiatePayoutRequest(
    payoutId: quote.data.payoutId,
    sourceAddress: sourceAddress,
    expiry: expiry,
    nonce: nonce,
    network: NoahNetwork.ethereumSepolia,
    trigger: trigger,
  ),
);

final response = await portal.ramps.noah.getPaymentMethods(
  request: NoahGetPaymentMethodsRequest(
    pageSize: 10,
    capability: NoahPaymentMethodCapability.payoutTo.value,
  ),
);

print(response.data.paymentMethods.length);
print(response.data.pageToken ?? 'no more pages');

final response = await portal.ramps.noah.getPaymentMethods();

Future<NoahGetPaymentMethodsResponse> getPaymentMethods({NoahGetPaymentMethodsRequest? request})

try {
  final response = await portal.ramps.noah.getPayoutCountries();
  print(response.data.countries);
} on PortalException catch (e) {
  if (e.code == 'NOT_INITIALIZED') {
    print('Initialize Portal before calling Noah');
  } else {
    print('getPayoutCountries failed: [${e.code}] ${e.message}');
  }
}