Flow payments with Flutter

# Create a flow from your backend (returns a flowId)
curl --request POST \
  --url "https://app.dynamic.xyz/api/v0/server/$DYNAMIC_ENVIRONMENT_ID/flow/payment" \
  --header "Authorization: Bearer $DYNAMIC_API_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{
    "amount": "25.00",
    "currency": "USD",
    "settlementConfig": {
      "strategy": "cheapest",
      "settlements": [
        {
          "chainName": "EVM",
          "tokenAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
          "chainId": "1",
          "symbol": "USDC",
          "tokenDecimals": 6
        }
      ]
    },
    "destinationConfig": {
      "destinations": [
        {
          "chainName": "EVM",
          "type": "address",
          "identifier": "0xYourSettlementAddress"
        }
      ]
    },
    "memo": {
      "description": "Payment for order #1234"
    }
  }'

dependencies:
  dynamic_sdk: ^1.15.1
  dynamic_sdk_fireblocks_flow: ^1.15.1

dependencies:
  dynamic_sdk_web3dart: ^1.15.1

dependencies:
  dynamic_sdk_solana: ^1.15.1

flutter pub get

import 'package:dynamic_sdk/dynamic_sdk.dart';
import 'package:dynamic_sdk_fireblocks_flow/dynamic_sdk_fireblocks_flow.dart';
import 'package:flutter/material.dart';

// Initialized earlier in main()
// DynamicSDK.init(
//   props: ClientProps(
//     environmentId: 'YOUR_ENVIRONMENT_ID',
//     appName: 'Your App',
//     appOrigin: 'https://your-app.com',
//   ),
// );

Future<void> runFlow({
  required String flowId,
  required BaseWallet wallet,
}) async {
  final flow = DynamicSDK.instance.fireblocksFlow;

  // Step 1: attach the source wallet
  final attached = await flow.attachSource(
    flowId: flowId,
    request: AttachSourceRequest(
      sourceType: FlowSourceType.wallet,
      fromAddress: wallet.address,
      fromChainId: '1',
      fromChainName: ChainEnum.evm,
    ),
  );

  // Step 2: get a quote. Quotes expire 60 seconds after creation.
  final quoted = await flow.getQuote(
    flowId: flowId,
    request: const GetQuoteRequest(
      fromTokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
    ),
  );

  print('Quote: ${quoted.quote}');

  // Step 3: prepare the unsigned source-chain payload
  final prepared = await flow.prepareSigning(flowId: flowId);

  // Step 4: sign and broadcast with the source wallet's signer
  // (see chain-specific examples below)
  final txHash = await signAndBroadcast(prepared.signingPayload, wallet);

  // Step 5: record the broadcast
  await flow.broadcast(
    flowId: flowId,
    request: BroadcastRequest(txHash: txHash),
  );

  // Step 6: poll until settlement finishes or the execution ends
  var status = await flow.getFlow(flowId: flowId);
  while (
    status.settlementState != FlowSettlementState.completed &&
    status.settlementState != FlowSettlementState.failed &&
    status.executionState != FlowExecutionState.cancelled &&
    status.executionState != FlowExecutionState.expired &&
    status.executionState != FlowExecutionState.failed
  ) {
    await Future.delayed(const Duration(seconds: 3));
    status = await flow.getFlow(flowId: flowId);
  }

  print('Final settlement state: ${status.settlementState}');
}

import 'package:dynamic_sdk/dynamic_sdk.dart';
import 'package:dynamic_sdk_web3dart/dynamic_sdk_web3dart.dart';
import 'package:web3dart/crypto.dart';
import 'package:web3dart/web3dart.dart';

Future<String> signAndBroadcast(
  SigningPayload payload,
  BaseWallet wallet,
) async {
  final evmTx = payload.evmTransaction;
  if (evmTx == null) {
    throw Exception('No EVM transaction in signing payload');
  }

  final transaction = Transaction(
    from: EthereumAddress.fromHex(wallet.address),
    to: EthereumAddress.fromHex(evmTx.to),
    data: evmTx.data.isEmpty ? null : hexToBytes(evmTx.data),
    value: EtherAmount.inWei(BigInt.parse(evmTx.value)),
    maxGas: evmTx.gasLimit != null ? int.tryParse(evmTx.gasLimit!) : null,
  );

  final txHash = await DynamicSDK.instance.web3dart.sendTransaction(
    transaction: transaction,
    wallet: wallet,
  );

  return txHash;
}

import 'package:dynamic_sdk/dynamic_sdk.dart';
import 'package:dynamic_sdk_solana/dynamic_sdk_solana.dart';

Future<String> signAndBroadcast(
  SigningPayload payload,
  BaseWallet wallet,
) async {
  final serialized = payload.serializedTransaction;
  if (serialized == null) {
    throw Exception('No serialized transaction in signing payload');
  }

  final signer = DynamicSDK.instance.solana.createSigner(wallet: wallet);
  final txHash = await signer.signAndSendEncodedTransaction(
    base64Transaction: serialized,
  );

  return txHash;
}

import 'dart:convert';

import 'package:dynamic_sdk/dynamic_sdk.dart';

Future<String> signAndBroadcast(
  SigningPayload payload,
  BaseWallet wallet,
) async {
  final psbtBase64 = payload.psbt;
  if (psbtBase64 == null) {
    throw Exception('No PSBT in signing payload');
  }

  final psbtBytes = base64.decode(psbtBase64);

  // Sign the PSBT with your Bitcoin signer library, then finalize and
  // broadcast the resulting transaction to the Bitcoin network.
  // This step is not provided by the Dynamic SDK.
  final txHash = await signPsbtAndBroadcast(psbtBytes, wallet);

  return txHash;
}

import 'package:dynamic_sdk/dynamic_sdk.dart';

Future<String> signAndBroadcast(
  SigningPayload payload,
  BaseWallet wallet,
) async {
  final tronTx = payload.tronTransaction;
  if (tronTx == null) {
    throw Exception('No TRON transaction in signing payload');
  }

  // Sign the raw transaction with your TRON signer and broadcast it to the
  // TRON network. This step is not provided by the Dynamic SDK.
  final txHash = await signTronTransactionAndBroadcast(tronTx, wallet);

  return txHash;
}

final status = await DynamicSDK.instance.fireblocksFlow.getFlow(
  flowId: flowId,
);

try {
  final quoted = await flow.getQuote(
    flowId: flowId,
    request: const GetQuoteRequest(fromTokenAddress: '0x...'),
  );
} on FireblocksFlowException catch (e) {
  if (e.sessionTokenInvalid) {
    // Token removed from storage; re-attach
    await flow.attachSource(
      flowId: flowId,
      request: AttachSourceRequest(
        sourceType: FlowSourceType.wallet,
        fromAddress: wallet.address,
        fromChainId: '1',
        fromChainName: ChainEnum.evm,
      ),
    );
  } else {
    print('Flow error: ${e.message}');
  }
}

Future<FlowStatus> pollUntilDone(FireblocksFlow flow, String flowId) async {
  const terminalExecution = [
    FlowExecutionState.cancelled,
    FlowExecutionState.expired,
    FlowExecutionState.failed,
  ];
  const terminalSettlement = [
    FlowSettlementState.completed,
    FlowSettlementState.failed,
  ];

  Future<FlowStatus> poll() async {
    final status = await flow.getFlow(flowId: flowId);

    if (terminalExecution.contains(status.executionState) ||
        terminalSettlement.contains(status.settlementState)) {
      return status;
    }

    await Future.delayed(const Duration(seconds: 3));
    return poll();
  }

  return poll();
}