@getstep/sdk 0.0.1-security → 982.649.0

package/dist/http/AppMetadata.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AppMetadata.js.map

package/dist/http/AxiosFactory.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAxios = void 0;
+const axios_1 = __importDefault(require("axios"));
+const uuid_1 = require("uuid");
+const util_1 = require("../util");
+const HttpError_1 = require("./HttpError");
+const TRACE_ID_HEADER = 'X-Cloud-Trace-Context';
+function createAxios({ baseURL, withCredentials, timeout = 30000, }) {
+    const instance = axios_1.default.create({
+        baseURL,
+        withCredentials,
+        timeout,
+    });
+    instance.interceptors.request.use(requestInterceptor, errorInterceptor);
+    instance.interceptors.response.use(responseInterceptor, errorInterceptor);
+    return instance;
+}
+exports.createAxios = createAxios;
+const requestInterceptor = (request) => {
+    if (!request.headers[TRACE_ID_HEADER]) {
+        // Google libs expect trace header to be in the trace_id/trace_span form.
+        // trace_id must be 32 chars, hex.
+        const traceId = uuid_1.v4().replace(/-/g, '').substring(0, 32);
+        const spanId = 0;
+        request.headers[TRACE_ID_HEADER] = `${traceId}/${spanId}`;
+    }
+    const url = request.url;
+    const method = request.method;
+    const body = request.data ? `\n${JSON.stringify(request.data)}` : '';
+    const tid = request.headers[TRACE_ID_HEADER];
+    console.debug(`REQ(${tid}): ${method}: ${url}${body}`);
+    return request;
+};
+const responseInterceptor = async (response) => {
+    const url = response.config.url;
+    const method = response.config.method;
+    const tid = response.config.headers[TRACE_ID_HEADER];
+    console.debug(`RES(${tid}): ${method}: ${url}\n${JSON.stringify(response.data)}`);
+    // TODO (notrly): remove ChaosDelay when bug is fixed: https://trello.com/c/4G2nWYuS
+    return await util_1.Chaos.generate(tid, () => response);
+};
+const errorInterceptor = async (error) => {
+    if (HttpError_1.isAxiosError(error)) {
+        const url = error.config.url;
+        const method = error.config.method;
+        const tid = error.config.headers[TRACE_ID_HEADER];
+        const httpError = new HttpError_1.HttpError(error);
+        console.debug(`>> ${method} ERROR(${tid}): ${url}`, httpError);
+        throw httpError;
+    }
+    console.debug(`>> ERROR: failed to reach destination`, error);
+    throw error;
+};
+//# sourceMappingURL=AxiosFactory.js.map

package/dist/http/DataUri.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataUri = void 0;
+class DataUri {
+    /**
+     * Encode binary data using data uri scheme, see https://en.wikipedia.org/wiki/Data_URI_scheme
+     *
+     * @param mediaType the content media type, see https://en.wikipedia.org/wiki/Media_type
+     * @param data the image data as base64 string
+     */
+    constructor(mediaType, data) {
+        this.mediaType = mediaType;
+        this.data = data;
+    }
+    static decode(encoded) {
+        const matches = encoded.match(this.regex);
+        if ((matches === null || matches === void 0 ? void 0 : matches.length) !== 3) {
+            throw new Error('invalid data uri');
+        }
+        return new DataUri(matches[1], matches[2]);
+    }
+    encode() {
+        return `data:${this.mediaType};base64,${this.data}`;
+    }
+}
+exports.DataUri = DataUri;
+DataUri.regex = /^data:(.+);base64,(.+)$/;
+//# sourceMappingURL=DataUri.js.map

package/dist/http/HttpClient.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const generated_1 = require("../api/generated");
+const AxiosFactory_1 = require("./AxiosFactory");
+const APP_VERSION_HEADER = 'Step-App-Version';
+const BUNDLE_ID_HEADER = 'Step-Bundle-Id';
+const SDK_VERSION_HEADER = 'Step-SDK-Version';
+class HttpClient {
+    constructor(config) {
+        const { baseURL, withCredentials, headers = {}, metadata, basePathResolver, } = config;
+        // Delay require of package.json until runtime. Otherwise TS will pull in package.json and
+        // the entire src folder into dist which breaks existing imports.
+        this.sdkVersion = require('../../package.json').version;
+        this.baseURL = baseURL;
+        this.headers = headers;
+        this.metadata = metadata;
+        this.basePathResolver = basePathResolver;
+        this.axios = AxiosFactory_1.createAxios({
+            baseURL,
+            withCredentials,
+            timeout: 30000,
+        });
+    }
+    async execute(action, options = {}) {
+        const response = await action(new generated_1.DefaultApi({
+            configuration: {
+                basePath: this.axios.defaults.baseURL,
+                baseOptions: this.config(options),
+            },
+            basePathResolver: this.basePathResolver,
+            axios: this.axios,
+        }));
+        return response.data;
+    }
+    config(options) {
+        const { authToken, headers: headersFromOptions = {} } = options;
+        const { platform, appVersion, bundleId } = this.metadata;
+        const headers = Object.assign(Object.assign({}, this.headers), headersFromOptions);
+        headers[APP_VERSION_HEADER] = `${platform}/${appVersion}`;
+        headers[BUNDLE_ID_HEADER] = bundleId;
+        headers[SDK_VERSION_HEADER] = this.sdkVersion;
+        if (authToken) {
+            headers.Authorization = `Bearer ${authToken.value}`;
+        }
+        return { headers };
+    }
+}
+exports.HttpClient = HttpClient;
+//# sourceMappingURL=HttpClient.js.map

package/dist/http/HttpError.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttpError = exports.isAxiosError = exports.HttpError = exports.ErrorCode = exports.ErrorStatus = void 0;
+/**
+ * A parsed status code. Corresponds to gRPC Status Code.
+ */
+var ErrorStatus;
+(function (ErrorStatus) {
+    ErrorStatus["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
+    ErrorStatus["FAILED_PRECONDITION"] = "FAILED_PRECONDITION";
+    ErrorStatus["OUT_OF_RANGE"] = "OUT_OF_RANGE";
+    ErrorStatus["UNAUTHENTICATED"] = "UNAUTHENTICATED";
+    ErrorStatus["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+    ErrorStatus["NOT_FOUND"] = "NOT_FOUND";
+    ErrorStatus["ALREADY_EXISTS"] = "ALREADY_EXISTS";
+    ErrorStatus["RESOURCE_EXHAUSTED"] = "RESOURCE_EXHAUSTED";
+    ErrorStatus["INTERNAL"] = "INTERNAL";
+    ErrorStatus["UNIMPLEMENTED"] = "UNIMPLEMENTED";
+    ErrorStatus["UNAVAILABLE"] = "UNAVAILABLE";
+    ErrorStatus["DEADLINE_EXCEEDED"] = "DEADLINE_EXCEEDED";
+    ErrorStatus["UNKNOWN"] = "UNKNOWN";
+    ErrorStatus["NETWORK_ERROR"] = "NETWORK_ERROR";
+})(ErrorStatus = exports.ErrorStatus || (exports.ErrorStatus = {}));
+/**
+ * Step specific error codes that we optionally provide back to the client.
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["UNKNOWN"] = "UNKNOWN";
+    // Account Error Codes
+    ErrorCode["ACCOUNT_NOT_SUPPORTED"] = "ACCOUNT_NOT_SUPPORTED";
+    ErrorCode["AVS_NOT_MATCHED"] = "AVS_NOT_MATCHED";
+    ErrorCode["CARD_DECLINED"] = "CARD_DECLINED";
+    ErrorCode["CARD_EXPIRATION_INVALID"] = "CARD_EXPIRATION_INVALID";
+    ErrorCode["CARD_EXPIRED"] = "CARD_EXPIRED";
+    ErrorCode["CARD_NUMBER_INVALID"] = "CARD_NUMBER_INVALID";
+    ErrorCode["CHARGE_UNDER_REVIEW"] = "CHARGE_UNDER_REVIEW";
+    ErrorCode["CVV_REQUIRED"] = "CVV_REQUIRED";
+    ErrorCode["CVV_NOT_MATCHED"] = "CVV_NOT_MATCHED";
+    ErrorCode["INVALID_CARD_TYPE"] = "INVALID_CARD_TYPE";
+    ErrorCode["INSTITUTION_NOT_RESPONDING"] = "INSTITUTION_NOT_RESPONDING";
+    ErrorCode["STEP_LINKING_UNSUPPORTED"] = "STEP_LINKING_UNSUPPORTED";
+    ErrorCode["UNSUPPORTED_CARD"] = "UNSUPPORTED_CARD";
+    // Auth Error Codes
+    ErrorCode["ACCOUNT_DISABLED"] = "ACCOUNT_DISABLED";
+    ErrorCode["ACCOUNT_SUSPENDED"] = "ACCOUNT_SUSPENDED";
+    ErrorCode["VERIFIED_PHONE_REQUIRED"] = "VERIFIED_PHONE_REQUIRED";
+    ErrorCode["VERIFIED_EMAIL_REQUIRED"] = "VERIFIED_EMAIL_REQUIRED";
+    ErrorCode["INSUFFICIENT_PERMISSIONS"] = "INSUFFICIENT_PERMISSIONS";
+    ErrorCode["MEMBERSHIP_REQUIRED"] = "MEMBERSHIP_REQUIRED";
+    ErrorCode["INVALID_OIDC_TOKEN"] = "INVALID_OIDC_TOKEN";
+    ErrorCode["INVALID_OIDC_DOMAIN"] = "INVALID_OIDC_DOMAIN";
+    ErrorCode["INVALID_IAP_TOKEN"] = "INVALID_IAP_TOKEN";
+    ErrorCode["INVALID_IAP_DOMAIN"] = "INVALID_IAP_DOMAIN";
+    ErrorCode["INVALID_IAP_AUDIENCE"] = "INVALID_IAP_AUDIENCE";
+    ErrorCode["RATE_LIMITED"] = "RATE_LIMITED";
+    ErrorCode["USER_NOT_FOUND"] = "USER_NOT_FOUND";
+    ErrorCode["INVALID_ISSUER"] = "INVALID_ISSUER";
+    ErrorCode["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+    ErrorCode["KEY_NOT_FOUND"] = "KEY_NOT_FOUND";
+    ErrorCode["UNSUPPORTED_ALGORITHM"] = "UNSUPPORTED_ALGORITHM";
+    ErrorCode["INVALID_SIGNATURE"] = "INVALID_SIGNATURE";
+    ErrorCode["ALGORITHM_MISMATCH"] = "ALGORITHM_MISMATCH";
+    ErrorCode["INVALID_TOKEN"] = "INVALID_TOKEN";
+    ErrorCode["TOKEN_REQUIRED"] = "TOKEN_REQUIRED";
+    ErrorCode["PROFILE_NOT_FOUND"] = "PROFILE_NOT_FOUND";
+    ErrorCode["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+    ErrorCode["DEVICE_BLOCKED"] = "DEVICE_BLOCKED";
+    ErrorCode["ACCOUNT_CLOSED"] = "ACCOUNT_CLOSED";
+    ErrorCode["KEY_PASSWORD_INVALID"] = "KEY_PASSWORD_INVALID";
+    ErrorCode["KEY_TOO_MANY_PASSWORD_ATTEMPTS"] = "KEY_TOO_MANY_PASSWORD_ATTEMPTS";
+    // Ledger Error Codes
+    ErrorCode["EXCEEDS_ACCOUNT_LIMIT"] = "EXCEEDS_ACCOUNT_LIMIT";
+    ErrorCode["EXCEEDS_AMOUNT_LIMIT"] = "EXCEEDS_AMOUNT_LIMIT";
+    ErrorCode["EXCEEDS_COUNT_LIMIT"] = "EXCEEDS_COUNT_LIMIT";
+    ErrorCode["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+    // Referral Error Codes
+    ErrorCode["FAILED_TO_ISSUE_REWARD"] = "FAILED_TO_ISSUE_REWARD";
+    ErrorCode["REDEMPTION_LIMIT_REACHED"] = "REDEMPTION_LIMIT_REACHED";
+    ErrorCode["SELF_REFERRAL_DISALLOWED"] = "SELF_REFERRAL_DISALLOWED";
+    ErrorCode["INVALID_REFERRAL"] = "INVALID_REFERRAL";
+    ErrorCode["ALREADY_REFERRED"] = "ALREADY_REFERRED";
+    ErrorCode["REFERRAL_CODES_DEPLETED"] = "REFERRAL_CODES_DEPLETED";
+    ErrorCode["ALREADY_REDEEMED_CODE"] = "ALREADY_REDEEMED_CODE";
+    ErrorCode["REFERRER_SUSPENDED"] = "REFERRER_SUSPENDED";
+    ErrorCode["REWARD_WINDOW_EXPIRED"] = "REWARD_WINDOW_EXPIRED";
+    ErrorCode["NOT_ONBOARDED"] = "NOT_ONBOARDED";
+    ErrorCode["VOIP_REDEMPTION_UNSUPPORTED"] = "VOIP_REDEMPTION_UNSUPPORTED";
+    // Referral Migration Error Codes
+    ErrorCode["USER_MIGRATED_TO_CORE_APP"] = "USER_MIGRATED_TO_CORE_APP";
+    ErrorCode["CODE_MIGRATED_TO_CORE_APP"] = "CODE_MIGRATED_TO_CORE_APP";
+    ErrorCode["USER_NOT_MIGRATED_TO_CORE_APP"] = "USER_NOT_MIGRATED_TO_CORE_APP";
+    // User Error Codes
+    ErrorCode["DOB_REQUIRED"] = "DOB_REQUIRED";
+    ErrorCode["FIRST_NAME_REQUIRED"] = "FIRST_NAME_REQUIRED";
+    ErrorCode["LAST_NAME_REQUIRED"] = "LAST_NAME_REQUIRED";
+    ErrorCode["SSN_REQUIRED"] = "SSN_REQUIRED";
+    ErrorCode["AGE_GATED"] = "AGE_GATED";
+    ErrorCode["INVALID_DOB"] = "INVALID_DOB";
+    ErrorCode["INVALID_SSN"] = "INVALID_SSN";
+    // ATM PIN Verification Error Codes
+    ErrorCode["OPTED_OUT_PHONE_NUMBER"] = "OPTED_OUT_PHONE_NUMBER";
+    ErrorCode["VERIFICATION_METHOD_RECENTLY_MODIFIED"] = "VERIFICATION_METHOD_RECENTLY_MODIFIED";
+    ErrorCode["VERIFICATION_ATTEMPTS_EXCEEDED"] = "VERIFICATION_ATTEMPTS_EXCEEDED";
+    // Other
+    ErrorCode["DISALLOWED_TERM"] = "DISALLOWED_TERM";
+    ErrorCode["REQUEST_TIMED_OUT"] = "REQUEST_TIMED_OUT";
+    ErrorCode["INVALID_SDK_VERSION"] = "INVALID_SDK_VERSION";
+    ErrorCode["QUOTA_EXCEEDED"] = "QUOTA_EXCEEDED";
+    // Address verification error codes
+    ErrorCode["ADDRESS_INVALID"] = "ADDRESS_INVALID";
+    ErrorCode["ADDRESS_MISSING_PRIMARY_NUMBER"] = "ADDRESS_MISSING_PRIMARY_NUMBER";
+    ErrorCode["ADDRESS_MISSING_SECONDARY_INFO"] = "ADDRESS_MISSING_SECONDARY_INFO";
+    ErrorCode["ADDRESS_INVALID_SECONDARY_INFO"] = "ADDRESS_INVALID_SECONDARY_INFO";
+    ErrorCode["ADDRESS_ZIP_POBOX_DELIVERY_ONLY"] = "ADDRESS_ZIP_POBOX_DELIVERY_ONLY";
+    // Phone verification error codes
+    ErrorCode["PHONE_UNSUPPORTED_CARRIER_TYPE"] = "PHONE_UNSUPPORTED_CARRIER_TYPE";
+    ErrorCode["PHONE_SWITCH_TO_VOIP_UNSUPPORTED"] = "PHONE_SWITCH_TO_VOIP_UNSUPPORTED";
+    // Issuing error codes
+    ErrorCode["TOO_MANY_OPEN_DISPUTES"] = "TOO_MANY_OPEN_DISPUTES";
+    ErrorCode["HIGH_OPEN_DISPUTE_RATE"] = "HIGH_OPEN_DISPUTE_RATE";
+    ErrorCode["TRANSACTION_TOO_RECENT"] = "TRANSACTION_TOO_RECENT";
+})(ErrorCode = exports.ErrorCode || (exports.ErrorCode = {}));
+/**
+ * Parsed out HTTP error generated by a Step service. Includes additional fields
+ * aside from regular HTTP stuff to help us present, debug and troubleshoot the
+ * problem.
+ */
+class HttpError extends Error {
+    constructor(cause) {
+        var _a, _b, _c, _d, _e;
+        super((_b = (_a = cause.response) === null || _a === void 0 ? void 0 : _a.statusText) !== null && _b !== void 0 ? _b : cause.message);
+        this.cause = cause;
+        const response = cause.response;
+        this.statusCode = (_c = response === null || response === void 0 ? void 0 : response.status) !== null && _c !== void 0 ? _c : 0;
+        if (response === null || response === void 0 ? void 0 : response.data) {
+            const { status, code, description } = response.data;
+            this.status = (_d = status) !== null && _d !== void 0 ? _d : ErrorStatus.UNKNOWN;
+            this.code = (_e = code) !== null && _e !== void 0 ? _e : ErrorCode.UNKNOWN;
+            this.description = description;
+        }
+        else if (isNetworkError(cause)) {
+            this.status = ErrorStatus.NETWORK_ERROR;
+            this.code = ErrorCode.REQUEST_TIMED_OUT;
+            this.description = cause.toString();
+        }
+        else {
+            this.status = ErrorStatus.UNKNOWN;
+            this.code = ErrorCode.UNKNOWN;
+            this.description = cause.toString();
+        }
+        this.errorId = response === null || response === void 0 ? void 0 : response.headers['error-id'];
+        this.message = this.toString();
+        this.userFriendlyDescription = userFriendlyDescription(this);
+    }
+    toString() {
+        return ('' +
+            `${this.statusCode} (${this.status}:${this.code}:${this.errorId}): ` +
+            `${this.description}`);
+    }
+}
+exports.HttpError = HttpError;
+function isNetworkError(error) {
+    return (error.message === 'Network Error' ||
+        (error.response && error.response.status === 408) ||
+        error.code === 'ECONNABORTED');
+}
+function isAxiosError(error) {
+    const axios = error;
+    return isAxiosResponse(axios.response) || axios.code !== undefined;
+}
+exports.isAxiosError = isAxiosError;
+function isAxiosResponse(response) {
+    const axios = response;
+    return (axios === null || axios === void 0 ? void 0 : axios.status) !== undefined && (axios === null || axios === void 0 ? void 0 : axios.request) != undefined;
+}
+function userFriendlyDescription(error) {
+    switch (error.code) {
+        case ErrorCode.FAILED_TO_ISSUE_REWARD:
+            return ("Oops, something went wrong while trying to send your reward, don't worry! " +
+                "We're aware of the issue and will let you know as soon as it's resolved.");
+        case ErrorCode.REDEMPTION_LIMIT_REACHED:
+        case ErrorCode.INVALID_REFERRAL:
+            return ("We're sorry, seems like that code is no longer valid. You can always try and use a " +
+                'different code, ask one of your friends!');
+        case ErrorCode.SELF_REFERRAL_DISALLOWED:
+            return "We're sorry, but you can't redeem your own code. Try a code from one of your friends!";
+        case ErrorCode.ALREADY_REFERRED:
+            return "We're sorry, but you've already redeemed a code. Keep on sharing your code to earn more!";
+        case ErrorCode.REFERRAL_CODES_DEPLETED:
+            return "Oops, seems like we're run out of codes. Try again in a little while.";
+        case ErrorCode.DOB_REQUIRED:
+            return ("Oops, seems like you haven't provided us with your date of birth yet, " +
+                "we're gonna need that before we can continue.");
+        case ErrorCode.ALREADY_REDEEMED_CODE:
+            return ("We're sorry, but you've already redeemed this referral code. " +
+                'Keep sharing your code to earn more!');
+    }
+    switch (error.status) {
+        case ErrorStatus.DEADLINE_EXCEEDED:
+            return 'Request timed out. Please try again later.';
+        case ErrorStatus.RESOURCE_EXHAUSTED:
+            return 'Too many attempts. Try again later.';
+        case ErrorStatus.NETWORK_ERROR:
+            return ("Oh! Seems like we're having some network problems, " +
+                'please check your internet connection and try again...');
+    }
+    return 'Oops, something went wrong, try again.';
+}
+/**
+ * Checks if the error is an HTTP error with the given code and status.
+ * @param error The error to check.
+ * @param opts Options to narrow down the type refinement.
+ * @examples
+ * ```ts
+ * const isResourceExhaustedError = isHttpError(error, {
+ *     status: ErrorStatus.RESOURCE_EXHAUSTED,
+ * })
+ *
+ * const isAlreadyExistsError = isHttpError(error, {
+ *    status: ErrorStatus.ALREADY_EXISTS,
+ * })
+ *
+ * const isUnauthenticatedError = isHttpError(error, {
+ *    status: ErrorStatus.UNAUTHENTICATED,
+ * })
+ *
+ * const isInvalidDobError = isHttpError(error, {
+ *    code: ErrorCode.INVALID_DOB,
+ *    status: ErrorStatus.UNAUTHENTICATED,
+ * })
+ * ```
+ *
+ */
+function isHttpError(error, opts) {
+    if (!(error instanceof HttpError))
+        return false;
+    if (!opts)
+        return true;
+    for (const key of ['code', 'status']) {
+        if (key in opts && error[key] !== opts[key])
+            return false;
+    }
+    return true;
+}
+exports.isHttpError = isHttpError;
+//# sourceMappingURL=HttpError.js.map

package/dist/http/PublicApi.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicApi = void 0;
+/**
+ * Api calls that do not require authentication
+ */
+class PublicApi {
+    constructor(client) {
+        this.client = client;
+    }
+    async getReferralInfo(code) {
+        const info = await this.client.execute((api) => api.referralServiceReferralInfo(code));
+        return this.withPromo(code, info);
+    }
+    /**
+     * Looks up public profile for a given username.
+     * Profile should be created and made public, or 404/403 errors will be thrown,
+     * @param username The username to look up
+     */
+    async getPublicProfile(username) {
+        const { profile } = await this.client.execute((api) => api.profileServiceLookupProfile({ alias: { username } }));
+        return profile;
+    }
+    withPromo(code, info) {
+        // do a manual check to see if it's a step code
+        const isPromo = code.toUpperCase().startsWith('STEP') ||
+            code.toUpperCase().startsWith('SNAP');
+        return Object.assign({ isPromo }, info);
+    }
+}
+exports.PublicApi = PublicApi;
+//# sourceMappingURL=PublicApi.js.map

package/dist/http/StripeHttpClient.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripeHttpClient = void 0;
+const qs_1 = __importDefault(require("qs"));
+const AxiosFactory_1 = require("./AxiosFactory");
+/**
+ * Wrapper for Stripe HTTP API
+ */
+class StripeHttpClient {
+    constructor(appMetadata) {
+        this.appMetadata = appMetadata;
+        this.API_VERSION = '2020-03-02';
+        this.BASE_URL = 'https://api.stripe.com/v1';
+        this.axios = AxiosFactory_1.createAxios({
+            baseURL: this.BASE_URL,
+            timeout: 30000,
+        });
+    }
+    /**
+     * Performs GET request against Stripe HTTP API.
+     * @param authKey secret key to use in `Authorization: Bearer xxx` header.
+     * @param query query params, will be stringified, urlencoded, and appended to the path. Metadata will also be added.
+     */
+    get(path, authKey, query) {
+        const queryString = query ? `?${qs_1.default.stringify(query)}` : '';
+        return this.request('GET', path + queryString, authKey);
+    }
+    /**
+     * Performs POST request against Stripe HTTP API.
+     * @param authKey secret key to use in `Authorization: Bearer xxx` header.
+     * @param data POST body, will be stringified and urlencoded.
+     */
+    post(path, authKey, data) {
+        return this.request('POST', path, authKey, qs_1.default.stringify(data));
+    }
+    get headers() {
+        const { appVersion, bundleId, platform } = this.appMetadata;
+        return {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Step-App-Version': appVersion,
+            'Step-Bundle-Id': bundleId,
+            'Step-Platform': platform,
+            'Stripe-Version': this.API_VERSION,
+        };
+    }
+    async request(method, url, authKey, data) {
+        return this.axios.request({
+            method,
+            url,
+            data,
+            headers: Object.assign(Object.assign({}, this.headers), { Authorization: `Bearer ${authKey}` }),
+        });
+    }
+}
+exports.StripeHttpClient = StripeHttpClient;
+//# sourceMappingURL=StripeHttpClient.js.map

package/dist/http/TestApi.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestApi = void 0;
+const Date_1 = require("../util/Date");
+const HttpClient_1 = require("./HttpClient");
+const AuthToken_1 = require("./models/AuthToken");
+class TestApi {
+    constructor(config) {
+        this.client = new HttpClient_1.HttpClient(config);
+    }
+    async startVirtualAccountSimulation(transfers) {
+        const res = await this.client.execute((api) => api.testApiServiceCreateVirtualAccountSimulation({ transfers }));
+        return res.state;
+    }
+    async getVirtualAccountSimulationState(state) {
+        const res = await this.client.execute((api) => api.testApiServiceGetVirtualAccountStatus(state));
+        return res.complete ? res.rejectedTransfers : undefined;
+    }
+    async enableFeature(feature, userId) {
+        await this.client.execute((api) => api.testApiServiceEnableFeature({ feature, userId }));
+    }
+    async loadFunds(amount, accountId) {
+        await this.client.execute((api) => api.testApiServiceLoadFunds(accountId, { amount }));
+    }
+    async reverseCardFundingTransaction(userId, fundingSourceId, externalTransactionId) {
+        await this.client.execute((api) => api.testApiServiceReverseFundingTransaction(externalTransactionId, {
+            fundingSourceId,
+            userId,
+        }));
+    }
+    async authorize(cardId, amount, paymentId, supportsPartial = false, context, controlCategory) {
+        const res = await this.client.execute((api) => api.testApiServiceSimulateAuthorization(cardId, {
+            amount,
+            context,
+            paymentId,
+            supportsPartial,
+            controlCategory,
+        }));
+        return res.paymentId;
+    }
+    async capture(cardId, paymentId, amount, controlCategory) {
+        const res = await this.client.execute((api) => api.testApiServiceSimulateCapture(paymentId, {
+            amount,
+            cardId,
+            controlCategory,
+        }));
+        return res.captureId;
+    }
+    async forceCapture(cardId, amount, context, controlCategory) {
+        const res = await this.client.execute((api) => api.testApiServiceSimulateForceCapture(cardId, {
+            amount,
+            context,
+            controlCategory,
+        }));
+        return res.paymentId;
+    }
+    async reverse(cardId, paymentId, amount, controlCategory) {
+        const res = await this.client.execute((api) => api.testApiServiceSimulateReversal(paymentId, {
+            amount,
+            cardId,
+            controlCategory,
+        }));
+        return res.reverseId;
+    }
+    async refund(cardId, paymentId, amount, controlCategory) {
+        const res = await this.client.execute((api) => api.testApiServiceSimulateRefund(paymentId, {
+            amount,
+            cardId,
+            controlCategory,
+        }));
+        return res.refundId;
+    }
+    async forceRefund(cardId, amount, context, controlCategory) {
+        const res = await this.client.execute((api) => api.testApiServiceSimulateForceRefund(cardId, {
+            amount,
+            context,
+            controlCategory,
+        }));
+        return res.paymentId;
+    }
+    async closeFundingDispute(provider, externalTransactionId, disputeWon) {
+        await this.client.execute((api) => api.testApiServiceCloseFundingDispute(externalTransactionId, {
+            disputeWon,
+            provider,
+        }));
+    }
+    async suspendUser(userId) {
+        await this.client.execute((api) => api.testApiServiceSuspendUser(userId));
+    }
+    async updateTransaction(paymentId, transactionId, status) {
+        await this.client.execute((api) => api.testApiServiceUpdateTransaction({
+            paymentId,
+            transactionId,
+            status,
+        }));
+    }
+    async adminLogin(groups, ttl) {
+        const result = await this.client.execute((api) => api.testApiServiceLogin({
+            groups,
+            ttlMs: ttl && `${Date_1.durationAsMilliseconds(ttl)}`,
+        }));
+        return {
+            userId: result.userId,
+            accessToken: AuthToken_1.AuthToken.parse(result.accessToken.value),
+            refreshToken: AuthToken_1.AuthToken.parse(result.refreshToken.value),
+        };
+    }
+    async unlinkSandboxPlaidAccount(userId, externalAccountId) {
+        await this.client.execute((api) => api.testApiServiceUnlinkSandboxPlaidAccount({
+            userId,
+            externalAccountId,
+        }));
+    }
+    async cashDeposit(barcode, amount) {
+        await this.client.execute((api) => api.cashDepositSimulationServiceSimulateCashDeposit({
+            barcode,
+            amount,
+        }));
+    }
+    async cashDepositReversal(barcode, amount) {
+        await this.client.execute((api) => api.cashDepositSimulationServiceReverseCashDeposit({
+            barcode,
+            amount,
+        }));
+    }
+    async setupTestUsers(users) {
+        const result = await this.client.execute((api) => api.userSetupServiceCreateUsers({
+            users,
+        }));
+        return result.users;
+    }
+    async unlinkAlias(alias) {
+        await this.client.execute((api) => api.testApiServiceUnlinkAlias({
+            alias,
+        }));
+    }
+}
+exports.TestApi = TestApi;
+//# sourceMappingURL=TestApi.js.map

package/dist/http/auth/AccessTokenProvider.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_AUTH_TOKEN_TTL_MS = exports.STRONG_AUTH_TOKEN_TTL_MS = exports.REFRESH_TOKEN_TTL_MS = void 0;
+// DO NOT CHANGE THIS! Unless first checking with krisan@step.com.
+// This has been set to expire after 24 hours for security
+exports.REFRESH_TOKEN_TTL_MS = 24 * 60 * 60 * 1000; // 1 day
+exports.STRONG_AUTH_TOKEN_TTL_MS = 5 * 60 * 1000; // 5 min
+// Used when creating refresh tokens that do not need to live for a long time, normal authentication session
+exports.SESSION_AUTH_TOKEN_TTL_MS = 60 * 60 * 1000; // 1 hour
+//# sourceMappingURL=AccessTokenProvider.js.map