Bulk Transfers

{
  "recipients": [
    {
      "type": "Crypto",
      "currency": "WEUR",
      "amount": "1.50",
      "crypto": {
        "address": "0xA7E41d5680dE394EaA2ed417169DFf56840Fb3EE",
        "network": "Base"
      }
    },
    {
      "type": "Crypto",
      "currency": "WEUR",
      "amount": "2.25",
      "crypto": {
        "address": "0xAAFF0821A09A1Aac28B72dD3Ff410A7ea5FEb874",
        "network": "Base"
      }
    }
  ]
}

{
  "transaction_id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "operation_id": "64120850-73a1-4df5-a074-d463258c9deb",
  "crypto_transfers": [
    {
      "address": "0xA7E41d5680dE394EaA2ed417169DFf56840Fb3EE",
      "precise_amount": "1500000000000000000",
      "token_address": "0x5c55F314624718019A326F16a62A05D6C6d8C8A2"
    },
    {
      "address": "0xAAFF0821A09A1Aac28B72dD3Ff410A7ea5FEb874",
      "precise_amount": "2250000000000000000",
      "token_address": "0x5c55F314624718019A326F16a62A05D6C6d8C8A2"
    }
  ]
}

const response = await fetch(`${baseUrl}/api/v1/bulk/transfer`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${corporationToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    recipients: payouts.map((p) => ({
      type: 'Crypto',
      currency: 'WEUR',
      amount: p.amount.toFixed(2), // anything past 2 decimals is discarded
      crypto: { address: p.address, network: 'Base' }
    }))
  })
});
const approval = await response.json();

response = requests.post(
    f"{base_url}/api/v1/bulk/transfer",
    headers={
        "Authorization": f"Bearer {corporation_token}",
        "Content-Type": "application/json",
    },
    json={
        "recipients": [
            {
                "type": "Crypto",
                "currency": "WEUR",
                "amount": f"{p['amount']:.2f}",  # anything past 2 decimals is discarded
                "crypto": {"address": p["address"], "network": "Base"},
            }
            for p in payouts
        ]
    },
)
approval = response.json()

recipients := make([]map[string]interface{}, 0, len(payouts))
for _, p := range payouts {
    recipients = append(recipients, map[string]interface{}{
        "type":     "Crypto",
        "currency": "WEUR",
        "amount":   fmt.Sprintf("%.2f", p.Amount), // anything past 2 decimals is discarded
        "crypto":   map[string]string{"address": p.Address, "network": "Base"},
    })
}

body, _ := json.Marshal(map[string]interface{}{"recipients": recipients})

req, _ := http.NewRequest("POST", baseURL+"/api/v1/bulk/transfer", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer "+corporationToken)
req.Header.Set("Content-Type", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

var approval BulkTransferResponse
json.NewDecoder(resp.Body).Decode(&approval)

function executeOutgoingBatchTransaction(
    bytes16   transactionId,
    bytes16   operationId,
    address   tokenAddress,
    address[] recipients,
    uint256[] amounts
)

import { createPublicClient, encodeFunctionData, http, pad, type Address, type Hex } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";
import { createKernelAccount, createKernelAccountClient, createZeroDevPaymasterClient } from "@zerodev/sdk";
import { getEntryPoint, KERNEL_V3_1 } from "@zerodev/sdk/constants";
import { toPermissionValidator } from "@zerodev/permissions";
import { toSudoPolicy } from "@zerodev/permissions/policies";
import { toECDSASigner } from "@zerodev/permissions/signers";

// From GET /api/v1/config → chains.<id>
const chainConfig = { rpcUrl, bundlerUrl, paymasterUrl, contractRegistry };

const publicClient = createPublicClient({ chain: base, transport: http(chainConfig.rpcUrl) });

const contractByName = (name: string) =>
  publicClient.readContract({
    address: chainConfig.contractRegistry,
    abi: [{ type: "function", name: "contractByName", stateMutability: "view", inputs: [{ type: "string" }], outputs: [{ type: "address" }] }],
    functionName: "contractByName",
    args: [name],
  });

const fundsManagement = await contractByName("FundsManagement");
const delayPolicy = await contractByName("ExecutionDelayCorporatePolicy");

// The corporation wallet, signed by an employee key
const entryPoint = getEntryPoint("0.7");
const validator = await toPermissionValidator(publicClient, {
  entryPoint,
  kernelVersion: KERNEL_V3_1,
  signer: await toECDSASigner({ signer: privateKeyToAccount(employeePrivateKey) }),
  policies: [toSudoPolicy({ policyAddress: delayPolicy })],
});
validator.address = delayPolicy;

const account = await createKernelAccount(publicClient, {
  entryPoint,
  kernelVersion: KERNEL_V3_1,
  plugins: { sudo: validator },
  address: corporationAddress,
});
const paymaster = createZeroDevPaymasterClient({ chain: base, transport: http(chainConfig.paymasterUrl) });
const wallet = createKernelAccountClient({
  account,
  chain: base,
  bundlerTransport: http(chainConfig.bundlerUrl),
  paymaster: { getPaymasterData: (userOperation) => paymaster.sponsorUserOperation({ userOperation }) },
});

// The call, built from the Step 1 response
const toBytes16 = (uuid: string) => pad(`0x${uuid.replace(/-/g, "")}` as Hex, { size: 16 });
const transfers = approval.crypto_transfers;

const callData = await account.encodeCalls([{
  to: fundsManagement,
  value: 0n,
  data: encodeFunctionData({
    abi: [{
      type: "function",
      name: "executeOutgoingBatchTransaction",
      stateMutability: "nonpayable",
      inputs: [
        { type: "bytes16", name: "transactionId" },
        { type: "bytes16", name: "operationId" },
        { type: "address", name: "tokenAddress" },
        { type: "address[]", name: "recipients" },
        { type: "uint256[]", name: "amounts" },
      ],
      outputs: [],
    }],
    functionName: "executeOutgoingBatchTransaction",
    args: [
      toBytes16(approval.transaction_id),
      toBytes16(approval.operation_id),
      transfers[0].token_address as Address,
      transfers.map((t) => t.address as Address),
      transfers.map((t) => BigInt(t.precise_amount)),
    ],
  }),
}]);

// Retry until the approval is on-chain ("Batch transaction not found" until then)
let txHash: Hex | undefined;
for (let attempt = 1; !txHash && attempt <= 20; attempt++) {
  try {
    const userOpHash = await wallet.sendUserOperation({ callData });
    const receipt = await wallet.waitForUserOperationReceipt({ hash: userOpHash });
    txHash = receipt.receipt.transactionHash;
  } catch {
    await new Promise((resolve) => setTimeout(resolve, 6000));
  }
}

{
  "id": "8b7a4f9b-537f-cba9-c18b-8dbe91c4247f",
  "corporation_address": "0xAAFF0821A09A1Aac28B72dD3Ff410A7ea5FEb874",
  "type": "Crypto",
  "direction": "Outbound",
  "status": "Completed",
  "source": { 
    "type": "Wallet", 
    "wallet": { 
      "address": "0xAAFF0821A09A1Aac28B72dD3Ff410A7ea5FEb874" 
    } 
  },
  "destination": { 
    "type": "ExternalWallet", 
    "wallet": { 
      "address": "0xA7E41d5680dE394EaA2ed417169DFf56840Fb3EE" 
    } 
  },
  "source_amount": { 
    "amount": -1.5, 
    "amount_precise": "-1500000000000000000", 
    "decimals": 18, 
    "token_symbol": "WEUR", 
    "token_address": "0x5c55F314624718019A326F16a62A05D6C6d8C8A2" 
  },
  "destination_amount": { 
    "amount": 1.5, 
    "amount_precise": "1500000000000000000", 
    "decimals": 18, 
    "token_symbol": "WEUR", 
    "token_address": "0x5c55F314624718019A326F16a62A05D6C6d8C8A2" 
  },
  "operations": [
    { 
      "hash": "0x6fb13e90d9696c9a8f7415527b396102ef2b455e8ddad3aa92af9d44b5ca9a1e", 
      "operation_amount": { 
        "amount": -1.5, 
        "token_symbol": "WEUR" 
      } 
    }
  ],
  "activity_steps": [
    { 
      "type": "Initiated", 
      "status": "Completed", 
      "created_at": "2024-01-01T10:00:00Z", 
      "completed_at": "2024-01-01T10:00:00Z" 
    },
    { 
      "type": "CryptoOut", 
      "status": "Completed", 
      "created_at": "2024-01-01T10:00:00Z", 
      "completed_at": "2024-01-01T10:00:00Z" 
    },
    { 
      "type": "Completed", 
      "status": "Completed", 
      "created_at": "2024-01-01T10:00:00Z", 
      "completed_at": "2024-01-01T10:00:00Z"
    }
  ],
  "created_at": "2024-01-01T10:00:00Z"
}

const response = await fetch(`${baseUrl}/api/v1/activity/feed?page_number=0&page_size=50`, {
  headers: { 'Authorization': `Bearer ${corporationToken}` }
});
const feed = await response.json();
const legs = feed.data.filter((item) =>
  item.operations?.some((op) => op.hash.toLowerCase() === txHash.toLowerCase())
);

response = requests.get(
    f"{base_url}/api/v1/activity/feed",
    params={"page_number": 0, "page_size": 50},
    headers={"Authorization": f"Bearer {corporation_token}"},
)
legs = [
    item for item in response.json()["data"]
    if any(op["hash"].lower() == tx_hash.lower() for op in item.get("operations", []))
]

req, _ := http.NewRequest("GET", baseURL+"/api/v1/activity/feed?page_number=0&page_size=50", nil)
req.Header.Set("Authorization", "Bearer "+corporationToken)

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

var feed ActivityFeedResponse
json.NewDecoder(resp.Body).Decode(&feed)

legs := []ActivityItem{}
for _, item := range feed.Data {
    for _, op := range item.Operations {
        if strings.EqualFold(op.Hash, txHash) {
            legs = append(legs, item)
        }
    }
}

{
  "error_reason": "ErrorInvalidField",
  "error_description": "All recipients must use the same currency",
  "error_category": {
    "category": "CategoryValidationFailure",
    "http_status_code": 400
  },
  "error_details": [
    { "key": "field", "details": "recipients[1].currency" },
    { "key": "issue", "details": "currency_mismatch" }
  ]
}