@opengovsg/formsg-sdk 0.10.0 → 0.12.0-alpha.1

package/dist/errors.js

@@ -3,16 +3,19 @@ var __extends = (this && this.__extends) || (function () {
     var extendStatics = function (d, b) {
         extendStatics = Object.setPrototypeOf ||
             ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
         return extendStatics(d, b);
     };
     return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
         extendStatics(d, b);
         function __() { this.constructor = d; }
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentDecryptionError = exports.WebhookAuthenticateError = exports.MissingPublicKeyError = exports.MissingSecretKeyError = void 0;
 var MissingSecretKeyError = /** @class */ (function (_super) {
     __extends(MissingSecretKeyError, _super);
     function MissingSecretKeyError(message) {

package/dist/index.d.ts

@@ -1,12 +1,8 @@
 import Crypto from './crypto';
+import CryptoV3 from './crypto-v3';
 import { PackageInitParams } from './types';
 import Verification from './verification';
 import Webhooks from './webhooks';
-declare const _default: (config?: PackageInitParams) => {
-    webhooks: Webhooks;
-    crypto: Crypto;
-    verification: Verification;
-};
 /**
  * Entrypoint into the FormSG SDK
  *
@@ -15,4 +11,10 @@ declare const _default: (config?: PackageInitParams) => {
  * @param {string?} [config.webhookSecretKey] Optional. base64 secret key for signing webhooks. If provided, enables generating signature and headers to authenticate webhook data.
  * @param {VerificationOptions?} [config.verificationOptions] Optional. If provided, enables the usage of the verification module.
  */
+declare const _default: (config?: PackageInitParams) => {
+    webhooks: Webhooks;
+    crypto: Crypto;
+    cryptoV3: CryptoV3;
+    verification: Verification;
+};
 export = _default;

package/dist/index.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var publicKey_1 = require("./util/publicKey");
 var crypto_1 = __importDefault(require("./crypto"));
+var crypto_v3_1 = __importDefault(require("./crypto-v3"));
 var verification_1 = __importDefault(require("./verification"));
 var webhooks_1 = __importDefault(require("./webhooks"));
 module.exports = function (config) {
@@ -13,17 +14,18 @@ module.exports = function (config) {
      * Public key is used for decrypting signed verified content in the `crypto` module, and
      * also for verifying webhook signatures' authenticity in the `wehbooks` module.
      */
-    var signingPublicKey = publicKey_1.getSigningPublicKey(mode || 'production');
+    var signingPublicKey = (0, publicKey_1.getSigningPublicKey)(mode || 'production');
     /**
      * Public key is used for verifying verified field signatures' authenticity in the `verification` module.
      */
-    var verificationPublicKey = publicKey_1.getVerificationPublicKey(mode || 'production');
+    var verificationPublicKey = (0, publicKey_1.getVerificationPublicKey)(mode || 'production');
     return {
         webhooks: new webhooks_1.default({
             publicKey: signingPublicKey,
             secretKey: webhookSecretKey,
         }),
         crypto: new crypto_1.default({ signingPublicKey: signingPublicKey }),
+        cryptoV3: new crypto_v3_1.default(),
         verification: new verification_1.default({
             publicKey: verificationPublicKey,
             secretKey: verificationOptions === null || verificationOptions === void 0 ? void 0 : verificationOptions.secretKey,

package/dist/resource/signing-keys.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGNING_KEYS = void 0;
 // keys generated using nacl.sign.keyPair() from tweetnacl
 exports.SIGNING_KEYS = {
     staging: {

package/dist/resource/verification-keys.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERIFICATION_KEYS = void 0;
 // keys generated using nacl.sign.keyPair() from tweetnacl
 exports.VERIFICATION_KEYS = {
     staging: {

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export declare type PackageInitParams = {
+export type PackageInitParams = {
     /** base64 secret key for signing webhooks. If provided, enables generating signature and headers to authenticate webhook data. */
     webhookSecretKey?: string;
     /** If provided, enables the usage of the verification module. */
@@ -6,8 +6,8 @@ export declare type PackageInitParams = {
     /** Initializes public key used for verifying and decrypting in this package. If not given, will default to "production". */
     mode?: PackageMode;
 };
-export declare type FieldType = 'section' | 'radiobutton' | 'dropdown' | 'checkbox' | 'nric' | 'email' | 'table' | 'number' | 'rating' | 'yes_no' | 'decimal' | 'textfield' | 'textarea' | 'attachment' | 'date' | 'mobile' | 'homeno';
-export declare type FormField = {
+export type FieldType = 'section' | 'radiobutton' | 'dropdown' | 'checkbox' | 'nric' | 'email' | 'table' | 'number' | 'rating' | 'yes_no' | 'decimal' | 'textfield' | 'textarea' | 'attachment' | 'date' | 'mobile' | 'homeno' | 'statement' | 'image' | 'country_region' | 'uen' | 'children';
+export type FormField = {
     _id: string;
     question: string;
     fieldType: FieldType;
@@ -20,61 +20,80 @@ export declare type FormField = {
     answer?: never;
     answerArray: string[] | string[][];
 });
-export declare type EncryptedContent = string;
-export declare type EncryptedAttachmentRecords = Record<string, string>;
+export type FormFieldsV3 = Record<string, {
+    fieldType: FieldType;
+    answer: any;
+}>;
+export type EncryptedContent = string;
+export type EncryptedContentV3 = {
+    submissionPublicKey: string;
+    submissionSecretKey: string;
+    encryptedContent: EncryptedContent;
+    encryptedSubmissionSecretKey: EncryptedContent;
+};
+export type EncryptedAttachmentRecords = Record<string, string>;
 export interface DecryptParams {
     encryptedContent: EncryptedContent;
     version: number;
     verifiedContent?: EncryptedContent;
     attachmentDownloadUrls?: EncryptedAttachmentRecords;
 }
-export declare type DecryptedContent = {
+export interface DecryptParamsV3 {
+    encryptedContent: EncryptedContent;
+    encryptedSubmissionSecretKey: EncryptedContent;
+    version: number;
+}
+export type DecryptedContent = {
     responses: FormField[];
     verified?: Record<string, any>;
 };
-export declare type DecryptedFile = {
+export type DecryptedContentV3 = {
+    submissionSecretKey: string;
+    responses: FormFieldsV3;
+};
+export type DecryptedFile = {
     filename: string;
     content: Uint8Array;
 };
-export declare type DecryptedAttachments = Record<string, DecryptedFile>;
-export declare type DecryptedContentAndAttachments = {
+export type DecryptedAttachments = Record<string, DecryptedFile>;
+export type DecryptedContentAndAttachments = {
     content: DecryptedContent;
     attachments: DecryptedAttachments;
 };
-export declare type EncryptedFileContent = {
+export type EncryptedFileContent = {
     submissionPublicKey: string;
     nonce: string;
     binary: Uint8Array;
 };
-export declare type EncryptedAttachmentContent = {
+export type EncryptedAttachmentContent = {
     encryptedFile: {
         submissionPublicKey: string;
         nonce: string;
         binary: string;
     };
 };
-export declare type Keypair = {
+export type Keypair = {
     publicKey: string;
     secretKey: string;
 };
-export declare type PackageMode = 'staging' | 'production' | 'development' | 'test';
-export declare type VerificationOptions = {
+export type PackageMode = 'staging' | 'production' | 'development' | 'test';
+export type VerificationOptions = {
     publicKey?: string;
     secretKey?: string;
     transactionExpiry?: number;
 };
-export declare type VerifiedAnswer = {
+export type VerifiedAnswer = {
     fieldId: string;
     answer: string;
 };
-export declare type VerificationSignatureOptions = VerifiedAnswer & {
+export type VerificationSignatureOptions = VerifiedAnswer & {
     transactionId: string;
     formId: string;
 };
-export declare type VerificationBasestringOptions = VerificationSignatureOptions & {
+export type VerificationBasestringOptions = VerificationSignatureOptions & {
     time: number;
 };
-export declare type VerificationAuthenticateOptions = VerifiedAnswer & {
+export type VerificationAuthenticateOptions = VerifiedAnswer & {
     signatureString: string;
     submissionCreatedAt: number;
 };

package/dist/util/crypto.d.ts

@@ -1,4 +1,4 @@
-import { Keypair, EncryptedAttachmentContent, EncryptedFileContent } from '../types';
+import { EncryptedAttachmentContent, EncryptedContent, EncryptedFileContent, Keypair } from '../types';
 /**
  * Helper method to generate a new keypair for encryption.
  * @returns The generated keypair.
@@ -11,14 +11,14 @@ export declare const generateKeypair: () => Keypair;
  * @returns The encrypted basestring
  * @throws error if any of the encrypt methods fail
  */
-export declare const encryptMessage: (msg: Uint8Array, theirPublicKey: string) => string;
+export declare const encryptMessage: (msg: Uint8Array, theirPublicKey: string) => EncryptedContent;
 /**
  * Helper method to decrypt an encrypted submission.
  * @param formPrivateKey base64
  * @param encryptedContent encrypted string encoded in base64
  * @return The decrypted content, or null if decryption failed.
  */
-export declare const decryptContent: (formPrivateKey: string, encryptedContent: string) => Uint8Array | null;
+export declare const decryptContent: (formPrivateKey: string, encryptedContent: EncryptedContent) => Uint8Array | null;
 /**
  * Helper method to verify a signed message.
  * @param msg the message to verify

package/dist/util/crypto.js

@@ -3,19 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEncryptedAttachmentToFileContent = exports.areAttachmentFieldIdsValid = exports.verifySignedMessage = exports.decryptContent = exports.encryptMessage = exports.generateKeypair = void 0;
 var tweetnacl_1 = __importDefault(require("tweetnacl"));
 var tweetnacl_util_1 = require("tweetnacl-util");
 /**
  * Helper method to generate a new keypair for encryption.
  * @returns The generated keypair.
  */
-exports.generateKeypair = function () {
+var generateKeypair = function () {
     var kp = tweetnacl_1.default.box.keyPair();
     return {
-        publicKey: tweetnacl_util_1.encodeBase64(kp.publicKey),
-        secretKey: tweetnacl_util_1.encodeBase64(kp.secretKey),
+        publicKey: (0, tweetnacl_util_1.encodeBase64)(kp.publicKey),
+        secretKey: (0, tweetnacl_util_1.encodeBase64)(kp.secretKey),
     };
 };
+exports.generateKeypair = generateKeypair;
 /**
  * Helper function to encrypt input with a unique keypair for each submission.
  * @param msg The message to encrypt
@@ -23,28 +25,30 @@ exports.generateKeypair = function () {
  * @returns The encrypted basestring
  * @throws error if any of the encrypt methods fail
  */
-exports.encryptMessage = function (msg, theirPublicKey) {
-    var submissionKeypair = exports.generateKeypair();
+var encryptMessage = function (msg, theirPublicKey) {
+    var submissionKeypair = (0, exports.generateKeypair)();
     var nonce = tweetnacl_1.default.randomBytes(24);
-    var encrypted = tweetnacl_util_1.encodeBase64(tweetnacl_1.default.box(msg, nonce, tweetnacl_util_1.decodeBase64(theirPublicKey), tweetnacl_util_1.decodeBase64(submissionKeypair.secretKey)));
-    return submissionKeypair.publicKey + ";" + tweetnacl_util_1.encodeBase64(nonce) + ":" + encrypted;
+    var encrypted = (0, tweetnacl_util_1.encodeBase64)(tweetnacl_1.default.box(msg, nonce, (0, tweetnacl_util_1.decodeBase64)(theirPublicKey), (0, tweetnacl_util_1.decodeBase64)(submissionKeypair.secretKey)));
+    return "".concat(submissionKeypair.publicKey, ";").concat((0, tweetnacl_util_1.encodeBase64)(nonce), ":").concat(encrypted);
 };
+exports.encryptMessage = encryptMessage;
 /**
  * Helper method to decrypt an encrypted submission.
  * @param formPrivateKey base64
  * @param encryptedContent encrypted string encoded in base64
  * @return The decrypted content, or null if decryption failed.
  */
-exports.decryptContent = function (formPrivateKey, encryptedContent) {
+var decryptContent = function (formPrivateKey, encryptedContent) {
     try {
         var _a = encryptedContent.split(';'), submissionPublicKey = _a[0], nonceEncrypted = _a[1];
         var _b = nonceEncrypted.split(':').map(tweetnacl_util_1.decodeBase64), nonce = _b[0], encrypted = _b[1];
-        return tweetnacl_1.default.box.open(encrypted, nonce, tweetnacl_util_1.decodeBase64(submissionPublicKey), tweetnacl_util_1.decodeBase64(formPrivateKey));
+        return tweetnacl_1.default.box.open(encrypted, nonce, (0, tweetnacl_util_1.decodeBase64)(submissionPublicKey), (0, tweetnacl_util_1.decodeBase64)(formPrivateKey));
     }
     catch (err) {
         return null;
     }
 };
+exports.decryptContent = decryptContent;
 /**
  * Helper method to verify a signed message.
  * @param msg the message to verify
@@ -52,28 +56,31 @@ exports.decryptContent = function (formPrivateKey, encryptedContent) {
  * @returns the signed message if successful, else an error will be thrown
  * @throws {Error} if the message cannot be verified
  */
-exports.verifySignedMessage = function (msg, publicKey) {
-    var openedMessage = tweetnacl_1.default.sign.open(msg, tweetnacl_util_1.decodeBase64(publicKey));
+var verifySignedMessage = function (msg, publicKey) {
+    var openedMessage = tweetnacl_1.default.sign.open(msg, (0, tweetnacl_util_1.decodeBase64)(publicKey));
     if (!openedMessage)
         throw new Error('Failed to open signed message with given public key');
-    return JSON.parse(tweetnacl_util_1.encodeUTF8(openedMessage));
+    return JSON.parse((0, tweetnacl_util_1.encodeUTF8)(openedMessage));
 };
+exports.verifySignedMessage = verifySignedMessage;
 /**
  * Helper method to check if all the field IDs given are within the filenames
  * @param fieldIds the list of fieldIds to check
  * @param filenames the filenames that should contain the fields
  * @returns boolean indicating whether the fields are valid
  */
-exports.areAttachmentFieldIdsValid = function (fieldIds, filenames) {
+var areAttachmentFieldIdsValid = function (fieldIds, filenames) {
     return fieldIds.every(function (fieldId) { return filenames[fieldId]; });
 };
+exports.areAttachmentFieldIdsValid = areAttachmentFieldIdsValid;
 /**
  * Converts an encrypted attachment to encrypted file content
  * @param encryptedAttachment The encrypted attachment
  * @returns EncryptedFileContent The encrypted file content
  */
-exports.convertEncryptedAttachmentToFileContent = function (encryptedAttachment) { return ({
+var convertEncryptedAttachmentToFileContent = function (encryptedAttachment) { return ({
     submissionPublicKey: encryptedAttachment.encryptedFile.submissionPublicKey,
     nonce: encryptedAttachment.encryptedFile.nonce,
-    binary: tweetnacl_util_1.decodeBase64(encryptedAttachment.encryptedFile.binary),
+    binary: (0, tweetnacl_util_1.decodeBase64)(encryptedAttachment.encryptedFile.binary),
 }); };
+exports.convertEncryptedAttachmentToFileContent = convertEncryptedAttachmentToFileContent;

package/dist/util/parser.d.ts

@@ -1,10 +1,10 @@
-export declare type HeaderSignature = {
+export type HeaderSignature = {
     v1: string;
     t: number;
     s: string;
     f: string;
 };
-export declare type VerificationSignature = {
+export type VerificationSignature = {
     v: string;
     t: number;
     s: string;

package/dist/util/parser.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVerificationSignature = exports.parseSignatureHeader = void 0;
 /**
  * Helper function to retrieve keys-values in a signature.
  * @param signature The signature to convert to a keymap
@@ -20,18 +21,20 @@ var signatureToKeyMap = function (signature) {
  * @param header The X-FormSG-Signature header
  * @returns The signature header constituents
  */
-exports.parseSignatureHeader = function (header) {
+var parseSignatureHeader = function (header) {
     var parsedSignature = signatureToKeyMap(header);
     parsedSignature.t = Number(parsedSignature.t);
     return parsedSignature;
 };
+exports.parseSignatureHeader = parseSignatureHeader;
 /**
  * Parses the verification signature into its constituent
  * @param signature The verification signature
  * @returns The verification signature constituents
  */
-exports.parseVerificationSignature = function (signature) {
+var parseVerificationSignature = function (signature) {
     var parsedSignature = signatureToKeyMap(signature);
     parsedSignature.t = Number(parsedSignature.t);
     return parsedSignature;
 };
+exports.parseVerificationSignature = parseVerificationSignature;

package/dist/util/publicKey.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVerificationPublicKey = exports.getSigningPublicKey = void 0;
 var signing_keys_1 = require("../resource/signing-keys");
 var verification_keys_1 = require("../resource/verification-keys");
 var stage_1 = __importDefault(require("./stage"));

package/dist/util/signature.js

@@ -1,12 +1,29 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.verify = exports.sign = void 0;
 var tweetnacl = __importStar(require("tweetnacl"));
 var tweetnacl_util_1 = require("tweetnacl-util");
 /**
@@ -16,7 +33,7 @@ var tweetnacl_util_1 = require("tweetnacl-util");
  * @return base64 encoded signature
  */
 function sign(basestring, secretKey) {
-    return tweetnacl_util_1.encodeBase64(tweetnacl.sign.detached(tweetnacl_util_1.decodeUTF8(basestring), tweetnacl_util_1.decodeBase64(secretKey)));
+    return (0, tweetnacl_util_1.encodeBase64)(tweetnacl.sign.detached((0, tweetnacl_util_1.decodeUTF8)(basestring), (0, tweetnacl_util_1.decodeBase64)(secretKey)));
 }
 exports.sign = sign;
 /**
@@ -27,6 +44,6 @@ exports.sign = sign;
  * @return True if verification checks out, false otherwise
  */
 function verify(message, signature, publicKey) {
-    return tweetnacl.sign.detached.verify(tweetnacl_util_1.decodeUTF8(message), tweetnacl_util_1.decodeBase64(signature), tweetnacl_util_1.decodeBase64(publicKey));
+    return tweetnacl.sign.detached.verify((0, tweetnacl_util_1.decodeUTF8)(message), (0, tweetnacl_util_1.decodeBase64)(signature), (0, tweetnacl_util_1.decodeBase64)(publicKey));
 }
 exports.verify = verify;

package/dist/util/validate.d.ts

@@ -1,3 +1,4 @@
-import { FormField } from '../types';
+import { FormField, FormFieldsV3 } from '../types';
 declare function determineIsFormFields(tbd: any): tbd is FormField[];
-export { determineIsFormFields };
+declare function determineIsFormFieldsV3(tbd: any): tbd is FormFieldsV3;
+export { determineIsFormFields, determineIsFormFieldsV3 };

package/dist/util/validate.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineIsFormFieldsV3 = exports.determineIsFormFields = void 0;
 function determineIsFormFields(tbd) {
     if (!Array.isArray(tbd)) {
         return false;
@@ -21,3 +22,15 @@ function determineIsFormFields(tbd) {
     return filter.length === tbd.length;
 }
 exports.determineIsFormFields = determineIsFormFields;
+// TODO(MRF): This is currently very rudimentary, we should look at making this more specific where required.
+function determineIsFormFieldsV3(tbd) {
+    for (var _i = 0, _a = Object.keys(tbd); _i < _a.length; _i++) {
+        var id = _a[_i];
+        var value = tbd[id];
+        var hasCorrectShape = value.fieldType && value.answer !== undefined;
+        if (!hasCorrectShape)
+            return false;
+    }
+    return true;
+}
+exports.determineIsFormFieldsV3 = determineIsFormFieldsV3;

package/dist/util/webhooks.js

@@ -1,12 +1,29 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasEpochExpired = exports.isSignatureHeaderValid = void 0;
 var url = __importStar(require("url"));
 var errors_1 = require("../errors");
 var signature_1 = require("./signature");
@@ -23,8 +40,8 @@ var isSignatureHeaderValid = function (uri, signatureHeader, publicKey) {
     if (!epoch || !signature || !submissionId || !formId) {
         throw new errors_1.WebhookAuthenticateError('X-FormSG-Signature header is invalid');
     }
-    var baseString = url.parse(uri).href + "." + submissionId + "." + formId + "." + epoch;
-    return signature_1.verify(baseString, signature, publicKey);
+    var baseString = "".concat(url.parse(uri).href, ".").concat(submissionId, ".").concat(formId, ".").concat(epoch);
+    return (0, signature_1.verify)(baseString, signature, publicKey);
 };
 exports.isSignatureHeaderValid = isSignatureHeaderValid;
 /**

package/dist/verification/index.js

@@ -33,27 +33,27 @@ var Verification = /** @class */ (function () {
                 throw new errors_1.MissingPublicKeyError();
             }
             try {
-                var _b = parser_1.parseVerificationSignature(signatureString), transactionId = _b.v, time = _b.t, formId = _b.f, signature = _b.s;
+                var _b = (0, parser_1.parseVerificationSignature)(signatureString), transactionId = _b.v, time = _b.t, formId = _b.f, signature = _b.s;
                 if (!time) {
                     throw new Error('Malformed signature string was passed into function');
                 }
-                if (utils_1.isSignatureTimeValid(time, submissionCreatedAt, _this.transactionExpiry)) {
-                    var data = utils_1.formatToBaseString({
+                if ((0, utils_1.isSignatureTimeValid)(time, submissionCreatedAt, _this.transactionExpiry)) {
+                    var data = (0, utils_1.formatToBaseString)({
                         transactionId: transactionId,
                         formId: formId,
                         fieldId: fieldId,
                         answer: answer,
                         time: time,
                     });
-                    return tweetnacl_1.default.sign.detached.verify(tweetnacl_util_1.decodeUTF8(data), tweetnacl_util_1.decodeBase64(signature), tweetnacl_util_1.decodeBase64(_this.verificationPublicKey));
+                    return tweetnacl_1.default.sign.detached.verify((0, tweetnacl_util_1.decodeUTF8)(data), (0, tweetnacl_util_1.decodeBase64)(signature), (0, tweetnacl_util_1.decodeBase64)(_this.verificationPublicKey));
                 }
                 else {
-                    console.info("Signature was expired for signatureString=\"" + signatureString + "\" signatureDate=\"" + time + "\" submissionCreatedAt=\"" + submissionCreatedAt + "\"");
+                    console.info("Signature was expired for signatureString=\"".concat(signatureString, "\" signatureDate=\"").concat(time, "\" submissionCreatedAt=\"").concat(submissionCreatedAt, "\""));
                     return false;
                 }
             }
             catch (error) {
-                console.error("An error occurred for             signatureString=\"" + signatureString + "\"             submissionCreatedAt=\"" + submissionCreatedAt + "\"             fieldId=\"" + fieldId + "\"             answer=\"" + answer + "\"             error=\"" + error + "\"");
+                console.error("An error occurred for             signatureString=\"".concat(signatureString, "\"             submissionCreatedAt=\"").concat(submissionCreatedAt, "\"             fieldId=\"").concat(fieldId, "\"             answer=\"").concat(answer, "\"             error=\"").concat(error, "\""));
                 return false;
             }
         };
@@ -63,15 +63,15 @@ var Verification = /** @class */ (function () {
                 throw new errors_1.MissingSecretKeyError('Provide a secret key when when initializing the Verification class to use this function.');
             }
             var time = Date.now();
-            var data = utils_1.formatToBaseString({
+            var data = (0, utils_1.formatToBaseString)({
                 transactionId: transactionId,
                 formId: formId,
                 fieldId: fieldId,
                 answer: answer,
                 time: time,
             });
-            var signature = tweetnacl_1.default.sign.detached(tweetnacl_util_1.decodeUTF8(data), tweetnacl_util_1.decodeBase64(_this.verificationSecretKey));
-            return "f=" + formId + ",v=" + transactionId + ",t=" + time + ",s=" + tweetnacl_util_1.encodeBase64(signature);
+            var signature = tweetnacl_1.default.sign.detached((0, tweetnacl_util_1.decodeUTF8)(data), (0, tweetnacl_util_1.decodeBase64)(_this.verificationSecretKey));
+            return "f=".concat(formId, ",v=").concat(transactionId, ",t=").concat(time, ",s=").concat((0, tweetnacl_util_1.encodeBase64)(signature));
         };
         this.verificationPublicKey = params === null || params === void 0 ? void 0 : params.publicKey;
         this.verificationSecretKey = params === null || params === void 0 ? void 0 : params.secretKey;

package/dist/verification/utils.js

@@ -1,20 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToBaseString = exports.isSignatureTimeValid = void 0;
 /**
  * Checks if signature was made within the given expiry range before
  * submission was created.
  * @param signatureTime ms
  * @param submissionCreatedAt ms
  */
-exports.isSignatureTimeValid = function (signatureTime, submissionCreatedAt, transactionExpiry) {
+var isSignatureTimeValid = function (signatureTime, submissionCreatedAt, transactionExpiry) {
     var maxTime = submissionCreatedAt;
     var minTime = maxTime - transactionExpiry * 1000;
     return signatureTime > minTime && signatureTime < maxTime;
 };
+exports.isSignatureTimeValid = isSignatureTimeValid;
 /**
  * Formats given data into a string for signing
  */
-exports.formatToBaseString = function (_a) {
+var formatToBaseString = function (_a) {
     var transactionId = _a.transactionId, formId = _a.formId, fieldId = _a.fieldId, answer = _a.answer, time = _a.time;
-    return transactionId + "." + formId + "." + fieldId + "." + answer + "." + time;
+    return "".concat(transactionId, ".").concat(formId, ".").concat(fieldId, ".").concat(answer, ".").concat(time);
 };
+exports.formatToBaseString = formatToBaseString;