Token Transfers

import { useAccount, useTransactionFlow } from '@partylayer/react';
import type { TokenDisclosedContract } from '@partylayer/react/query';

const TRANSFER_FACTORY_INTERFACE =
  '#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferFactory';

function TransferButton({
  factoryCid,
  choiceContext,
  disclosedContracts,
  inputHoldingCids,
  dsoParty,
  receiverPartyId,
}: {
  factoryCid: string;             // factoryId from Scan transfer-factory
  choiceContext: Record<string, unknown>; // raw choiceContext.choiceContextData from Scan
  disclosedContracts: TokenDisclosedContract[]; // from that SAME fresh choice context
  inputHoldingCids: string[];     // from your ACS query
  dsoParty: string;               // instrument admin (e.g. DSO on the network)
  receiverPartyId: string;
}) {
  const { isConnected, party } = useAccount();
  const flow = useTransactionFlow(); // add an independent confirm reader; see Transaction lifecycle

  const handleTransfer = async () => {
    if (!isConnected || !party) return;

    const nowIso = new Date().toISOString();
    const expiresIso = new Date(Date.now() + 5 * 60_000).toISOString();

    // v2 JSON Ledger API: interface exercises use the standard ExerciseCommand
    // wrapper with the interfaceId placed in the templateId field.
    const payload = {
      commands: [
        {
          ExerciseCommand: {
            templateId: TRANSFER_FACTORY_INTERFACE,
            contractId: factoryCid,
            choice: 'TransferFactory_Transfer',
            choiceArgument: {
              expectedAdmin: dsoParty,
              transfer: {
                sender: party,
                receiver: receiverPartyId,
                amount: '10.0',
                instrumentId: { admin: dsoParty, id: 'Amulet' },
                lock: null,
                requestedAt: nowIso,
                executeBefore: expiresIso,
                inputHoldingCids,
                meta: { values: {} },
              },
              // extraArgs.context is the ChoiceContext blob from the Scan
              // transfer-factory response, passed through unchanged. The
              // canonical Splice CLI assigns it verbatim, with NO extra wrapping:
              //   extraArgs.context = transferFactory.choiceContext.choiceContextData
              // choiceContext below already IS that choiceContextData object.
              extraArgs: {
                context: choiceContext,
                meta: { values: {} },
              },
            },
          },
        },
      ],
      commandId: crypto.randomUUID(),
      applicationId: 'my-app',
      actAs: [party],
      readAs: [],
      disclosedContracts,
    };

    // Wallet-owned prepare/approve/sign/execute. Exactly one submission.
    const result = await flow.submitTransaction({ signedTx: payload }, { commandId: payload.commandId });
    console.log(result.status, result.receipt); // submitted is NOT settled
  };

  if (!isConnected) return null;

  return (
    <>
      <button onClick={() => { void handleTransfer().catch(console.error); }} disabled={flow.isPending}>
        {flow.isPending ? 'Awaiting wallet…' : 'Transfer 10 Amulet'}
      </button>
      {flow.transaction?.error && <p>Error: {flow.transaction.error.message}</p>}
    </>
  );
}

const TRANSFER_INSTRUCTION_INTERFACE =
  '#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferInstruction';

await client.submitTransaction({
  signedTx: {
    commands: [{
      ExerciseCommand: {
        templateId: TRANSFER_INSTRUCTION_INTERFACE, // interfaceId goes in templateId
        contractId: instructionCid,                 // from the recipient's ACS
        choice: 'TransferInstruction_Accept',
        choiceArgument: {
          extraArgs: {
            context: acceptChoiceContext, // raw choiceContextData from Scan, passed through unchanged
            meta: { values: {} },
          },
        },
      },
    }],
    commandId: crypto.randomUUID(),
    applicationId: 'my-app',
    actAs: [recipientPartyId],
    readAs: [],
    disclosedContracts: acceptDisclosedContracts, // from the fresh ACCEPT context
  },
});

import {
  UserRejectedError,
  SessionExpiredError,
  CapabilityNotSupportedError,
} from '@partylayer/sdk';

try {
  const result = await client.submitTransaction({ signedTx: payload });
  // A returned acknowledgement still needs independent ledger confirmation.
} catch (err) {
  if (err instanceof UserRejectedError) {
    // Show rejection. A new attempt requires another explicit user action.
  } else if (err instanceof SessionExpiredError) {
    // Offer reconnect. Reconcile any issued write before a new submission.
  } else if (err instanceof CapabilityNotSupportedError) {
    // Explain that this operation is unavailable for the selected wallet.
  } else {
    // Preserve unknown outcome. Do not automatically send the payload again.
  }
}