@bosonprotocol/core-sdk 1.12.0-alpha.1 → 1.12.0-alpha.10

package/dist/esm/utils/graphql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../src/utils/graphql.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD"}
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../src/utils/graphql.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD"}

package/dist/esm/utils/tokenInfoManager.d.ts

@@ -0,0 +1,16 @@
+import { Web3LibAdapter } from "@bosonprotocol/common";
+export interface ITokenInfo {
+    name: string;
+    decimals: number;
+    symbol: string;
+}
+export interface ITokenInfoManager {
+    getExchangeTokenInfo: (tokenAddress: string) => Promise<ITokenInfo>;
+}
+export declare class TokenInfoManager implements ITokenInfoManager {
+    private _tokenInfos;
+    private _web3Lib;
+    constructor(chainId: number, web3Lib: Web3LibAdapter);
+    getExchangeTokenInfo(tokenAddress: string): Promise<ITokenInfo>;
+}
+//# sourceMappingURL=tokenInfoManager.d.ts.map

package/dist/esm/utils/tokenInfoManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenInfoManager.d.ts","sourceRoot":"","sources":["../../../src/utils/tokenInfoManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAIvD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACrE;AAqDD,qBAAa,gBAAiB,YAAW,iBAAiB;IACxD,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,QAAQ,CAAiB;gBAEd,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc;IAQ9C,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAmB7E"}

package/dist/esm/utils/tokenInfoManager.js

@@ -0,0 +1,83 @@
+import { AddressZero } from "@ethersproject/constants";
+import { erc20 } from "..";
+const NATIVE_TOKENS = {
+    1: {
+        // Ethereum Mainnet
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    3: {
+        // Ethereum Ropsten
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    4: {
+        // Ethereum Rinkeby
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    5: {
+        // Ethereum Goerli
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    137: {
+        // Polygon Mainnet
+        name: "MATIC",
+        decimals: 18,
+        symbol: "MATIC"
+    },
+    80001: {
+        // Polygon Mumbai
+        name: "MATIC",
+        decimals: 18,
+        symbol: "MATIC"
+    },
+    1234: {
+        // Private Node
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    },
+    31337: {
+        // Local Hardhat
+        name: "Ether",
+        decimals: 18,
+        symbol: "ETH"
+    }
+};
+export class TokenInfoManager {
+    _tokenInfos = new Map();
+    _web3Lib;
+    constructor(chainId, web3Lib) {
+        if (!NATIVE_TOKENS[chainId]) {
+            throw new Error(`Unexpected chainId value '${chainId}'`);
+        }
+        this._tokenInfos.set(AddressZero, NATIVE_TOKENS[chainId]);
+        this._web3Lib = web3Lib;
+    }
+    async getExchangeTokenInfo(tokenAddress) {
+        if (!this._tokenInfos.has(tokenAddress.toLowerCase())) {
+            const args = {
+                web3Lib: this._web3Lib,
+                contractAddress: tokenAddress
+            };
+            const [decimals, name, symbol] = await Promise.all([
+                erc20.handler.getDecimals(args),
+                erc20.handler.getName(args),
+                erc20.handler.getSymbol(args)
+            ]);
+            this._tokenInfos.set(tokenAddress.toLowerCase(), {
+                decimals,
+                name,
+                symbol
+            });
+        }
+        return this._tokenInfos.get(tokenAddress.toLowerCase());
+    }
+}
+//# sourceMappingURL=tokenInfoManager.js.map

package/dist/esm/utils/tokenInfoManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenInfoManager.js","sourceRoot":"","sources":["../../../src/utils/tokenInfoManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC;AAY3B,MAAM,aAAa,GAAkC;IACnD,CAAC,EAAE;QACD,mBAAmB;QACnB,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,CAAC,EAAE;QACD,mBAAmB;QACnB,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,CAAC,EAAE;QACD,mBAAmB;QACnB,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,CAAC,EAAE;QACD,kBAAkB;QAClB,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,GAAG,EAAE;QACH,kBAAkB;QAClB,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,OAAO;KAChB;IACD,KAAK,EAAE;QACL,iBAAiB;QACjB,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,OAAO;KAChB;IACD,IAAI,EAAE;QACJ,eAAe;QACf,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,KAAK,EAAE;QACL,gBAAgB;QAChB,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;CACF,CAAC;AAEF,MAAM,OAAO,gBAAgB;IACnB,WAAW,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC5C,QAAQ,CAAiB;IAEjC,YAAmB,OAAe,EAAE,OAAuB;QACzD,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,6BAA6B,OAAO,GAAG,CAAC,CAAC;SAC1D;QACD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;QAC1D,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAAC,YAAoB;QACpD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,EAAE;YACrD,MAAM,IAAI,GAAG;gBACX,OAAO,EAAE,IAAI,CAAC,QAAQ;gBACtB,eAAe,EAAE,YAAY;aAC9B,CAAC;YACF,MAAM,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;gBACjD,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC;gBAC/B,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;gBAC3B,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC;aAC9B,CAAC,CAAC;YACH,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE;gBAC/C,QAAQ;gBACR,IAAI;gBACJ,MAAM;aACP,CAAC,CAAC;SACJ;QACD,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC;IAC1D,CAAC;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bosonprotocol/core-sdk",
-  "version": "1.12.0-alpha.1",
+  "version": "1.12.0-alpha.10",
   "description": "> TODO: description",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -33,15 +33,17 @@
     "access": "restricted"
   },
   "dependencies": {
-    "@bosonprotocol/common": "^1.9.0-alpha.1",
+    "@bosonprotocol/common": "^1.9.0-alpha.10",
     "@ethersproject/abi": "^5.5.0",
     "@ethersproject/address": "^5.5.0",
     "@ethersproject/bignumber": "^5.5.0",
+    "@ethersproject/bytes": "^5.6.1",
     "@ethersproject/constants": "^5.5.0",
     "@ethersproject/units": "^5.5.0",
     "cross-fetch": "^3.1.5",
     "graphql": "^16.5.0",
-    "graphql-request": "^4.3.0"
+    "graphql-request": "^4.3.0",
+    "mustache": "^4.2.0"
   },
   "devDependencies": {
     "eslint": "^8.10.0",
@@ -51,5 +53,5 @@
     "ts-jest": "^27.1.3",
     "typescript": "^4.5.5"
   },
-  "gitHead": "f8d19ecf3bab037d80c64b3ec4986baed39d36c7"
+  "gitHead": "97acb60ebdb531a063787e99cc44cf5a4461aa25"
 }

package/src/accounts/interface.ts

@@ -1,5 +1,6 @@
 import {
   SellerStruct,
+  AuthTokenStruct,
   abis,
   DisputeResolverStruct,
   utils
@@ -17,9 +18,11 @@ export const bosonAccountHandlerIface = new Interface(
 );
 
 export function encodeCreateAccount(seller: CreateSellerArgs) {
+  const sellerArgs = createSellerArgsToStruct(seller);
   return bosonAccountHandlerIface.encodeFunctionData("createSeller", [
-    createSellerArgsToStruct(seller),
-    seller.contractUri
+    sellerArgs.sellerStruct,
+    seller.contractUri,
+    sellerArgs.authTokenStruct
   ]);
 }
 
@@ -86,16 +89,24 @@ export function encodeUpdateDisputeResolver(
   ]);
 }
 
-export function createSellerArgsToStruct(
-  args: CreateSellerArgs
-): Partial<SellerStruct> {
+export function createSellerArgsToStruct(args: CreateSellerArgs): {
+  sellerStruct: Partial<SellerStruct>;
+  authTokenStruct: AuthTokenStruct;
+} {
+  const { authTokenId, authTokenType, ...sellerStructArgs } = args;
   return {
-    // NOTE: It doesn't matter which values we set for `id` and `active` here
-    // as they will be overridden by the contract. But to conform to the struct
-    // we need to set some arbitrary values.
-    id: "0",
-    active: true,
-    ...args
+    sellerStruct: {
+      // NOTE: It doesn't matter which values we set for `id` and `active` here
+      // as they will be overridden by the contract. But to conform to the struct
+      // we need to set some arbitrary values.
+      id: "0",
+      active: true,
+      ...sellerStructArgs
+    },
+    authTokenStruct: {
+      tokenId: authTokenId,
+      tokenType: authTokenType
+    }
   };
 }
 

package/src/accounts/queries.graphql

@@ -191,6 +191,9 @@ fragment BaseSellerFields on Seller {
   admin
   clerk
   treasury
+  authTokenId
+  authTokenType
+  voucherCloneAddress
   active
 }
 

package/src/core-sdk.ts

@@ -1,3 +1,4 @@
+import { ITokenInfo, TokenInfoManager } from "./utils/tokenInfoManager";
 import {
   Web3LibAdapter,
   TransactionResponse,
@@ -8,8 +9,10 @@ import {
 } from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { AddressZero } from "@ethersproject/constants";
+import { BytesLike } from "@ethersproject/bytes";
 
 import * as accounts from "./accounts";
+import * as disputes from "./disputes";
 import * as exchanges from "./exchanges";
 import * as offers from "./offers";
 import * as orchestration from "./orchestration";
@@ -28,6 +31,8 @@ export class CoreSDK {
 
   private _subgraphUrl: string;
   private _protocolDiamond: string;
+  private _chainId: number;
+  private _tokenInfoManager: TokenInfoManager;
 
   /**
    * Creates an instance of `CoreSDK`
@@ -39,12 +44,14 @@ export class CoreSDK {
     protocolDiamond: string;
     metadataStorage?: MetadataStorage;
     theGraphStorage?: MetadataStorage;
+    chainId?: number;
   }) {
     this._web3Lib = opts.web3Lib;
     this._subgraphUrl = opts.subgraphUrl;
     this._protocolDiamond = opts.protocolDiamond;
     this._metadataStorage = opts.metadataStorage;
     this._theGraphStorage = opts.theGraphStorage;
+    this._chainId = opts.chainId;
   }
 
   /**
@@ -80,7 +87,8 @@ export class CoreSDK {
       metadataStorage: args.metadataStorage,
       theGraphStorage: args.theGraphStorage,
       subgraphUrl: defaultConfig.subgraphUrl,
-      protocolDiamond: defaultConfig.contracts.protocolDiamond
+      protocolDiamond: defaultConfig.contracts.protocolDiamond,
+      chainId: args.chainId
     });
   }
 
@@ -641,22 +649,21 @@ export class CoreSDK {
    * @param exchangeToken - Address exchange token.
    * @returns Decimals, name and symbol.
    */
-  public async getExchangeTokenInfo(exchangeToken: string): Promise<{
-    name: string;
-    decimals: number;
-    symbol: string;
-  }> {
-    const args = {
-      web3Lib: this._web3Lib,
-      contractAddress: exchangeToken
-    };
-    const [decimals, name, symbol] = await Promise.all([
-      erc20.handler.getDecimals(args),
-      erc20.handler.getName(args),
-      erc20.handler.getSymbol(args)
-    ]);
+  public async getExchangeTokenInfo(
+    exchangeToken: string
+  ): Promise<ITokenInfo> {
+    if (this._chainId === undefined) {
+      this._chainId = await this._web3Lib.getChainId();
+    }
+
+    if (this._tokenInfoManager === undefined) {
+      this._tokenInfoManager = new TokenInfoManager(
+        this._chainId,
+        this._web3Lib
+      );
+    }
 
-    return { decimals, name, symbol };
+    return this._tokenInfoManager.getExchangeTokenInfo(exchangeToken);
   }
 
   /**
@@ -923,6 +930,167 @@ export class CoreSDK {
   /*                           Dispute related methods                          */
   /* -------------------------------------------------------------------------- */
 
+  public async getDisputeById(
+    disputeId: BigNumberish,
+    queryVars?: disputes.subgraph.SingleDisputeQueryVariables
+  ) {
+    return disputes.subgraph.getDisputeById(
+      this._subgraphUrl,
+      disputeId,
+      queryVars
+    );
+  }
+
+  public async getDisputes(
+    queryVars?: subgraph.GetDisputesQueryQueryVariables
+  ) {
+    return disputes.subgraph.getDisputes(this._subgraphUrl, queryVars);
+  }
+
+  public async raiseDispute(
+    exchangeId: BigNumberish,
+    complaint: string
+  ): Promise<TransactionResponse> {
+    return disputes.handler.raiseDispute({
+      exchangeId,
+      complaint,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async retractDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.retractDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async extendDisputeTimeout(
+    exchangeId: BigNumberish,
+    newDisputeTimeout: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.extendDisputeTimeout({
+      exchangeId,
+      newDisputeTimeout,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async expireDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.expireDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async expireDisputeBatch(
+    exchangeIds: BigNumberish[]
+  ): Promise<TransactionResponse> {
+    return disputes.handler.expireDisputeBatch({
+      exchangeIds,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async resolveDispute(args: {
+    exchangeId: BigNumberish;
+    buyerPercent: BigNumberish;
+    sigR: BytesLike;
+    sigS: BytesLike;
+    sigV: BigNumberish;
+  }): Promise<TransactionResponse> {
+    return disputes.handler.resolveDispute({
+      ...args,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async escalateDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.escalateDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async decideDispute(
+    exchangeId: BigNumberish,
+    buyerPercent: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.decideDispute({
+      exchangeId,
+      buyerPercent,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async refuseEscalatedDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.refuseEscalatedDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async expireEscalatedDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.expireEscalatedDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async signMutualAgreement(args: {
+    exchangeId: string;
+    buyerPercent: string;
+  }) {
+    // Set the message Type, needed for signature
+    const resolutionType = [
+      { name: "exchangeId", type: "uint256" },
+      { name: "buyerPercent", type: "uint256" }
+    ];
+
+    const customSignatureType = {
+      Resolution: resolutionType
+    };
+
+    const message = {
+      exchangeId: args.exchangeId,
+      buyerPercent: args.buyerPercent
+    };
+
+    if (this._chainId === undefined) {
+      this._chainId = await this._web3Lib.getChainId();
+    }
+
+    return metaTx.handler.prepareDataSignatureParameters({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      customTransactionType: customSignatureType,
+      primaryType: "Resolution",
+      message,
+      nonce: "" // not used in this case
+    });
+  }
+
   /* -------------------------------------------------------------------------- */
   /*                           Meta Tx related methods                          */
   /* -------------------------------------------------------------------------- */
@@ -983,4 +1151,22 @@ export class CoreSDK {
       ...args
     });
   }
+
+  public async renderContractualAgreementForOffer(
+    offerId: BigNumberish
+  ): Promise<string> {
+    const offerData = await offers.subgraph.getOfferById(
+      this._subgraphUrl,
+      offerId
+    );
+    return offers.renderContractualAgreementForOffer(offerData);
+  }
+
+  public async renderContractualAgreement(
+    template: string,
+    offerData: offers.CreateOfferArgs
+  ): Promise<string> {
+    const tokenInfo = await this.getExchangeTokenInfo(offerData.exchangeToken);
+    return offers.renderContractualAgreement(template, offerData, tokenInfo);
+  }
 }

package/src/disputes/handler.ts

@@ -0,0 +1,132 @@
+import { Web3LibAdapter, TransactionResponse } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { BytesLike } from "@ethersproject/bytes";
+import {
+  encodeRaiseDispute,
+  encodeDecideDispute,
+  encodeEscalateDispute,
+  encodeExpireDispute,
+  encodeExpireDisputeBatch,
+  encodeExpireEscalatedDispute,
+  encodeExtendDisputeTimeout,
+  encodeRefuseEscalatedDispute,
+  encodeResolveDispute,
+  encodeRetractDispute
+} from "./interface";
+
+export async function raiseDispute(args: {
+  exchangeId: BigNumberish;
+  complaint: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRaiseDispute(args)
+  });
+}
+
+export async function retractDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRetractDispute(args.exchangeId)
+  });
+}
+
+export async function extendDisputeTimeout(args: {
+  exchangeId: BigNumberish;
+  newDisputeTimeout: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeExtendDisputeTimeout(args)
+  });
+}
+
+export async function expireDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeExpireDispute(args.exchangeId)
+  });
+}
+
+export async function expireDisputeBatch(args: {
+  exchangeIds: BigNumberish[];
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeExpireDisputeBatch(args.exchangeIds)
+  });
+}
+
+export async function resolveDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercent: BigNumberish;
+  sigR: BytesLike;
+  sigS: BytesLike;
+  sigV: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeResolveDispute(args)
+  });
+}
+
+export async function escalateDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeEscalateDispute(args.exchangeId)
+  });
+}
+
+export async function decideDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercent: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeDecideDispute(args)
+  });
+}
+
+export async function refuseEscalatedDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRefuseEscalatedDispute(args.exchangeId)
+  });
+}
+
+export async function expireEscalatedDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeExpireEscalatedDispute(args.exchangeId)
+  });
+}

package/src/disputes/index.ts

@@ -0,0 +1,3 @@
+export * as iface from "./interface";
+export * as handler from "./handler";
+export * as subgraph from "./subgraph";