utils#normalizeBalance TypeScript Examples

Preview = ({ descriptionText, schemeToUse }) => {
  const {
    context: { daoStore, configStore },
  } = useContext();
  const networkTokens = configStore.getTokensOfNetwork();
  const networkContracts = configStore.getNetworkContracts();
  const { assetLimits: transferLimits } = daoStore.getSchemeRecommendedCalls(
    schemeToUse.address
  );
  const networkAssetSymbol =
    NETWORK_ASSET_SYMBOL[configStore.getActiveChainName()];
  return (
    <>
      <MDEditor.Markdown
        source={descriptionText}
        style={{
          backgroundColor: 'white',
          borderRadius: '5px',
          border: '1px solid gray',
          padding: '20px 10px',
        }}
        linkTarget="_blank"
        skipHtml
        escapeHtml
      />
      {schemeToUse.type === 'ContributionReward' ||
      schemeToUse.type === 'GenericMulticall' ||
      schemeToUse.type === 'SchemeRegistrar' ||
      (isWalletScheme(schemeToUse) &&
        schemeToUse.controllerAddress === networkContracts.controller) ? (
        <h2>
          Calls executed from the avatar <Question question="9" />
        </h2>
      ) : (
        <h2>
          Calls executed from the scheme <Question question="9" />
        </h2>
      )}
      {Object.keys(transferLimits).map(assetAddress => {
        if (assetAddress === ZERO_ADDRESS)
          return (
            <h3>
              Transfer limit of{' '}
              {normalizeBalance(transferLimits[assetAddress]).toString()}{' '}
              {networkAssetSymbol}
            </h3>
          );
        else {
          const token = networkTokens.find(
            networkToken => networkToken.address === assetAddress
          );
          if (token)
            return (
              <h3>
                Transfer limit of{' '}
                {normalizeBalance(
                  transferLimits[assetAddress],
                  token.decimals
                ).toString()}{' '}
                {token.symbol}
              </h3>
            );
          else
            return (
              <h3>
                Transfer limit {transferLimits[assetAddress].toString()} of
                asset {assetAddress}
              </h3>
            );
        }
      })}
    </>
  );
}

RecommendedCalls = ({
  to,
  from,
  recommendedCallUsed,
  callParameters,
  encodedFunctionName,
  data,
  showMore,
}: RecomendedCallsProps) => {
  const {
    context: { daoStore },
  } = useContext();

  const proposalId = useLocation().pathname.split('/')[3];
  const proposal = daoStore.getProposal(proposalId);

  const normalizeValue = (value: any, param: CallParameterDefinition) => {
    if (param.decimals) {
      return normalizeBalance(value, param.decimals).toString();
    }

    return value;
  };

  const getComponentToRender = (param: CallParameterDefinition, value: any) => {
    if (param.isRep) {
      return (
        <RepDisplay
          rep={bnum(value)}
          atBlock={proposal.creationEvent.blockNumber}
          timestamp={proposal.creationEvent.timestamp}
        />
      );
    } else {
      return normalizeValue(value, param);
    }
  };

  let decodedCallDetail: React.ReactNodeArray = [
    recommendedCallUsed.decodeText,
  ];
  if (
    recommendedCallUsed.decodeText &&
    recommendedCallUsed.decodeText.length > 0
  ) {
    recommendedCallUsed.params.forEach((param, paramIndex) => {
      const component = getComponentToRender(param, callParameters[paramIndex]);

      decodedCallDetail = reactStringReplace(
        reactStringReplace(
          decodedCallDetail,
          `[PARAM_${paramIndex}]`,
          () => component
        ),
        'FROM',
        () => proposal.scheme
      );
    });
  }

  if (showMore) {
    return (
      <div>
        <p>
          <strong>From: </strong>{' '}
          <small>
            <BlockchainLink text={from} toCopy={false} />
          </small>
        </p>
        <p>
          <strong>To: </strong>{' '}
          <small>
            <BlockchainLink text={to} toCopy={false} />
          </small>
        </p>
        <p>
          <strong>Descriptions: </strong>{' '}
          <small>{recommendedCallUsed.toName}</small>
        </p>
        <p>
          <strong>Function: </strong>
          <small>{recommendedCallUsed.functionName}</small>
        </p>
        <p>
          <strong>Function Signature: </strong>{' '}
          <small>{encodedFunctionName}</small>
        </p>
        <strong>Params: </strong>
        {Object.keys(callParameters).map((paramIndex, i) => {
          return (
            <p key={i}>
              <small>{callParameters[paramIndex]} </small>
            </p>
          );
        })}
        <strong>data: </strong>
        <small>{data} </small>
      </div>
    );
  }

  return (
    <div>
      <small>{decodedCallDetail}</small>
    </div>
  );
}

useSubmitProposal = (
  stableAmount: BigNumber,
  dxdAmount: BigNumber,
  repReward: BigNumber,
  dxdPrice: number,
  startDate: moment.Moment,
  setConfirm: any,
  selectedLevel: any
): UsePaymentAmountsReturns => {
  const {
    context: {
      ipfsService,
      pinataService,
      providerStore,
      configStore,
      daoStore,
      daoService,
    },
  } = useContext();

  const { library, account } = providerStore.getActiveWeb3React();

  const contracts = configStore.getNetworkContracts();
  const tokens = configStore.getTokensOfNetwork();

  const [loading, setLoading] = useState(null);
  const [proposalCreated, setProposalCreated] = useState(false);
  const [errorMessage, setErrorMessage] = useState('');

  const proposalType = configStore
    .getProposalTypes()
    .find(type => type.id === 'contributor');

  const scheme = daoStore
    .getAllSchemes()
    .find(scheme => scheme.address === proposalType.scheme);

  const submitProposal = async () => {
    try {
      setLoading(true);

      const hash = await ipfsService.uploadProposalMetadata(
        localStorage.getItem('dxvote-newProposal-title'),
        localStorage.getItem('dxvote-newProposal-description') +
          `${
            '\n$' + normalizeBalance(stableAmount).toString()
          } \n ${normalizeBalance(
            dxdAmount
          ).toString()} DXD vested for 3 years and 1 year cliff @ $${dxdPrice}/DXD
          \n ${normalizeBalance(repReward).toString()} REP \n `,
        ['Contributor Proposal', `Level ${selectedLevel.id}`],
        pinataService
      );

      // Encode rep mint call
      const repCallData = encodeRepMint(
        library,
        repReward.toString(),
        account,
        contracts.avatar
      );

      // Encode WXDAI transfer
      const wxdaiTransferCallData = encodeErc20Transfer(
        library,
        account,
        stableAmount.toString()
      );

      // Encode DXD approval
      const dxdApprovalCallData = encodeErc20Approval(
        library,
        contracts.utils.dxdVestingFactory,
        dxdAmount.toString()
      );

      // Encode vesting contract call
      const vestingCallData = encodeDxdVestingCreate(
        library,
        account,
        dxdAmount.toString(),
        startDate
      );

      const proposalData = {
        to: [
          contracts.controller,
          // Needs new stables coin value in config for other networks
          tokens.find(token => token.symbol === 'WXDAI').address,
          tokens.find(token => token.symbol === 'DXD').address,
          contracts.utils.dxdVestingFactory,
        ],
        data: [
          repCallData,
          wxdaiTransferCallData,
          dxdApprovalCallData,
          vestingCallData,
        ],

        value: [0, 0, 0, 0],
        titleText: localStorage.getItem('dxvote-newProposal-title'),
        descriptionHash: contentHash.fromIpfs(hash),
      };

      console.debug('[PROPOSAL]', scheme.address, proposalData);

      daoService
        .createProposal(scheme.address, scheme.type, proposalData)
        .on(TXEvents.TX_HASH, hash => {
          console.debug('[TX_SUBMITTED]', hash);
          setConfirm(false);
        })
        .on(TXEvents.RECEIPT, hash => {
          console.debug('[TX_RECEIPT]', hash);
          setLoading(false);
          setProposalCreated(true);
        })
        .on(TXEvents.TX_ERROR, txerror => {
          console.error('[TX_ERROR]', txerror);
          setLoading(false);
          setErrorMessage((txerror as Error).message);
        })
        .on(TXEvents.INVARIANT, error => {
          console.error('[ERROR]', error);
          setLoading(false);
          setErrorMessage((error as Error).message);
        })
        .catch(error => {
          console.error('[ERROR]', error);
          setLoading(false);
          setErrorMessage((error as Error).message);
        });
    } catch (error) {
      console.error('[PROPOSAL_ERROR]', error);
    }
  };

  return {
    submitProposal,
    loading,
    proposalCreated,
    errorMessage,
  };
}