@consensolabs/claims-test v0.1.0

Safient Claims

JavaScript SDK to manage and interact with the safe claims on Safient protocol.

Installation

  git clone https://github.com/safient/safient-claims-js.git
  cd safient-claims-js
  npm install

Running Tests

Compile the TS code

  npx tsc

Run the chain on a separate terminal

  npm run chain

Run the tests

  npm run test

Getting started

  npm install safient-claims

Usage

// If not injected web3 provider, create a jsonRpcProvider
const { JsonRpcProvider } = require('@ethersproject/providers');
const provider = new JsonRpcProvider('http://localhost:8545');

// Get chainId from provider
(async () => {
  const providerNetwork = await provider.getNetwork();
  const chainId = providerNetwork.chainId;
})();

Initialization

import { SafientClaims } from 'safient-claims';

const sc = new SafientClaims(provider, chainId);

Arbitrator

sc.arbitrator.getArbitrationFee

SafientMain

sc.safientMain.createSafe
sc.safientMain.createClaim
sc.safientMain.submitEvidence
sc.safientMain.depositSafeFunds
sc.safientMain.recoverSafeFunds
sc.safientMain.setTotalClaimsAllowed
sc.safientMain.getTotalNumberOfSafes
sc.safientMain.getTotalNumberOfClaims
sc.safientMain.getAllSafes
sc.safientMain.getAllClaims
sc.safientMain.getSafeBySafeId
sc.safientMain.getClaimByClaimId
sc.safientMain.getClaimsOnSafeBySafeId
sc.safientMain.getClaimStatus
sc.safientMain.getTotalClaimsAllowed
sc.safientMain.getSafientMainContractBalance

API details

Arbitrator

Get Arbitration Fee

const getArbitrationFee = async () => {
  try {
    const fee = await sc.arbitrator.getArbitrationFee();
    console.log(fee);
  } catch (e) {
    console.log(e.message);
  }
};

SafientMain

Create Safe

const createSafe = async (inheritorAddress, metaevidenceURI, value) => {
  try {
    const tx = await sc.safientMain.createSafe(inheritorAddress, metaevidenceURI, value);
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Create Claim

const createClaim = async (safeId, evidenceURI) => {
  try {
    const tx = await sc.safientMain.createClaim(safeId, evidenceURI);
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Submit Evidence

const submitEvidence = async (disputeId, evidenceURI) => {
  try {
    const tx = await sc.safientMain.submitEvidence(disputeId, evidenceURI);
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Deposit Safe Funds

const depositSafeFunds = async (safeId, value) => {
  try {
    const tx = await sc.safientMain.depositSafeFunds(safeId, value);
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Recover Safe Funds

Only safe's current owner can execute this

const recoverSafeFunds = async (safeId) => {
  try {
    const tx = await sc.safientMain.recoverSafeFunds(safeId);
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Set Total Claims Allowed

Only SafientMain contract deployer can execute this

const setTotalClaimsAllowed = async (claimsAllowed) => {
  try {
    const tx = await sc.safientMain.setTotalClaimsAllowed(claimsAllowed);
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Get Total Number Of Safes

const getTotalNumberOfSafes = async () => {
  try {
    const numOfSafes = await sc.safientMain.getTotalNumberOfSafes();
    console.log(numOfSafes);
  } catch (e) {
    console.log(e.message);
  }
};

Get Total Number Of Claims

const getTotalNumberOfClaims = async () => {
  try {
    const numOfClaims = await sc.safientMain.getTotalNumberOfClaims();
    console.log(numOfClaims);
  } catch (e) {
    console.log(e.message);
  }
};

Get All Safes

const getAllSafes = async () => {
  try {
    const safes = await sc.safientMain.getAllSafes();
    console.log(safes);
  } catch (e) {
    console.log(e.message);
  }
};

Type Safe

Get All Claims

const getAllClaims = async () => {
  try {
    const claims = await sc.safientMain.getAllClaims();
    console.log(claims);
  } catch (e) {
    console.log(e.message);
  }
};

Type Claim

Get Safe By Safe Id

const getSafeBySafeId = async (safeId) => {
  try {
    const safe = await sc.safientMain.getSafeBySafeId(safeId);
    console.log(safe);
  } catch (e) {
    console.log(e.message);
  }
};

Get Claim By Claim Id

const getClaimByClaimId = async (claimId) => {
  try {
    const claim = await sc.safientMain.getClaimByClaimId(claimId);
    console.log(claim);
  } catch (e) {
    console.log(e.message);
  }
};

Get All Claims On A Safe By Safe Id

const getClaimsOnSafeBySafeId = async (safeId) => {
  try {
    const claims = await sc.safientMain.getClaimsOnSafeBySafeId(safeId);
    console.log(claims);
  } catch (e) {
    console.log(e.message);
  }
};

Get Claim Status

const getClaimStatus = async (claimId) => {
  try {
    const claimStatus = await sc.safientMain.getClaimStatus(safeId);
    console.log(claimStatus);
  } catch (e) {
    console.log(e.message);
  }
};

Get Total No. Of Claims Allowed On A Safe

const getTotalClaimsAllowed = async () => {
  try {
    const claimsAllowed = await sc.safientMain.getTotalClaimsAllowed();
    console.log(claimsAllowed);
  } catch (e) {
    console.log(e.message);
  }
};

Get SafientMain Contract Total Balance

const getSafientMainContractBalance = async () => {
  try {
    const balance = await sc.safientMain.getSafientMainContractBalance();
    console.log(balance);
  } catch (e) {
    console.log(e.message);
  }
};