Dfns

1. Plan operation        →  RebelFi returns unsigned transaction(s)
2. Broadcast via Dfns    →  Pass transaction to Dfns broadcastTransaction
3. Dfns signs & sends    →  Server-side MPC signing + on-chain broadcast
4. Poll for confirmation →  Wait for Dfns to confirm the transaction
5. Submit hash           →  Report the on-chain txHash back to RebelFi

import fs from 'node:fs';
import { DfnsApiClient } from '@dfns/sdk';
import { AsymmetricKeySigner } from '@dfns/sdk-keysigner';

const signer = new AsymmetricKeySigner({
  credId: process.env.DFNS_CRED_ID,
  privateKey: fs.readFileSync(process.env.DFNS_PRIVATE_KEY_PATH, 'utf-8'),
});

const dfns = new DfnsApiClient({
  orgId: process.env.DFNS_ORG_ID,
  authToken: process.env.DFNS_AUTH_TOKEN,
  baseUrl: 'https://api.dfns.io',
  signer,
});

import { RebelfiClient, Blockchain } from '@rebelfi/sdk';

const rebelfi = new RebelfiClient({ apiKey: process.env.REBELFI_API_KEY });

// Get the wallet address from Dfns
const dfnsWallet = await dfns.wallets.getWallet({
  walletId: process.env.DFNS_WALLET_ID,
});

// Register with RebelFi — detect blockchain from the network
const blockchain = dfnsWallet.network.toLowerCase().includes('solana')
  ? Blockchain.SOLANA
  : Blockchain.ETHEREUM;

const wallet = await rebelfi.wallets.register({
  walletAddress: dfnsWallet.address,
  blockchain,
});

import type { UnsignedTransactionDetail, EvmTransactionFields } from '@rebelfi/sdk';

const POLL_INTERVAL_MS = 3_000;
const MAX_POLL_ATTEMPTS = 120;

const TERMINAL_STATUSES = new Set(['Confirmed', 'Failed', 'Rejected']);

function buildBroadcastBody(tx: UnsignedTransactionDetail) {
  const blockchain = tx.blockchain.toLowerCase();

  if (blockchain === 'solana') {
    // Solana: convert base64 serialized tx to hex
    const hexTx = '0x' + Buffer.from(
      tx.unsignedTransaction.serialized, 'base64'
    ).toString('hex');
    return { kind: 'Transaction' as const, transaction: hexTx };
  }

  // EVM: pass structured transaction fields
  const evm = tx.evmTransaction!;
  return {
    kind: 'Transaction' as const,
    transaction: {
      to: evm.to,
      data: evm.data,
      value: evm.value || '0',
    },
  };
}

async function signAndBroadcast(
  tx: UnsignedTransactionDetail,
  walletId: string,
): Promise<{ txHash: string }> {
  const result = await dfns.wallets.broadcastTransaction({
    walletId,
    body: buildBroadcastBody(tx),
  });

  const dfnsTxId = result.id;

  // Poll until Dfns confirms the transaction on-chain
  for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
    const txInfo = await dfns.wallets.getTransaction({
      walletId,
      transactionId: dfnsTxId,
    });

    if (!TERMINAL_STATUSES.has(txInfo.status)) continue;

    if (txInfo.status === 'Confirmed') {
      return { txHash: txInfo.txHash! };
    }

    throw new Error(
      `Dfns transaction ${dfnsTxId} ended with status: ${txInfo.status}`
    );
  }

  throw new Error(`Dfns transaction ${dfnsTxId} timed out`);
}

async function supply(
  walletId: number,
  strategyId: number,
  amount: string,
  tokenAddress: string,
  dfnsWalletId: string,
) {
  // 1. Plan the supply — RebelFi returns unsigned transactions
  const operation = await rebelfi.operations.supply({
    walletId,
    strategyId,
    amount,
    tokenAddress,
  });
  console.log(`Operation ${operation.operationId} created`);

  // 2. Fetch the unsigned transactions
  const unsignedTxs = await rebelfi.operations.getUnsignedTransactions(
    operation.operationId,
  );
  console.log(`${unsignedTxs.length} transaction(s) to sign`);

  // 3. Sign and submit each transaction via Dfns
  for (const tx of unsignedTxs) {
    console.log(`Signing: ${tx.description} (${tx.blockchain})`);
    const { txHash } = await signAndBroadcast(tx, dfnsWalletId);

    // 4. Report the hash back to RebelFi
    await rebelfi.transactions.submitHash({
      operationId: operation.operationId,
      txHash,
      transactionId: tx.attemptId,
    });
    console.log(`Submitted: ${tx.description} (${txHash})`);
  }

  // 5. Confirm final status
  const final = await rebelfi.operations.get(operation.operationId);
  console.log(`Final status: ${final.status}`);
  return final;
}

async function unwind(
  walletId: number,
  strategyId: number,
  amount: string,
  dfnsWalletId: string,
) {
  const operation = await rebelfi.operations.unwind({
    walletId,
    strategyId,
    amount,
  });

  const unsignedTxs = await rebelfi.operations.getUnsignedTransactions(
    operation.operationId,
  );

  for (const tx of unsignedTxs) {
    const { txHash } = await signAndBroadcast(tx, dfnsWalletId);

    await rebelfi.transactions.submitHash({
      operationId: operation.operationId,
      txHash,
      transactionId: tx.attemptId,
    });
  }

  return rebelfi.operations.get(operation.operationId);
}