web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/locks.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var memo = require('../../rpc-core/util/memo.js');
+var _undefined = require('../../util/is/undefined.js');
+var consts = require('../../util/bn/consts.js');
+
+const LOCKUPS = [0, 1, 2, 4, 8, 16, 32];
+function parseEnd(api, vote, _ref) {
+  let {
+    approved,
+    end
+  } = _ref;
+  return [end, approved.isTrue && vote.isAye || approved.isFalse && vote.isNay ? end.add((api.consts.democracy.voteLockingPeriod || api.consts.democracy.enactmentPeriod).muln(LOCKUPS[vote.conviction.index])) : consts.BN_ZERO];
+}
+function parseLock(api, _ref2, referendum) {
+  let [referendumId, accountVote] = _ref2;
+  const {
+    balance,
+    vote
+  } = accountVote.asStandard;
+  const [referendumEnd, unlockAt] = referendum.isFinished ? parseEnd(api, vote, referendum.asFinished) : [consts.BN_ZERO, consts.BN_ZERO];
+  return {
+    balance,
+    isDelegated: false,
+    isFinished: referendum.isFinished,
+    referendumEnd,
+    referendumId,
+    unlockAt,
+    vote
+  };
+}
+function delegateLocks(api, _ref3) {
+  let {
+    balance,
+    conviction,
+    target
+  } = _ref3;
+  return api.derive.democracy.locks(target).pipe(map.map(available => available.map(_ref4 => {
+    let {
+      isFinished,
+      referendumEnd,
+      referendumId,
+      unlockAt,
+      vote
+    } = _ref4;
+    return {
+      balance,
+      isDelegated: true,
+      isFinished,
+      referendumEnd,
+      referendumId,
+      unlockAt: unlockAt.isZero() ? unlockAt : referendumEnd.add((api.consts.democracy.voteLockingPeriod || api.consts.democracy.enactmentPeriod).muln(LOCKUPS[conviction.index])),
+      vote: api.registry.createType('Vote', {
+        aye: vote.isAye,
+        conviction
+      })
+    };
+  })));
+}
+function directLocks(api, _ref5) {
+  let {
+    votes
+  } = _ref5;
+  if (!votes.length) {
+    return of.of([]);
+  }
+  return api.query.democracy.referendumInfoOf.multi(votes.map(_ref6 => {
+    let [referendumId] = _ref6;
+    return referendumId;
+  })).pipe(map.map(referendums => votes.map((vote, index) => [vote, referendums[index].unwrapOr(null)]).filter(item => !!item[1] && _undefined.isUndefined(item[1].end) && item[0][1].isStandard).map(_ref7 => {
+    let [directVote, referendum] = _ref7;
+    return parseLock(api, directVote, referendum);
+  })));
+}
+function locks(instanceId, api) {
+  return memo.memo(instanceId, accountId => api.query.democracy.votingOf ? api.query.democracy.votingOf(accountId).pipe(switchMap.switchMap(voting => voting.isDirect ? directLocks(api, voting.asDirect) : voting.isDelegating ? delegateLocks(api, voting.asDelegating) : of.of([]))) : of.of([]));
+}
+
+exports.locks = locks;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/nextExternal.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var util = require('./util.js');
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var memo = require('../../rpc-core/util/memo.js');
+
+function withImage(api, nextOpt) {
+  if (nextOpt.isNone) {
+    return of.of(null);
+  }
+  const [hash, threshold] = nextOpt.unwrap();
+  return api.derive.democracy.preimage(hash).pipe(map.map(image => ({
+    image,
+    imageHash: util.getImageHashBounded(hash),
+    threshold
+  })));
+}
+function nextExternal(instanceId, api) {
+  return memo.memo(instanceId, () => api.query.democracy?.nextExternal ? api.query.democracy.nextExternal().pipe(switchMap.switchMap(nextOpt => withImage(api, nextOpt))) : of.of(null));
+}
+
+exports.nextExternal = nextExternal;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/preimages.js

@@ -0,0 +1,103 @@
+'use strict';
+
+var util = require('./util.js');
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var first = require('../util/first.js');
+var memo = require('../../rpc-core/util/memo.js');
+var _function = require('../../util/is/function.js');
+var consts = require('../../util/bn/consts.js');
+
+function getUnrequestedTicket(status) {
+  return status.ticket || status.deposit;
+}
+function getRequestedTicket(status) {
+  return (status.maybeTicket || status.deposit).unwrapOrDefault();
+}
+function isDemocracyPreimage(api, imageOpt) {
+  return !!imageOpt && !api.query.democracy['dispatchQueue'];
+}
+function constructProposal(api, _ref) {
+  let [bytes, proposer, balance, at] = _ref;
+  let proposal;
+  try {
+    proposal = api.registry.createType('Call', bytes.toU8a(true));
+  } catch (error) {
+    console.error(error);
+  }
+  return {
+    at,
+    balance,
+    proposal,
+    proposer
+  };
+}
+function parseDemocracy(api, imageOpt) {
+  if (imageOpt.isNone) {
+    return;
+  }
+  if (isDemocracyPreimage(api, imageOpt)) {
+    const status = imageOpt.unwrap();
+    if (status.isMissing) {
+      return;
+    }
+    const {
+      data,
+      deposit,
+      provider,
+      since
+    } = status.asAvailable;
+    return constructProposal(api, [data, provider, deposit, since]);
+  }
+  return constructProposal(api, imageOpt.unwrap());
+}
+function parseImage(api, _ref2) {
+  let [proposalHash, status, bytes] = _ref2;
+  if (!status) {
+    return undefined;
+  }
+  const [proposer, balance] = status.isUnrequested ? getUnrequestedTicket(status.asUnrequested) : getRequestedTicket(status.asRequested);
+  let proposal;
+  if (bytes) {
+    try {
+      proposal = api.registry.createType('Call', bytes.toU8a(true));
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return {
+    at: consts.BN_ZERO,
+    balance,
+    proposal,
+    proposalHash,
+    proposer
+  };
+}
+function getDemocracyImages(api, bounded) {
+  const hashes = bounded.map(b => util.getImageHashBounded(b));
+  return api.query.democracy['preimages'].multi(hashes).pipe(map.map(images => images.map(imageOpt => parseDemocracy(api, imageOpt))));
+}
+function getImages(api, bounded) {
+  const hashes = bounded.map(b => util.getImageHashBounded(b));
+  const bytesType = api.registry.lookup.getTypeDef(api.query.preimage.preimageFor.creator.meta.type.asMap.key).type;
+  return api.query.preimage.statusFor.multi(hashes).pipe(switchMap.switchMap(optStatus => {
+    const statuses = optStatus.map(o => o.unwrapOr(null));
+    const keys = statuses.map((s, i) => s ? bytesType === 'H256'
+    // first generation
+    ? hashes[i]
+    // current generation (H256,u32)
+    : s.isRequested ? [hashes[i], s.asRequested.len.unwrapOr(0)] : [hashes[i], s.asUnrequested.len] : null).filter(p => !!p);
+    return api.query.preimage.preimageFor.multi(keys).pipe(map.map(optBytes => {
+      let ptr = -1;
+      return statuses.map((s, i) => s ? [hashes[i], s, optBytes[++ptr].unwrapOr(null)] : [hashes[i], null, null]).map(v => parseImage(api, v));
+    }));
+  }));
+}
+function preimages(instanceId, api) {
+  return memo.memo(instanceId, hashes => hashes.length ? _function.isFunction(api.query.democracy['preimages']) ? getDemocracyImages(api, hashes) : _function.isFunction(api.query.preimage.preimageFor) ? getImages(api, hashes) : of.of([]) : of.of([]));
+}
+const preimage = /*#__PURE__*/first.firstMemo((api, hash) => api.derive.democracy.preimages([hash]));
+
+exports.preimage = preimage;
+exports.preimages = preimages;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/proposals.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var util = require('./util.js');
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var combineLatest = require('../../../rxjs/dist/esm5/internal/observable/combineLatest.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var memo = require('../../rpc-core/util/memo.js');
+var _function = require('../../util/is/function.js');
+var spread = require('../../util/object/spread.js');
+
+function isNewDepositors(depositors) {
+  // Detect balance...
+  return _function.isFunction(depositors[1].mul);
+}
+function parse(_ref) {
+  let [proposals, images, optDepositors] = _ref;
+  return proposals.filter((_ref2, index) => {
+    let [,, proposer] = _ref2;
+    return !!optDepositors[index]?.isSome && !proposer.isEmpty;
+  }).map((_ref3, proposalIndex) => {
+    let [index, hash, proposer] = _ref3;
+    const depositors = optDepositors[proposalIndex].unwrap();
+    return spread.objectSpread({
+      image: images[proposalIndex],
+      imageHash: util.getImageHashBounded(hash),
+      index,
+      proposer
+    }, isNewDepositors(depositors) ? {
+      balance: depositors[1],
+      seconds: depositors[0]
+    } : {
+      balance: depositors[0],
+      seconds: depositors[1]
+    });
+  });
+}
+function proposals(instanceId, api) {
+  return memo.memo(instanceId, () => _function.isFunction(api.query.democracy?.publicProps) ? api.query.democracy.publicProps().pipe(switchMap.switchMap(proposals => proposals.length ? combineLatest.combineLatest([of.of(proposals), api.derive.democracy.preimages(proposals.map(_ref4 => {
+    let [, hash] = _ref4;
+    return hash;
+  })), api.query.democracy.depositOf.multi(proposals.map(_ref5 => {
+    let [index] = _ref5;
+    return index;
+  }))]) : of.of([[], [], []])), map.map(parse)) : of.of([]));
+}
+
+exports.proposals = proposals;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/referendumIds.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var memo = require('../../rpc-core/util/memo.js');
+
+function referendumIds(instanceId, api) {
+  return memo.memo(instanceId, () => api.query.democracy?.lowestUnbaked ? api.queryMulti([api.query.democracy.lowestUnbaked, api.query.democracy.referendumCount]).pipe(map.map(_ref => {
+    let [first, total] = _ref;
+    return total.gt(first)
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    ? [...Array(total.sub(first).toNumber())].map((_, i) => first.addn(i)) : [];
+  })) : of.of([]));
+}
+
+exports.referendumIds = referendumIds;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/referendums.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var combineLatest = require('../../../rxjs/dist/esm5/internal/observable/combineLatest.js');
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var memo = require('../../rpc-core/util/memo.js');
+var spread = require('../../util/object/spread.js');
+
+function referendums(instanceId, api) {
+  return memo.memo(instanceId, () => api.derive.democracy.referendumsActive().pipe(switchMap.switchMap(referendums => referendums.length ? combineLatest.combineLatest([of.of(referendums), api.derive.democracy._referendumsVotes(referendums)]) : of.of([[], []])), map.map(_ref => {
+    let [referendums, votes] = _ref;
+    return referendums.map((referendum, index) => spread.objectSpread({}, referendum, votes[index]));
+  })));
+}
+
+exports.referendums = referendums;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/referendumsActive.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var memo = require('../../rpc-core/util/memo.js');
+
+function referendumsActive(instanceId, api) {
+  return memo.memo(instanceId, () => api.derive.democracy.referendumIds().pipe(switchMap.switchMap(ids => ids.length ? api.derive.democracy.referendumsInfo(ids) : of.of([]))));
+}
+
+exports.referendumsActive = referendumsActive;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/referendumsFinished.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var memo = require('../../rpc-core/util/memo.js');
+
+function referendumsFinished(instanceId, api) {
+  return memo.memo(instanceId, () => api.derive.democracy.referendumIds().pipe(switchMap.switchMap(ids => api.query.democracy.referendumInfoOf.multi(ids)), map.map(infos => infos.map(o => o.unwrapOr(null)).filter(info => !!info && info.isFinished).map(info => info.asFinished))));
+}
+
+exports.referendumsFinished = referendumsFinished;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/referendumsInfo.js

@@ -0,0 +1,130 @@
+'use strict';
+
+var util = require('./util.js');
+var combineLatest = require('../../../rxjs/dist/esm5/internal/observable/combineLatest.js');
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var of = require('../../../rxjs/dist/esm5/internal/observable/of.js');
+var switchMap = require('../../../rxjs/dist/esm5/internal/operators/switchMap.js');
+var memo = require('../../rpc-core/util/memo.js');
+var _function = require('../../util/is/function.js');
+var spread = require('../../util/object/spread.js');
+
+function votesPrev(api, referendumId) {
+  return api.query.democracy['votersFor'](referendumId).pipe(switchMap.switchMap(votersFor => combineLatest.combineLatest([of.of(votersFor), votersFor.length ? api.query.democracy['voteOf'].multi(votersFor.map(accountId => [referendumId, accountId])) : of.of([]), api.derive.balances.votingBalances(votersFor)])), map.map(_ref => {
+    let [votersFor, votes, balances] = _ref;
+    return votersFor.map((accountId, index) => ({
+      accountId,
+      balance: balances[index].votingBalance || api.registry.createType('Balance'),
+      isDelegating: false,
+      vote: votes[index] || api.registry.createType('Vote')
+    }));
+  }));
+}
+function extractVotes(mapped, referendumId) {
+  return mapped.filter(_ref2 => {
+    let [, voting] = _ref2;
+    return voting.isDirect;
+  }).map(_ref3 => {
+    let [accountId, voting] = _ref3;
+    return [accountId, voting.asDirect.votes.filter(_ref4 => {
+      let [idx] = _ref4;
+      return idx.eq(referendumId);
+    })];
+  }).filter(_ref5 => {
+    let [, directVotes] = _ref5;
+    return !!directVotes.length;
+  }).reduce((result, _ref6) => {
+    let [accountId, votes] = _ref6;
+    return (
+      // FIXME We are ignoring split votes
+      votes.reduce((result, _ref7) => {
+        let [, vote] = _ref7;
+        if (vote.isStandard) {
+          result.push(spread.objectSpread({
+            accountId,
+            isDelegating: false
+          }, vote.asStandard));
+        }
+        return result;
+      }, result)
+    );
+  }, []);
+}
+function votesCurr(api, referendumId) {
+  return api.query.democracy.votingOf.entries().pipe(map.map(allVoting => {
+    const mapped = allVoting.map(_ref8 => {
+      let [{
+        args: [accountId]
+      }, voting] = _ref8;
+      return [accountId, voting];
+    });
+    const votes = extractVotes(mapped, referendumId);
+    const delegations = mapped.filter(_ref9 => {
+      let [, voting] = _ref9;
+      return voting.isDelegating;
+    }).map(_ref0 => {
+      let [accountId, voting] = _ref0;
+      return [accountId, voting.asDelegating];
+    });
+    // add delegations
+    delegations.forEach(_ref1 => {
+      let [accountId, {
+        balance,
+        conviction,
+        target
+      }] = _ref1;
+      // Are we delegating to a delegator
+      const toDelegator = delegations.find(_ref10 => {
+        let [accountId] = _ref10;
+        return accountId.eq(target);
+      });
+      const to = votes.find(_ref11 => {
+        let {
+          accountId
+        } = _ref11;
+        return accountId.eq(toDelegator ? toDelegator[0] : target);
+      });
+      // this delegation has a target
+      if (to) {
+        votes.push({
+          accountId,
+          balance,
+          isDelegating: true,
+          vote: api.registry.createType('Vote', {
+            aye: to.vote.isAye,
+            conviction
+          })
+        });
+      }
+    });
+    return votes;
+  }));
+}
+function _referendumVotes(instanceId, api) {
+  return memo.memo(instanceId, referendum => combineLatest.combineLatest([api.derive.democracy.sqrtElectorate(), _function.isFunction(api.query.democracy.votingOf) ? votesCurr(api, referendum.index) : votesPrev(api, referendum.index)]).pipe(map.map(_ref12 => {
+    let [sqrtElectorate, votes] = _ref12;
+    return util.calcVotes(sqrtElectorate, referendum, votes);
+  })));
+}
+function _referendumsVotes(instanceId, api) {
+  return memo.memo(instanceId, referendums => referendums.length ? combineLatest.combineLatest(referendums.map(referendum => api.derive.democracy._referendumVotes(referendum))) : of.of([]));
+}
+function _referendumInfo(instanceId, api) {
+  return memo.memo(instanceId, (index, info) => {
+    const status = util.getStatus(info);
+    return status ? api.derive.democracy.preimage(status.proposal || status.proposalHash).pipe(map.map(image => ({
+      image,
+      imageHash: util.getImageHash(status),
+      index: api.registry.createType('ReferendumIndex', index),
+      status
+    }))) : of.of(null);
+  });
+}
+function referendumsInfo(instanceId, api) {
+  return memo.memo(instanceId, ids => ids.length ? api.query.democracy.referendumInfoOf.multi(ids).pipe(switchMap.switchMap(infos => combineLatest.combineLatest(ids.map((id, index) => api.derive.democracy._referendumInfo(id, infos[index])))), map.map(infos => infos.filter(r => !!r))) : of.of([]));
+}
+
+exports._referendumInfo = _referendumInfo;
+exports._referendumVotes = _referendumVotes;
+exports._referendumsVotes = _referendumsVotes;
+exports.referendumsInfo = referendumsInfo;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/sqrtElectorate.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var map = require('../../../rxjs/dist/esm5/internal/operators/map.js');
+var memo = require('../../rpc-core/util/memo.js');
+var sqrt = require('../../util/bn/sqrt.js');
+
+function sqrtElectorate(instanceId, api) {
+  return memo.memo(instanceId, () => api.query.balances.totalIssuance().pipe(map.map(sqrt.bnSqrt)));
+}
+
+exports.sqrtElectorate = sqrtElectorate;

package/dist/cjs/node_modules/@polkadot/api-derive/democracy/util.js

@@ -0,0 +1,134 @@
+'use strict';
+
+var toHex = require('../../util/string/toHex.js');
+var sqrt = require('../../util/bn/sqrt.js');
+var spread = require('../../util/object/spread.js');
+var toHex$1 = require('../../util/u8a/toHex.js');
+var string = require('../../util/is/string.js');
+var hex = require('../../util/is/hex.js');
+var u8a = require('../../util/is/u8a.js');
+var bn = require('../../../../_virtual/bn.js');
+
+function isOldInfo(info) {
+  return !!info.proposalHash;
+}
+function isCurrentStatus(status) {
+  return !!status.tally;
+}
+function compareRationals(n1, d1, n2, d2) {
+  while (true) {
+    const q1 = n1.div(d1);
+    const q2 = n2.div(d2);
+    if (q1.lt(q2)) {
+      return true;
+    } else if (q2.lt(q1)) {
+      return false;
+    }
+    const r1 = n1.mod(d1);
+    const r2 = n2.mod(d2);
+    if (r2.isZero()) {
+      return false;
+    } else if (r1.isZero()) {
+      return true;
+    }
+    n1 = d2;
+    n2 = d1;
+    d1 = r2;
+    d2 = r1;
+  }
+}
+function calcPassingOther(threshold, sqrtElectorate, _ref) {
+  let {
+    votedAye,
+    votedNay,
+    votedTotal
+  } = _ref;
+  const sqrtVoters = sqrt.bnSqrt(votedTotal);
+  return sqrtVoters.isZero() ? false : threshold.isSuperMajorityApprove ? compareRationals(votedNay, sqrtVoters, votedAye, sqrtElectorate) : compareRationals(votedNay, sqrtElectorate, votedAye, sqrtVoters);
+}
+function calcPassing(threshold, sqrtElectorate, state) {
+  return threshold.isSimpleMajority ? state.votedAye.gt(state.votedNay) : calcPassingOther(threshold, sqrtElectorate, state);
+}
+function calcVotesPrev(votesFor) {
+  return votesFor.reduce((state, derived) => {
+    const {
+      balance,
+      vote
+    } = derived;
+    const isDefault = vote.conviction.index === 0;
+    const counted = balance.muln(isDefault ? 1 : vote.conviction.index).divn(isDefault ? 10 : 1);
+    if (vote.isAye) {
+      state.allAye.push(derived);
+      state.voteCountAye++;
+      state.votedAye.iadd(counted);
+    } else {
+      state.allNay.push(derived);
+      state.voteCountNay++;
+      state.votedNay.iadd(counted);
+    }
+    state.voteCount++;
+    state.votedTotal.iadd(counted);
+    return state;
+  }, {
+    allAye: [],
+    allNay: [],
+    voteCount: 0,
+    voteCountAye: 0,
+    voteCountNay: 0,
+    votedAye: new bn.default(0),
+    votedNay: new bn.default(0),
+    votedTotal: new bn.default(0)
+  });
+}
+function calcVotesCurrent(tally, votes) {
+  const allAye = [];
+  const allNay = [];
+  votes.forEach(derived => {
+    if (derived.vote.isAye) {
+      allAye.push(derived);
+    } else {
+      allNay.push(derived);
+    }
+  });
+  return {
+    allAye,
+    allNay,
+    voteCount: allAye.length + allNay.length,
+    voteCountAye: allAye.length,
+    voteCountNay: allNay.length,
+    votedAye: tally.ayes,
+    votedNay: tally.nays,
+    votedTotal: tally.turnout
+  };
+}
+function calcVotes(sqrtElectorate, referendum, votes) {
+  const state = isCurrentStatus(referendum.status) ? calcVotesCurrent(referendum.status.tally, votes) : calcVotesPrev(votes);
+  return spread.objectSpread({}, state, {
+    isPassing: calcPassing(referendum.status.threshold, sqrtElectorate, state),
+    votes
+  });
+}
+function getStatus(info) {
+  if (info.isNone) {
+    return null;
+  }
+  const unwrapped = info.unwrap();
+  return isOldInfo(unwrapped) ? unwrapped : unwrapped.isOngoing ? unwrapped.asOngoing
+  // done, we don't include it here... only currently active
+  : null;
+}
+function getImageHashBounded(hash) {
+  return hash.isLegacy ? hash.asLegacy.hash_.toHex() : hash.isLookup ? hash.asLookup.hash_.toHex()
+  // for inline, use the actual Bytes hash
+  : hash.isInline ? hash.asInline.hash.toHex() : string.isString(hash) ? hex.isHex(hash) ? hash : toHex.stringToHex(hash) : u8a.isU8a(hash) ? toHex$1.u8aToHex(hash) : hash.toHex();
+}
+function getImageHash(status) {
+  return getImageHashBounded(status.proposal || status.proposalHash);
+}
+
+exports.calcPassing = calcPassing;
+exports.calcVotes = calcVotes;
+exports.compareRationals = compareRationals;
+exports.getImageHash = getImageHash;
+exports.getImageHashBounded = getImageHashBounded;
+exports.getStatus = getStatus;

package/dist/cjs/node_modules/@polkadot/api-derive/derive.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var index$j = require('./accounts/index.js');
+var index$i = require('./alliance/index.js');
+var index$h = require('./bagsList/index.js');
+var index$g = require('./balances/index.js');
+var index$f = require('./bounties/index.js');
+var index$e = require('./chain/index.js');
+var index$d = require('./contracts/index.js');
+var index$c = require('./council/index.js');
+var index$b = require('./crowdloan/index.js');
+var index$a = require('./democracy/index.js');
+var index$9 = require('./elections/index.js');
+var index$8 = require('./imOnline/index.js');
+var index$7 = require('./membership/index.js');
+var index$6 = require('./parachains/index.js');
+var index$5 = require('./session/index.js');
+var index$4 = require('./society/index.js');
+var index$3 = require('./staking/index.js');
+var index$2 = require('./technicalCommittee/index.js');
+var index$1 = require('./treasury/index.js');
+var index = require('./tx/index.js');
+
+const derive = {
+  accounts: index$j,
+  alliance: index$i,
+  bagsList: index$h,
+  balances: index$g,
+  bounties: index$f,
+  chain: index$e,
+  contracts: index$d,
+  council: index$c,
+  crowdloan: index$b,
+  democracy: index$a,
+  elections: index$9,
+  imOnline: index$8,
+  membership: index$7,
+  parachains: index$6,
+  session: index$5,
+  society: index$4,
+  staking: index$3,
+  technicalCommittee: index$2,
+  treasury: index$1,
+  tx: index
+};
+
+exports.derive = derive;

package/dist/cjs/node_modules/@polkadot/api-derive/elections/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var info = require('./info.js');
+
+
+
+exports.info = info.info;