useResolveDispute

Resolve disputas de escrow distribuindo os fundos ao aprovador e ao provedor de serviço conforme determinado pelo solucionador da disputa.

Uso

Este hook customizado expõe uma função para resolver uma disputa em um escrow.

import { useResolveDispute } from "@trustless-work/escrow/hooks";
import { MultiReleaseResolveDisputePayload, SingleReleaseResolveDisputePayload } from "@trustless-work/escrow/types";

/*
 *  useResolveDispute
*/
const { resolveDispute } = useResolveDispute();

/* 
 * Retorna uma transação não assinada
 * payload deve ser do tipo `MultiReleaseResolveDisputePayload` ou `SingleReleaseResolveDisputePayload`
*/
const { unsignedTransaction } = await resolveDispute(payload);

Função de Mutação

resolveDispute

Responsável por construir e retornar uma transação não assinada com base no payload fornecido.

TipoDeEscrow: Especifica o tipo de escrow. Aceita os seguintes valores:

• multi-release: Permite múltiplos desembolsos de fundos.

• single-release: Os fundos são liberados em uma única transação.

SingleReleaseResolveDisputePayload: Um objeto com os campos necessários para resolver uma single-release escrow.

MultiReleaseResolveDisputePayload: Um objeto com os campos necessários para resolver uma multi-release escrow por marco.

Parâmetros:

Garanta que correspondam: se você escolher o tipo "multi-release", também deve usar um payload "multi-release".

• tipo: Descreve o tipo de escrow a ser usado. As opções são "multi-release" ou "single-release".

• payload: Um objeto contendo os campos obrigatórios para resolver uma disputa.

Resolver disputa

Valor de Retorno:

unsignedTransaction: Um objeto representando a transação construída, pronto para ser assinado pela sua carteira e transmitido.

---

Exemplo de Uso

src/hooks/useResolveDisputeForm.ts

import {
  useResolveDispute,
  useSendTransaction,
} from "@trustless-work/escrow/hooks";
import {
  MultiReleaseResolveDisputePayload, SingleReleaseResolveDisputePayload
} from "@trustless-work/escrow/types";

export const useStartDisputeForm = () => {

 /*
  *  useResolveDispute
 */
 const { resolveDispute } = useResolveDispute();
 
 /*
  *  useSendTransaction
 */
 const { sendTransaction } = useSendTransaction();

/*
 * função onSubmit, isso pode ser chamada por um botão de formulário
*/
 const onSubmit = async (payload: MultiReleaseResolveDisputePayload | SingleReleaseResolveDisputePayload) => {

    try {
      /**
       * Chamada de API usando os hooks do trustless work
       * @Nota:
       * - Precisamos passar o payload para a função resolveDispute
       * - O resultado será uma transação não assinada
       */
      const { unsignedTransaction } = await resolveDispute(
        payload,
        "multi-release"
        // ou ...
        //"single-release"
      );

      if (!unsignedTransaction) {
        throw new Error(
          "Transação não assinada está ausente em resolveDispute."
        );
      }

      /**
       * @Nota:
       * - Precisamos assinar a transação usando sua [chave privada], como uma carteira
       * - O resultado será uma transação assinada
       */
      const signedXdr = await signTransaction({ /* Este método deve ser fornecido pela carteira */
        unsignedTransaction,
        address: walletAddress || "",
      });

      if (!signedXdr) {
        throw new Error("Transação assinada está ausente.");
      }

      /**
       * @Nota:
       * - Precisamos enviar a transação assinada para a API
       * - Os dados serão um SendTransactionResponse
       */
      const data = await sendTransaction(signedXdr);

      /**
       * @Respostas:
       * data.status === "SUCCESS"
       * - Disputa resolvida com sucesso
       * - Mostrar um toast de sucesso
       *
       * data.status == "ERROR"
       * - Mostrar um toast de erro
       */
      if (data.status === "SUCCESS") {
         toast.success("Disputa Resolvida");
      }
    } catch (error: unknown) {
      // lógica de captura de erro
    }
  };
}