@safient/claims v0.1.7

Safient Claims SDK

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

Installation

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

Running Tests

Create an .env file in the root dtrectory with INFURA_API_KEY

Terminal 1

  npm run chain

Terminal 2

  npm run deploy
  npm run tests

Getting started

  npm i @safient/claims

Usage

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

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

Initialization

import { SafientClaims } from '@safient/claims';

const sc = new SafientClaims(signer, chainId);

Arbitrator

sc.arbitrator.getArbitrationFee

SafientMain

sc.safientMain.createSafe
sc.safientMain.syncSafe
sc.safientMain.createClaim
sc.safientMain.submitEvidence
sc.safientMain.depositFunds
sc.safientMain.withdrawFunds
sc.safientMain.getTotalNumberOfSafes
sc.safientMain.getTotalNumberOfClaims
sc.safientMain.getSafeBySafeId
sc.safientMain.getClaimByClaimId
sc.safientMain.getClaimStatus
sc.safientMain.getContractBalance
sc.safientMain.guardianProof

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 (beneficiaryAddress, safeIdOnThreadDB, claimType, signalingPeriod, metaevidenceURI, value) => {
  try {
    const tx = await sc.safientMain.createSafe(
      beneficiaryAddress,
      safeIdOnThreadDB,
      claimType,
      signalingPeriod,
      metaevidenceURI,
      value
    );
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Sync Safe

const syncSafe = async (creatorAddress, safeIdOnThreadDB, claimType, signalingPeriod, metaevidenceURI, value) => {
  try {
    const tx = await sc.safientMain.syncSafe(
      creatorAddress,
      safeIdOnThreadDB,
      claimType,
      signalingPeriod,
      metaevidenceURI,
      value
    );
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Create Claim

const createClaim = async (safeIdOnThreadDB, evidenceURI) => {
  try {
    const tx = await sc.safientMain.createClaim(safeIdOnThreadDB, 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 depositFunds = async (safeIdOnThreadDB, value) => {
  try {
    const tx = await sc.safientMain.depositFunds(safeIdOnThreadDB, value);
    console.log(tx);
  } catch (e) {
    console.log(e.message);
  }
};

Retrieve Safe Funds

Only safe's current owner can execute this

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

Send signal

Only safe's current owner can execute this

const sendSignal = async (safeIdOnThreadDB) => {
  try {
    const tx = await sc.safientMain.sendSignal(safeIdOnThreadDB);
    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 Safe By Safe Id

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

Type Safe

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);
  }
};

Type Claim

Get Claim Status

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

Get SafientMain Contract Total Balance

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

Guardian proof

const guardianProof = async (message, signature, guardianProof, secrets, safeIdOnThreadDB) => {
  try {
    const result = await sc.safientMain.guardianProof(message, signature, guardianProof, secrets, safeIdOnThreadDB);
    console.log(result);
  } catch (e) {
    console.log(e.message);
  }
};

Type RecoveryProof