Dispute resolver

The dispute resolver entity MUST be created before any dispute resolver actions can be performed.

Dispute resolvers decide the dispute outcome when the buyer and seller cannot do it mutually. The dispute resolver is a complex role with admin, assistant and treasury. Initially, all roles must be the same Ethereum address; however, the admin can later change them to other addresses.

Dispute resolvers decide in which tokens they are willing to accept the fee and what the amount is.

Dispute resolvers can set a list of allowed sellers, i.e. the seller ID for which they are willing to do the dispute resolution.

Dispute resolver's funds management is described in Deposit and withdraw.

TypeScript SDK

Create dispute resolver

Creates a new dispute resolver

const drAddress = signerWallet.address;

await coreSDK.createDisputeResolver({
  assistant: drAddress,
  admin: drAddress,
  treasury: drAddress,
  escalationResponsePeriodInMS: 10 * 24 * 60 * 60 * 1000, // 10 days
  fees: [
    {
    tokenAddress: "0x0000000000000000000000000000000000000000",
    tokenName: "ETH",
    feeAmount: parseEther("0.001")
    },
    {
    tokenAddress: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    tokenName: "USDC",
    feeAmount: "10000000000"
    }],
  metadataUri: "http://metadata.uri",
});

Update dispute resolver

Updates an existing dispute resolver.

const newAssistantWallet = Wallet.createRandom(ethereumProvider);
const disputeResolverId = "12";
const disputeResolver = await coreSDK.getDisputeResolverById(disputeResolverId);

// Start the update with the dispute resolver's wallet
await drCoreSDK.updateDisputeResolver({
   disputeResolverId,
   {
   assistant: newAssistantWallet.address,
   metadataUri: "ipfs://changed",
   escalationResponsePeriodInMS: 123_000
   }
);

// Finalize the update with the assistant's wallet 
const assistantCoreSDK = CoreSDK.fromDefaultConfig({
   envName,
   configId,
   web3Lib: new EthersAdapter(provider, newAssistantWallet),
});

await assistantCoreSDK.optInToDisputeResolverUpdate({
   id: disputeResolverId,
   fieldsToUpdate: {assistant: true}
})

Manage dispute resolver fees

Add supported fee tokens

const disputeResolverId = "12";

await drCoreSDK.addFeesToDisputeResolver(
    disputeResolverId,
    {
    tokenAddress: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    tokenName: "USDC",
    feeAmount: "10000000000"
    }
);

Remove supported fee tokens

const disputeResolverId = "12";

await drCoreSDK.removeFeesFromDisputeResolver(
    disputeResolverId,
    {
    tokenAddress: "0x0000000000000000000000000000000000000000",
    tokenName: "ETH",
    feeAmount: parseEther("0.001")
    }
);

Manage allowlisted sellers

Add and remove sellers from the dispute resolver's allowlist.

Add sellers to the allowlist

const disputeResolverId = "12";
const sellerId1 = "153";
const sellerId2 = "2";

await drCoreSDK.addSellersToDisputeResolverAllowList(
    disputeResolverId,
    [sellerId1, sellerId2]
);

Remove sellers from the allowlist

const disputeResolverId = "12";
const sellerId1 = "153";
const sellerId2 = "2";

await drCoreSDK.removeSellersFromDisputeResolverAllowList(
    disputeResolverId,
    [sellerId1, sellerId2]
);

Solidity

Create dispute resolver

Creates a new dispute resolver

IBosonAccountHandler bosonProtocol = IBosonAccountHandler(_bosonProtocolAddress);

BosonTypes.DisputeResolver memory disputeResolver = BosonTypes.DisputeResolver({
    id: 0, // will be ignored and auto-assigned
    escalationResponsePeriod: 604800, // 1 week in seconds
    assistant: assistantAddress,
    admin: adminAddress,
    clerk: address(0), // deprecated, always zero
    treasury: payable(treasuryAddress),
    metadataUri: "https://ipfs.io/ipfs/dispute-resolver-metadata",
    active: true
});

// Define supported token fees
BosonTypes.DisputeResolverFee[] memory disputeResolverFees = new BosonTypes.DisputeResolverFee[](2);
disputeResolverFees[0] = BosonTypes.DisputeResolverFee({
    tokenAddress: address(0), // native token
    tokenName: "ETH",
    feeAmount: 1e17 // 0.1 ETH
});
disputeResolverFees[1] = BosonTypes.DisputeResolverFee({
    tokenAddress: usdcTokenAddress,
    tokenName: "USDC", 
    feeAmount: 50e6 // 50 USDC (6 decimals)
});

// Define allowed sellers (empty array means no restrictions)
uint256[] memory sellerAllowList = new uint256[](0);

bosonProtocol.createDisputeResolver(disputeResolver, disputeResolverFees, sellerAllowList);

Update dispute resolver

Updates an existing dispute resolver.

Changes to admin/assistant require opt-in from the new addresses.

IBosonAccountHandler bosonProtocol = IBosonAccountHandler(_bosonProtocolAddress);

BosonTypes.DisputeResolver memory disputeResolver = BosonTypes.DisputeResolver({
    id: 1, // existing dispute resolver ID
    escalationResponsePeriod: 1209600, // 2 weeks in seconds
    assistant: newAssistantAddress,
    admin: newAdminAddress,
    clerk: address(0), // deprecated, always zero
    treasury: payable(newTreasuryAddress),
    metadataUri: "https://ipfs.io/ipfs/updated-dispute-resolver-metadata",
    active: true // active flag from storage will be used
});

bosonProtocol.updateDisputeResolver(disputeResolver);

// For admin/assistant updates, new addresses must opt in:
bosonProtocol.optInToDisputeResolverUpdate(disputeResolverId, fieldsToUpdate);

Manage dispute resolver fees

Add and remove supported fee tokens.

IBosonAccountHandler bosonProtocol = IBosonAccountHandler(_bosonProtocolAddress);
uint256 disputeResolverId = 1;

// Add new fee tokens
BosonTypes.DisputeResolverFee[] memory newFees = new BosonTypes.DisputeResolverFee[](1);
newFees[0] = BosonTypes.DisputeResolverFee({
    tokenAddress: daiTokenAddress,
    tokenName: "DAI",
    feeAmount: 25e18 // 25 DAI (18 decimals)
});

bosonProtocol.addFeesToDisputeResolver(disputeResolverId, newFees);

// Remove fee tokens
address[] memory tokenAddressesToRemove = new address[](1);
tokenAddressesToRemove[0] = usdcTokenAddress;

bosonProtocol.removeFeesFromDisputeResolver(disputeResolverId, tokenAddressesToRemove);

Manage allowlisted sellers

Add and remove sellers from the dispute resolver's allowlist.

IBosonAccountHandler bosonProtocol = IBosonAccountHandler(_bosonProtocolAddress);
uint256 disputeResolverId = 1;

// Add sellers to allowlist
uint256[] memory sellersToAdd = new uint256[](2);
sellersToAdd[0] = 1;
sellersToAdd[1] = 2;

bosonProtocol.addSellersToAllowList(disputeResolverId, sellersToAdd);

// Remove sellers from allowlist
uint256[] memory sellersToRemove = new uint256[](1);
sellersToRemove[0] = 1;

bosonProtocol.removeSellersFromAllowList(disputeResolverId, sellersToRemove);