@foreverrbum/ethsign/dist/helpers/newdocument.js

This package will allow you to electronically sign documents within your application

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.validateUploadFile = exports.setDocumentCommentsForSigner = exports.setDocStorageForDocument = exports.handleFileUpload = exports.handleDocumentReupload = exports.handleDocumentMetadataUpload = exports.getEncryptedStringFromFile = exports.getEncryptedStringFromBuffer = exports.docUpload = exports.default = exports.autoSelfSign = exports.aggregateNewBasicDocumentAndSetStorage = exports.aggregateHandleDocumentUpload = void 0;

var _bs = _interopRequireDefault(require("bs58"));

var _cryptoJs = _interopRequireDefault(require("crypto-js"));

var _ipfsHttpClient = require("ipfs-http-client");

var _fleekStorageJs = _interopRequireDefault(require("@fleekhq/fleek-storage-js"));

var _ethers = require("ethers");

var _dashboard = require("./dashboard");

var _sign = require("./sign");

var _file = require("./file");

var _pdfLib = require("pdf-lib");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var FLEEK_SECRET = "hu1j3Lr1jZbpLF1L96HgKtjbtQCvHgw+J+Ww4dwIXHI=";
var FLEEK_KEY = "9mvRajFjGL6fws3M2BHJvA==";
var fromAscii = _ethers.ethers.utils.formatBytes32String;

var handleFileUpload = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(storage_provider, buffer) {
    var storage_ID;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (storage_provider == "IPFS") {} else if (storage_provider == "Fleek") {}

            return _context.abrupt("return", storage_ID);

          case 2:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function handleFileUpload(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();

exports.handleFileUpload = handleFileUpload;

var handleDocumentReupload = /*#__PURE__*/function () {
  var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(storage_provider, handleSubmitButton, password, documentKey, file, fileHash, handleFileHash, createProgress, handleCreateProgress, indicatorProgress, handleIndicatorProgress, continueCallback, close, formatMessage) {
    var docuStorageHash, reader;
    return regeneratorRuntime.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            docuStorageHash = fileHash;
            reader = new window.FileReader();
            reader.readAsArrayBuffer(file);
            reader.onloadend = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
              var buffer, encryptedString, storage_id0, storage_id1, ipfs, uploadedFile;
              return regeneratorRuntime.wrap(function _callee2$(_context2) {
                while (1) {
                  switch (_context2.prev = _context2.next) {
                    case 0:
                      // File encryption
                      handleSubmitButton(formatMessage({
                        id: 'ENCRYPTING_FILE'
                      }));
                      buffer = Buffer(reader.result);
                      encryptedString = _cryptoJs.default.AES.encrypt(JSON.stringify(buffer), password).toString(); // File upload
                      // Part 1 and part 2 if cannot fit in bytes32

                      storage_id0 = '0x0000000000000000000000000000000000000000000000000000000000000000';
                      storage_id1 = '0x0000000000000000000000000000000000000000000000000000000000000000';
                      _context2.prev = 5;
                      handleSubmitButton(formatMessage({
                        id: 'UPLOADING_FILE_TO'
                      }, {
                        ip: storage_provider === 'IP' ? 'IPFS' + formatMessage({
                          id: 'PERMAPINNING_ARWEAVE'
                        }) : '',
                        fl: storage_provider === 'FL' ? 'Fleek' : '',
                        ar: storage_provider === 'AR' ? 'Arweave' : ''
                      }));

                      if (!(storage_provider == 'IP')) {
                        _context2.next = 12;
                        break;
                      }

                      // IPFS
                      ipfs = (0, _ipfsHttpClient.create)({
                        host: 'ipfs.infura.io',
                        port: 5001,
                        protocol: 'https'
                      });
                      storage_id0 = ipfsUpload(encryptedString);
                      _context2.next = 20;
                      break;

                    case 12:
                      if (!(storage_provider == 'FL')) {
                        _context2.next = 19;
                        break;
                      }

                      _context2.next = 15;
                      return _fleekStorageJs.default.upload({
                        apiKey: FLEEK_KEY,
                        apiSecret: FLEEK_SECRET,
                        key: documentKey,
                        data: encryptedString
                      });

                    case 15:
                      uploadedFile = _context2.sent;
                      storage_id0 = '0x' + _bs.default.decode(uploadedFile.hashV0).slice(2).toString('hex');
                      _context2.next = 20;
                      break;

                    case 19:
                      if (storage_provider == 'AR') {// Arweave
                      }

                    case 20:
                      docuStorageHash = {
                        0: storage_id0,
                        1: storage_id1
                      };
                      handleFileHash(docuStorageHash);
                      handleCreateProgress(1);
                      indicatorProgress += 1;
                      handleIndicatorProgress(indicatorProgress);
                      continueCallback(1, indicatorProgress, docuStorageHash);
                      return _context2.abrupt("return", 1);

                    case 29:
                      _context2.prev = 29;
                      _context2.t0 = _context2["catch"](5);
                      (0, _dashboard.storeNotif)(formatMessage({
                        id: 'FILE_UPLOAD_ERROR'
                      }), formatMessage({
                        id: 'FILE_UPLOAD_ERROR_MESSAGE'
                      }, {
                        button: formatMessage({
                          id: "SEND"
                        })
                      }), 'danger');
                      close();
                      return _context2.abrupt("return", 0);

                    case 34:
                    case "end":
                      return _context2.stop();
                  }
                }
              }, _callee2, null, [[5, 29]]);
            }));

          case 4:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3);
  }));

  return function handleDocumentReupload(_x3, _x4, _x5, _x6, _x7, _x8, _x9, _x10, _x11, _x12, _x13, _x14, _x15, _x16) {
    return _ref2.apply(this, arguments);
  };
}();

exports.handleDocumentReupload = handleDocumentReupload;

var setDocStorageForDocument = /*#__PURE__*/function () {
  var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(contract, provider, documentKey, storage_provider, docuStorageHash, indicatorProgress, handleIndicatorProgress, handleCreateProgress, handleSubmitButton, continueCallback, close, formatMessage) {
    var instance, storage_address, tx1, networkId;
    return regeneratorRuntime.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            _context4.prev = 0;
            instance = contract.connect(provider.getSigner());
            handleSubmitButton(formatMessage({
              id: 'SVAING_FILE_ADDRESS_TO_BLOCKCHAIN'
            }));
            storage_address = fromAscii(storage_provider);
            _context4.next = 6;
            return instance.setDocStorageForDocument(documentKey, storage_address, docuStorageHash[0], docuStorageHash[1]);

          case 6:
            tx1 = _context4.sent;
            handleSubmitButton(formatMessage({
              id: 'WAITING_FOR_CONFIRMATIONS_FROM_NEWWORK'
            }));
            _context4.next = 10;
            return provider.getNetwork();

          case 10:
            networkId = _context4.sent.chainId;
            _context4.next = 13;
            return tx1.wait(networkId == 1287 ? 2 : 1).then(function (receipt) {
              // console.log(receipt)
              indicatorProgress += 1;
              handleIndicatorProgress(indicatorProgress);
              handleCreateProgress(2);
              continueCallback(2, indicatorProgress, docuStorageHash);
            });

          case 13:
            _context4.next = 20;
            break;

          case 15:
            _context4.prev = 15;
            _context4.t0 = _context4["catch"](0);
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'DOCUMENT_STORAGE_ERROR'
            }), formatMessage({
              id: 'PLEASE_PRESS_SUBMIT_TO_RETRY'
            }, {
              error: _context4.t0.message.toString()
            }), 'danger');
            close();
            return _context4.abrupt("return", 0);

          case 20:
          case "end":
            return _context4.stop();
        }
      }
    }, _callee4, null, [[0, 15]]);
  }));

  return function setDocStorageForDocument(_x17, _x18, _x19, _x20, _x21, _x22, _x23, _x24, _x25, _x26, _x27, _x28) {
    return _ref4.apply(this, arguments);
  };
}();

exports.setDocStorageForDocument = setDocStorageForDocument;

var getEncryptedStringFromFile = /*#__PURE__*/function () {
  var _ref5 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6(file, password) {
    var reader;
    return regeneratorRuntime.wrap(function _callee6$(_context6) {
      while (1) {
        switch (_context6.prev = _context6.next) {
          case 0:
            reader = new window.FileReader();
            return _context6.abrupt("return", new Promise(function (resolve, reject) {
              reader.onload = /*#__PURE__*/function () {
                var _ref6 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(fileEvent) {
                  var buffer, encryptedString;
                  return regeneratorRuntime.wrap(function _callee5$(_context5) {
                    while (1) {
                      switch (_context5.prev = _context5.next) {
                        case 0:
                          buffer = Buffer(fileEvent.target.result);
                          encryptedString = getEncryptedStringFromBuffer(buffer, password);
                          resolve(encryptedString);

                        case 3:
                        case "end":
                          return _context5.stop();
                      }
                    }
                  }, _callee5);
                }));

                return function (_x31) {
                  return _ref6.apply(this, arguments);
                };
              }();

              reader.onerror = function () {
                reject('oops, something went wrong with the file reader.');
              };

              reader.readAsArrayBuffer(file);
            }));

          case 2:
          case "end":
            return _context6.stop();
        }
      }
    }, _callee6);
  }));

  return function getEncryptedStringFromFile(_x29, _x30) {
    return _ref5.apply(this, arguments);
  };
}();

exports.getEncryptedStringFromFile = getEncryptedStringFromFile;

var getEncryptedStringFromBuffer = function getEncryptedStringFromBuffer(buffer, password) {
  var encryptedString = _cryptoJs.default.AES.encrypt(JSON.stringify(buffer), password).toString();

  return encryptedString;
};

exports.getEncryptedStringFromBuffer = getEncryptedStringFromBuffer;

var ipfsUpload = /*#__PURE__*/function () {
  var _ref7 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7(encryptedFile) {
    var ipfs, file, hash, res;
    return regeneratorRuntime.wrap(function _callee7$(_context7) {
      while (1) {
        switch (_context7.prev = _context7.next) {
          case 0:
            ipfs = (0, _ipfsHttpClient.create)({
              host: 'ipfs.infura.io',
              port: 5001,
              protocol: 'https'
            });
            _context7.next = 3;
            return ipfs.add(encryptedFile);

          case 3:
            file = _context7.sent;
            hash = file.path;
            _context7.next = 7;
            return fetch("https://ipfs2arweave.com/permapin/".concat(hash), {
              method: 'POST'
            });

          case 7:
            res = _context7.sent;

            if (res.ok) {
              _context7.next = 15;
              break;
            }

            _context7.t0 = console;
            _context7.next = 12;
            return res.json();

          case 12:
            _context7.t1 = _context7.sent;

            _context7.t0.log.call(_context7.t0, _context7.t1);

            throw new Error("ipfs2arweave HTTP status: " + res.status);

          case 15:
            return _context7.abrupt("return", '0x' + _bs.default.decode(hash).slice(2).toString('hex'));

          case 16:
          case "end":
            return _context7.stop();
        }
      }
    }, _callee7);
  }));

  return function ipfsUpload(_x32) {
    return _ref7.apply(this, arguments);
  };
}();

var fleekUpload = /*#__PURE__*/function () {
  var _ref8 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee8(encryptedFile, key) {
    var uploadedFile;
    return regeneratorRuntime.wrap(function _callee8$(_context8) {
      while (1) {
        switch (_context8.prev = _context8.next) {
          case 0:
            _context8.next = 2;
            return _fleekStorageJs.default.upload({
              apiKey: FLEEK_KEY,
              apiSecret: FLEEK_SECRET,
              key: key,
              data: encryptedFile
            });

          case 2:
            uploadedFile = _context8.sent;
            return _context8.abrupt("return", '0x' + _bs.default.decode(uploadedFile.hashV0).slice(2).toString('hex'));

          case 4:
          case "end":
            return _context8.stop();
        }
      }
    }, _callee8);
  }));

  return function fleekUpload(_x33, _x34) {
    return _ref8.apply(this, arguments);
  };
}();

var aggregateFleekUpload = /*#__PURE__*/function () {
  var _ref9 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee9(documentKey, ethAccount, instance, encryptedFile, encryptedSigFields, encryptedAnnotations) {
    var saltedDocumentMappingKey, saltedAddressMappingKey, storage_id0, sig_storage_id0, annot_storage_id0;
    return regeneratorRuntime.wrap(function _callee9$(_context9) {
      while (1) {
        switch (_context9.prev = _context9.next) {
          case 0:
            _context9.next = 2;
            return instance.hashSaltedDocumentMappingKey(documentKey);

          case 2:
            saltedDocumentMappingKey = _context9.sent;
            _context9.next = 5;
            return instance.hashSaltedAddressMappingKey(documentKey, ethAccount);

          case 5:
            saltedAddressMappingKey = _context9.sent;
            _context9.next = 8;
            return fleekUpload(encryptedFile, documentKey);

          case 8:
            storage_id0 = _context9.sent;
            _context9.next = 11;
            return fleekUpload(encryptedSigFields, saltedDocumentMappingKey);

          case 11:
            sig_storage_id0 = _context9.sent;
            _context9.next = 14;
            return fleekUpload(encryptedAnnotations, saltedAddressMappingKey);

          case 14:
            annot_storage_id0 = _context9.sent;
            return _context9.abrupt("return", {
              storage_id0: storage_id0,
              sig_storage_id0: sig_storage_id0,
              annot_storage_id0: annot_storage_id0
            });

          case 16:
          case "end":
            return _context9.stop();
        }
      }
    }, _callee9);
  }));

  return function aggregateFleekUpload(_x35, _x36, _x37, _x38, _x39, _x40) {
    return _ref9.apply(this, arguments);
  };
}();

var getFileUploadMessage = function getFileUploadMessage(storageProvider, formatMessage) {
  return formatMessage({
    id: 'UPLOADING_FILE_TO'
  }, {
    ip: storageProvider === 'IP' ? 'IPFS' + formatMessage({
      id: 'PERMAPINNING_ARWEAVE'
    }) : '',
    fl: storageProvider === 'FL' ? 'Fleek' : '',
    ar: storageProvider === 'AR' ? 'Arweave' : ''
  });
};

var emptyHex = '0x0000000000000000000000000000000000000000000000000000000000000000';

var setDocumentCommentsForSigner = /*#__PURE__*/function () {
  var _ref10 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee11(provider, contract, ethAccount, storageProvider, documentKey, indices, ec_signatures, encryptedAnnotations, formatMessage, callback, errorCallback, handleSaveStatus, signaturesLength) {
    var signer, instance, annot_storage_id0, annot_storage_id1, saltedAddressMappingKey, tx, networkId;
    return regeneratorRuntime.wrap(function _callee11$(_context11) {
      while (1) {
        switch (_context11.prev = _context11.next) {
          case 0:
            handleSaveStatus(getFileUploadMessage(storageProvider, formatMessage));
            _context11.next = 3;
            return provider.getSigner();

          case 3:
            signer = _context11.sent;
            // signer == current logged in user
            instance = contract.connect(signer);
            annot_storage_id0 = emptyHex;
            annot_storage_id1 = emptyHex;
            _context11.next = 9;
            return instance.hashSaltedAddressMappingKey(documentKey, ethAccount);

          case 9:
            saltedAddressMappingKey = _context11.sent;
            _context11.prev = 10;

            if (!(storageProvider == 'IP')) {
              _context11.next = 28;
              break;
            }

            _context11.prev = 12;
            _context11.next = 15;
            return ipfsUpload(encryptedAnnotations);

          case 15:
            annot_storage_id0 = _context11.sent;
            _context11.next = 26;
            break;

          case 18:
            _context11.prev = 18;
            _context11.t0 = _context11["catch"](12);
            console.log(_context11.t0);
            storageProvider = 'FL';
            handleSaveStatus(getFileUploadMessage(storageProvider, formatMessage));
            _context11.next = 25;
            return fleekUpload(encryptedAnnotations, saltedAddressMappingKey);

          case 25:
            annot_storage_id0 = _context11.sent;

          case 26:
            _context11.next = 35;
            break;

          case 28:
            if (!(storageProvider == 'FL')) {
              _context11.next = 34;
              break;
            }

            _context11.next = 31;
            return fleekUpload(encryptedAnnotations, saltedAddressMappingKey);

          case 31:
            annot_storage_id0 = _context11.sent;
            _context11.next = 35;
            break;

          case 34:
            if (storageProvider == 'AR') {// Arweave
            }

          case 35:
            storageProvider = fromAscii(storageProvider);
            _context11.next = 38;
            return instance.aggregateSetSigFieldsAndCommentsAsSigner(documentKey, indices, ec_signatures, [storageProvider, annot_storage_id0, annot_storage_id1], {
              gasLimit: 2500000
            });

          case 38:
            tx = _context11.sent;
            // handleSubmitButton(formatMessage({id: 'WAITING_FOR_CONFIRMATIONS_FROM_NEWWORK'}));
            handleSaveStatus(formatMessage({
              id: 'WAITING_FOR_CONFIRMATIONS_FROM_NEWWORK'
            }));
            _context11.next = 42;
            return provider.getNetwork();

          case 42:
            networkId = _context11.sent.chainId;
            _context11.next = 45;
            return tx.wait(networkId == 1287 ? 2 : 1).then( /*#__PURE__*/function () {
              var _ref11 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee10(receipt) {
                var message;
                return regeneratorRuntime.wrap(function _callee10$(_context10) {
                  while (1) {
                    switch (_context10.prev = _context10.next) {
                      case 0:
                        message = signaturesLength > 0 ? 'SIGNATURES_COMMENTS_SAVED' : 'COMMENTS_SAVED';
                        handleSaveStatus(null);
                        (0, _dashboard.storeNotif)(formatMessage({
                          id: 'SUCCESSFUL_TRANSACTION'
                        }), formatMessage({
                          id: message
                        }), 'success');

                        if (!callback) {
                          _context10.next = 6;
                          break;
                        }

                        _context10.next = 6;
                        return callback();

                      case 6:
                      case "end":
                        return _context10.stop();
                    }
                  }
                }, _callee10);
              }));

              return function (_x54) {
                return _ref11.apply(this, arguments);
              };
            }());

          case 45:
            _context11.next = 54;
            break;

          case 47:
            _context11.prev = 47;
            _context11.t1 = _context11["catch"](10);
            console.log(_context11.t1);
            handleSaveStatus(null);
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'FILE_UPLOAD_ERROR'
            }), formatMessage({
              id: 'FILE_UPLOAD_ERROR_MESSAGE'
            }, {
              button: formatMessage({
                id: "SIGN"
              })
            }), 'danger');

            if (errorCallback) {
              errorCallback();
            }

            return _context11.abrupt("return", false);

          case 54:
            return _context11.abrupt("return", true);

          case 55:
          case "end":
            return _context11.stop();
        }
      }
    }, _callee11, null, [[10, 47], [12, 18]]);
  }));

  return function setDocumentCommentsForSigner(_x41, _x42, _x43, _x44, _x45, _x46, _x47, _x48, _x49, _x50, _x51, _x52, _x53) {
    return _ref10.apply(this, arguments);
  };
}();

exports.setDocumentCommentsForSigner = setDocumentCommentsForSigner;

var docUpload = /*#__PURE__*/function () {
  var _ref12 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee12(formatMessage, encryptedFile, contract, handleSubmitButton, storage_provider) {
    var documentKey, hash;
    return regeneratorRuntime.wrap(function _callee12$(_context12) {
      while (1) {
        switch (_context12.prev = _context12.next) {
          case 0:
            handleSubmitButton(getFileUploadMessage(storage_provider, formatMessage));
            _context12.next = 3;
            return (0, _dashboard.getNewDocumentKey)(contract);

          case 3:
            documentKey = _context12.sent;
            hash = emptyHex;
            _context12.prev = 5;
            _context12.next = 8;
            return ipfsUpload(encryptedFile);

          case 8:
            hash = _context12.sent;
            _context12.next = 19;
            break;

          case 11:
            _context12.prev = 11;
            _context12.t0 = _context12["catch"](5);
            console.log(_context12.t0);
            storage_provider = "FL";
            handleSubmitButton(getFileUploadMessage('FL', formatMessage));
            _context12.next = 18;
            return fleekUpload(encryptedFile, documentKey);

          case 18:
            hash = _context12.sent;

          case 19:
            return _context12.abrupt("return", {
              documentKey: documentKey,
              hash: hash,
              storage_provider: storage_provider
            });

          case 20:
          case "end":
            return _context12.stop();
        }
      }
    }, _callee12, null, [[5, 11]]);
  }));

  return function docUpload(_x55, _x56, _x57, _x58, _x59) {
    return _ref12.apply(this, arguments);
  };
}();

exports.docUpload = docUpload;

var aggregateHandleDocumentUpload = /*#__PURE__*/function () {
  var _ref13 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee13(provider, contract, storageProvider, handleStorageProvider, handleSubmitButton, documentKey, encryptedFile, handleStorageHash, encryptedSigFields, encryptedAnnotations, handleCreateProgress, indicatorProgress, handleIndicatorProgress, continueCallback, close, formatMessage) {
    var signer, ethAccount, instance, storage_id0, storage_id1, sig_storage_id0, sig_storage_id1, annot_storage_id0, annot_storage_id1, temp, _temp, storage_ids;

    return regeneratorRuntime.wrap(function _callee13$(_context13) {
      while (1) {
        switch (_context13.prev = _context13.next) {
          case 0:
            _context13.next = 2;
            return provider.getSigner();

          case 2:
            signer = _context13.sent;
            _context13.next = 5;
            return signer.getAddress();

          case 5:
            ethAccount = _context13.sent;
            instance = contract.connect(signer); // Part 1 and part 2 if cannot fit in bytes32

            storage_id0 = emptyHex;
            storage_id1 = emptyHex;
            sig_storage_id0 = emptyHex;
            sig_storage_id1 = emptyHex;
            annot_storage_id0 = emptyHex;
            annot_storage_id1 = emptyHex;
            _context13.prev = 13;
            handleSubmitButton(getFileUploadMessage(storageProvider, formatMessage));

            if (!(storageProvider == 'IP')) {
              _context13.next = 42;
              break;
            }

            _context13.prev = 16;
            _context13.next = 19;
            return ipfsUpload(encryptedFile);

          case 19:
            storage_id0 = _context13.sent;
            _context13.next = 22;
            return ipfsUpload(encryptedSigFields);

          case 22:
            sig_storage_id0 = _context13.sent;
            _context13.next = 25;
            return ipfsUpload(encryptedAnnotations);

          case 25:
            annot_storage_id0 = _context13.sent;
            _context13.next = 40;
            break;

          case 28:
            _context13.prev = 28;
            _context13.t0 = _context13["catch"](16);
            console.log(_context13.t0);
            storageProvider = 'FL';
            handleStorageProvider(storageProvider);
            handleSubmitButton(getFileUploadMessage(storageProvider, formatMessage));
            _context13.next = 36;
            return aggregateFleekUpload(documentKey, ethAccount, instance, encryptedFile, encryptedSigFields, encryptedAnnotations);

          case 36:
            temp = _context13.sent;
            storage_id0 = temp.storage_id0;
            sig_storage_id0 = temp.sig_storage_id0;
            annot_storage_id0 = temp.annot_storage_id0;

          case 40:
            _context13.next = 52;
            break;

          case 42:
            if (!(storageProvider == 'FL')) {
              _context13.next = 51;
              break;
            }

            _context13.next = 45;
            return aggregateFleekUpload(documentKey, ethAccount, instance, encryptedFile, encryptedSigFields, encryptedAnnotations);

          case 45:
            _temp = _context13.sent;
            storage_id0 = _temp.storage_id0;
            sig_storage_id0 = _temp.sig_storage_id0;
            annot_storage_id0 = _temp.annot_storage_id0;
            _context13.next = 52;
            break;

          case 51:
            if (storageProvider == 'AR') {// Arweave
            }

          case 52:
            storage_ids = [storage_id0, storage_id1, sig_storage_id0, sig_storage_id1, annot_storage_id0, annot_storage_id1];
            handleStorageHash(storage_ids);
            handleCreateProgress(1);
            indicatorProgress += 1;
            handleIndicatorProgress(indicatorProgress);
            continueCallback(1, indicatorProgress, storage_ids, storageProvider);
            return _context13.abrupt("return", 1);

          case 61:
            _context13.prev = 61;
            _context13.t1 = _context13["catch"](13);
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'FILE_UPLOAD_ERROR'
            }), formatMessage({
              id: 'FILE_UPLOAD_ERROR_MESSAGE'
            }, {
              button: formatMessage({
                id: "SEND"
              })
            }), 'danger');
            close();
            return _context13.abrupt("return", 0);

          case 66:
          case "end":
            return _context13.stop();
        }
      }
    }, _callee13, null, [[13, 61], [16, 28]]);
  }));

  return function aggregateHandleDocumentUpload(_x60, _x61, _x62, _x63, _x64, _x65, _x66, _x67, _x68, _x69, _x70, _x71, _x72, _x73, _x74, _x75) {
    return _ref13.apply(this, arguments);
  };
}();

exports.aggregateHandleDocumentUpload = aggregateHandleDocumentUpload;

var aggregateNewBasicDocumentAndSetStorage = /*#__PURE__*/function () {
  var _ref14 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee14(provider, contract, docKey, docName, expiration, storage_provider, docuStorageHash, signers, numOfSigFields, handleSubmitButton, formatMessage, successTxCallback, failTxCallback, buttonLabel) {
    var instance, storage_address, documentName, tx;
    return regeneratorRuntime.wrap(function _callee14$(_context14) {
      while (1) {
        switch (_context14.prev = _context14.next) {
          case 0:
            instance = contract.connect(provider.getSigner());
            storage_address = fromAscii(storage_provider);
            documentName = fromAscii(docName);
            _context14.prev = 3;
            handleSubmitButton(formatMessage({
              id: "SVAING_FILE_ADDRESS_TO_BLOCKCHAIN"
            }));
            _context14.next = 7;
            return instance.aggregateNewBasicDocumentAndSetStorage(docKey, documentName, expiration, signers.length, [storage_address, storage_address, storage_address], docuStorageHash, signers, numOfSigFields, {
              gasLimit: 2500000
            });

          case 7:
            tx = _context14.sent;
            handleSubmitButton(formatMessage({
              id: 'WAITING_FOR_CONFIRMATIONS_FROM_NEWWORK'
            }));

            if (!successTxCallback) {
              _context14.next = 12;
              break;
            }

            _context14.next = 12;
            return successTxCallback(tx);

          case 12:
            return _context14.abrupt("return", 1);

          case 15:
            _context14.prev = 15;
            _context14.t0 = _context14["catch"](3);
            console.log(_context14.t0);
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'TRANSACTION_ERROR'
            }), formatMessage({
              id: 'PLEASE_PRESS_SUBMIT_TO_RETRY'
            }, {
              button: buttonLabel
            }), 'danger');

            if (failTxCallback) {
              failTxCallback();
            }

            return _context14.abrupt("return", 0);

          case 21:
          case "end":
            return _context14.stop();
        }
      }
    }, _callee14, null, [[3, 15]]);
  }));

  return function aggregateNewBasicDocumentAndSetStorage(_x76, _x77, _x78, _x79, _x80, _x81, _x82, _x83, _x84, _x85, _x86, _x87, _x88, _x89) {
    return _ref14.apply(this, arguments);
  };
}();

exports.aggregateNewBasicDocumentAndSetStorage = aggregateNewBasicDocumentAndSetStorage;

var autoSelfSign = /*#__PURE__*/function () {
  var _ref15 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee15(contract, provider, docKey, createProgress, handleCreateProgress, indicatorProgress, handleIndicatorProgress, handleSubmitButton, continueCallback, close, formatMessage) {
    var basicDoc, fullDoc;
    return regeneratorRuntime.wrap(function _callee15$(_context15) {
      while (1) {
        switch (_context15.prev = _context15.next) {
          case 0:
            handleSubmitButton(formatMessage({
              id: 'AUTOMATICLLY_SELF_SIGNING'
            }));
            _context15.next = 3;
            return (0, _dashboard.getDocument)(docKey, contract, provider, formatMessage);

          case 3:
            basicDoc = _context15.sent;
            _context15.next = 6;
            return (0, _dashboard.getDocumentDetails)(docKey, basicDoc, contract, provider, formatMessage);

          case 6:
            fullDoc = _context15.sent;
            _context15.prev = 7;
            _context15.next = 10;
            return (0, _sign.signDocumentAtIndex)(contract, provider, docKey, fullDoc.ipfsHash, fullDoc.metaHash, 0, handleSubmitButton, formatMessage);

          case 10:
            if (!_context15.sent) {
              _context15.next = 17;
              break;
            }

            indicatorProgress += 1;
            handleIndicatorProgress(indicatorProgress);
            handleCreateProgress(3);
            continueCallback(3, indicatorProgress);
            _context15.next = 20;
            break;

          case 17:
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'TRANSACTION_ERROR'
            }), formatMessage({
              id: 'ERROR_SIGNING_DOCUMENT'
            }), 'danger');
            close();
            return _context15.abrupt("return", 0);

          case 20:
            _context15.next = 27;
            break;

          case 22:
            _context15.prev = 22;
            _context15.t0 = _context15["catch"](7);
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'TRANSACTION_ERROR'
            }), formatMessage({
              id: 'PLEASE_PRESS_SUBMIT_TO_RETRY'
            }, {
              button: formatMessage({
                id: 'SEND'
              })
            }), 'danger');
            close();
            return _context15.abrupt("return", 0);

          case 27:
            return _context15.abrupt("return", 1);

          case 28:
          case "end":
            return _context15.stop();
        }
      }
    }, _callee15, null, [[7, 22]]);
  }));

  return function autoSelfSign(_x90, _x91, _x92, _x93, _x94, _x95, _x96, _x97, _x98, _x99, _x100) {
    return _ref15.apply(this, arguments);
  };
}(); // Upload document metadata file


exports.autoSelfSign = autoSelfSign;

var handleDocumentMetadataUpload = /*#__PURE__*/function () {
  var _ref16 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee16(instance, docKey, file, storage_provider) {
    return regeneratorRuntime.wrap(function _callee16$(_context16) {
      while (1) {
        switch (_context16.prev = _context16.next) {
          case 0:
          case "end":
            return _context16.stop();
        }
      }
    }, _callee16);
  }));

  return function handleDocumentMetadataUpload(_x101, _x102, _x103, _x104) {
    return _ref16.apply(this, arguments);
  };
}();

exports.handleDocumentMetadataUpload = handleDocumentMetadataUpload;

var readFile = function readFile(file) {
  return new Promise(function (resolve, reject) {
    var reader = new FileReader();

    reader.onload = function () {
      return resolve(reader.result);
    };

    reader.onerror = function (error) {
      return reject(error);
    };

    reader.readAsArrayBuffer(file);
  });
};

var getNumPages = /*#__PURE__*/function () {
  var _ref17 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee17(file) {
    var arrayBuffer, pdf;
    return regeneratorRuntime.wrap(function _callee17$(_context17) {
      while (1) {
        switch (_context17.prev = _context17.next) {
          case 0:
            _context17.next = 2;
            return readFile(file);

          case 2:
            arrayBuffer = _context17.sent;
            _context17.next = 5;
            return _pdfLib.PDFDocument.load(arrayBuffer);

          case 5:
            pdf = _context17.sent;
            return _context17.abrupt("return", pdf.getPages().length);

          case 7:
          case "end":
            return _context17.stop();
        }
      }
    }, _callee17);
  }));

  return function getNumPages(_x105) {
    return _ref17.apply(this, arguments);
  };
}();

var validateUploadFile = /*#__PURE__*/function () {
  var _ref18 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee18(file, handlePageCount, handleFile, handleFilename, handleOriginalFilename, formatMessage) {
    var tempFile, count, name;
    return regeneratorRuntime.wrap(function _callee18$(_context18) {
      while (1) {
        switch (_context18.prev = _context18.next) {
          case 0:
            if (!(file.type != "application/pdf")) {
              _context18.next = 4;
              break;
            }

            (0, _dashboard.storeNotif)(formatMessage({
              id: 'FILE_TYPE_ERROR'
            }), formatMessage({
              id: 'ONLY_PROCESS_PDFS'
            }), 'danger');
            _context18.next = 23;
            break;

          case 4:
            tempFile = file;
            _context18.prev = 5;
            _context18.next = 8;
            return getNumPages(tempFile);

          case 8:
            count = _context18.sent;
            // await reader.result.match(/\/Type[\]*\/Page[^s]/i).length;
            handlePageCount(count);
            handleOriginalFilename(tempFile.name);
            handleFile(tempFile);
            name = (0, _file.getFileName)(file); // PDF name length error checker

            if (tempFile.name.length >= 32) {
              name.name = name.name.slice(0, 31 - name.ext.length); // Our file name can only be 32 characters long WITH NULL TERMINATOR, including extension. Do calculation below and slice it.

              (0, _dashboard.storeNotif)(formatMessage({
                id: 'FILE_RENAMED'
              }), "".concat(formatMessage({
                id: "FILENAME_HAS_BEEN_SHORTENED"
              }), " ").concat(name.name), 'info');
            }

            handleFilename(name);
            _context18.next = 23;
            break;

          case 17:
            _context18.prev = 17;
            _context18.t0 = _context18["catch"](5);
            // Invalid PDF, no page count included
            handlePageCount(null);
            handleFile(null);
            (0, _dashboard.storeNotif)(formatMessage({
              id: 'INVALID_PDF'
            }), formatMessage({
              id: 'PLEASE_TRY_ANOTHER_FILE'
            }), 'danger');
            return _context18.abrupt("return");

          case 23:
          case "end":
            return _context18.stop();
        }
      }
    }, _callee18, null, [[5, 17]]);
  }));

  return function validateUploadFile(_x106, _x107, _x108, _x109, _x110, _x111) {
    return _ref18.apply(this, arguments);
  };
}();

exports.validateUploadFile = validateUploadFile;
var _default = {
  autoSelfSign: autoSelfSign,
  aggregateHandleDocumentUpload: aggregateHandleDocumentUpload,
  aggregateNewBasicDocumentAndSetStorage: aggregateNewBasicDocumentAndSetStorage,
  getEncryptedStringFromFile: getEncryptedStringFromFile
};
exports.default = _default;