web3-banking-system-sdk 1.0.0

package/dist/helper/storage/localStorageHelper.js

@@ -0,0 +1,108 @@
+class LocalStorageHelper {
+    // #region "Properties"
+    get Count() {
+        return localStorage.length;
+    }
+    cookiesHelper;
+    cipherHelper;
+    errorHandler;
+    // #endregion
+    // #region "Constructor"
+    constructor(cookiesHelper, cipherHelper, errorHandler) {
+        this.errorHandler = errorHandler;
+        this.cookiesHelper = cookiesHelper;
+        this.cipherHelper = cipherHelper;
+    }
+    // #endregion
+    // #region "User Data"
+    async getUserData() {
+        try {
+            const IID = await this.cookiesHelper.getIID();
+            if (!IID)
+                return null;
+            const { key, iv } = this.cipherHelper.generateByInstallationID(IID);
+            const userData = this.get("CUD");
+            if (userData) {
+                const decryptedUserData = this.cipherHelper.decrypt(userData, key, iv);
+                if (decryptedUserData) {
+                    return JSON.parse(decryptedUserData);
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return null;
+        }
+    }
+    async setUserData(userData) {
+        try {
+            const IID = await this.cookiesHelper.getIID();
+            if (!IID)
+                return;
+            const { key, iv } = this.cipherHelper.generateByInstallationID(IID);
+            const data = JSON.stringify(userData);
+            const encryptedUserData = this.cipherHelper.encrypt(data, key, iv);
+            if (encryptedUserData) {
+                this.set("CUD", encryptedUserData);
+            }
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return null;
+        }
+    }
+    // #endregion
+    // #region "Methods"
+    get(key) {
+        try {
+            return localStorage.getItem(key);
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return null;
+        }
+    }
+    set(key, value) {
+        try {
+            localStorage.setItem(key, value);
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return null;
+        }
+    }
+    remove(key) {
+        try {
+            localStorage.removeItem(key);
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return null;
+        }
+    }
+    clear() {
+        localStorage.clear();
+    }
+    // #endregion
+    // #region "Utils"
+    setLocalStorageByUserData(data) {
+        if (data.preferences?.preferred_language_code) {
+            this.set("lang", data.preferences.preferred_language_code);
+        }
+    }
+    removeLocalStorageOnSignup() {
+        this.remove("promoCode");
+        this.remove("promotionData");
+        this.remove("referralCode");
+    }
+    removeLocalStorageOnLogout() {
+        this.remove("CUD");
+    }
+    clearLocalStorage() {
+        this.remove("CUD");
+        this.remove("currency");
+        this.remove("prefixCurrency");
+    }
+}
+export { LocalStorageHelper };

package/dist/helper/storage/storageHelper.d.ts

@@ -0,0 +1,13 @@
+import { CipherHelper } from "../cipherHelper";
+import { CookiesHelper } from "./cookiesHelper";
+import { LocalStorageHelper } from "./localStorageHelper";
+declare class StorageHelper {
+    cipherHelper: CipherHelper;
+    cookiesHelper: CookiesHelper;
+    localStorageHelper: LocalStorageHelper;
+    errorHandler: (error: any) => void;
+    constructor(programId: string, domain: string, errorHandler: (error: any) => void);
+    getCookiesHelper(): CookiesHelper;
+    getLocalStorageHelper(): LocalStorageHelper;
+}
+export { StorageHelper };

package/dist/helper/storage/storageHelper.js

@@ -0,0 +1,26 @@
+import { CipherHelper } from "../cipherHelper";
+import { CookiesHelper } from "./cookiesHelper";
+import { LocalStorageHelper } from "./localStorageHelper";
+class StorageHelper {
+    // #region "Properties"
+    cipherHelper;
+    cookiesHelper;
+    localStorageHelper;
+    errorHandler;
+    // #endregion
+    // #region "Constructor"
+    constructor(programId, domain, errorHandler) {
+        this.errorHandler = errorHandler;
+        this.cookiesHelper = new CookiesHelper(programId, domain, this.errorHandler);
+        this.cipherHelper = new CipherHelper(this.errorHandler);
+        this.localStorageHelper = new LocalStorageHelper(this.cookiesHelper, this.cipherHelper, this.errorHandler);
+    }
+    // #endregion
+    getCookiesHelper() {
+        return this.cookiesHelper;
+    }
+    getLocalStorageHelper() {
+        return this.localStorageHelper;
+    }
+}
+export { StorageHelper };

package/dist/helper/userHelper.d.ts

@@ -0,0 +1,47 @@
+import { Entity, EntityData } from "../constant";
+import type { TModifyListByEntity, TModifyByDocumentData, TSortByID, TSortByIsPrimary, TSortByVerificationStatus, TSortEntity, TModifyOrganizationByDocumentData, TModifyOrganizationList, TModifyProfilePicture, TModifySecurityResetUserSecurity, VerifySecurityData, UserData, ICreateUserData, PromotionCustomField, TicketData } from "../types";
+declare class UserHelper {
+    static modifyListByEntity: TModifyListByEntity;
+    static modifyByDocumentData: TModifyByDocumentData;
+    static modifyOrganizationByDocumentData: TModifyOrganizationByDocumentData;
+    static modifyOrganizationList: TModifyOrganizationList;
+    static modifyProfilePicture: TModifyProfilePicture;
+    static modifySecurityByResetUserSecurity: TModifySecurityResetUserSecurity;
+    static sortEntity: TSortEntity;
+    static sortByIsPrimary: TSortByIsPrimary;
+    static sortByVerificationStatus: TSortByVerificationStatus;
+    static sortById: TSortByID;
+    static extractDeviceData: (data: UserData | VerifySecurityData) => import("..").Device;
+    static fillUserDataByEntity(entity: Entity, entityData: EntityData, data: any, id: number): UserData;
+    /**
+     * Adds a newly created ticket to the user-level ticket list, and to the entity
+     * its sub-entity points at when it has one. Applying the same ticket twice
+     * leaves a single copy of it.
+     *
+     * Mutates `userData` in place, so it may be called on a draft inside a
+     * reducer.
+     */
+    static addTicket(userData: UserData, ticket: TicketData): void;
+    /**
+     * Applies an updated ticket to the user-level ticket list, and to the entity
+     * its sub-entity points at when it has one. Unlike `addTicket`, both lists are
+     * only updated in place — a ticket that is not already there is never
+     * appended.
+     *
+     * Mutates `userData` in place, so it may be called on a draft inside a
+     * reducer.
+     */
+    static modifyTicket(userData: UserData, ticket: TicketData): void;
+    /**
+     * Takes a ticket off the user-level ticket list, and off the entity its
+     * sub-entity points at when it has one. That entity's `verification_status`
+     * and `status` are left untouched — the ticket holds no record of what they
+     * were before it was filed, so there is nothing to restore them to.
+     *
+     * Mutates `userData` in place, so it may be called on a draft inside a
+     * reducer.
+     */
+    static removeTicket(userData: UserData, ticket: TicketData): void;
+    static fillPromotionData: (data: Pick<ICreateUserData, "giftData" | "referralCode" | "referralCodeType">) => PromotionCustomField | undefined;
+}
+export { UserHelper };

package/dist/helper/userHelper.js

@@ -0,0 +1,260 @@
+import { Entity, EntityData, EntityVerificationStatus } from "../constant";
+import { createDefaultUserData } from "../api/data/user/userDefaults";
+import { filterDefinedProperties } from "../utils/data/manipulation";
+import { isNullOrUndefined } from "../utils/data/validation";
+import { applyTicket } from "../utils/helper/userHelper";
+class UserHelper {
+    // #region "Modify"
+    static modifyListByEntity = (entityList, entity) => {
+        try {
+            if (!entity)
+                return entityList;
+            const modifiedList = entityList.map((e) => {
+                if (e.id == entity.id) {
+                    return { ...e, ...entity };
+                }
+                if (entity.is_primary == 1) {
+                    return { ...e, is_primary: 0 };
+                }
+                return e;
+            });
+            const sortedList = this.sortEntity(modifiedList);
+            return sortedList;
+        }
+        catch (error) {
+            console.error("Error in ModifyListByEntity:", error);
+            return entityList;
+        }
+    };
+    static modifyByDocumentData = (entityList, documentData) => {
+        if (!documentData)
+            return entityList;
+        const modifiedList = entityList.map((e) => {
+            if (e.id == documentData.info.entity_id) {
+                return { ...e, verification_status: EntityVerificationStatus.Pending };
+            }
+            return e;
+        });
+        const sortedList = this.sortEntity(modifiedList);
+        return sortedList;
+    };
+    static modifyOrganizationByDocumentData = (organizationList, documentData) => {
+        if (!documentData)
+            return organizationList;
+        const modifiedList = organizationList.map((e) => {
+            if (e.info.id == documentData.info.entity_id) {
+                const modifiedOrganizationData = {
+                    ...e,
+                    info: {
+                        ...e.info,
+                        verification_status: EntityVerificationStatus.Pending,
+                    },
+                };
+                return modifiedOrganizationData;
+            }
+            return e;
+        });
+        return modifiedList;
+    };
+    static modifyOrganizationList = (organizationList, organization) => {
+        if (!organization?.info?.id)
+            return organizationList;
+        const modifiedOrganization = filterDefinedProperties(organization);
+        return organizationList.map((org) => {
+            if (org?.info?.id !== organization.info.id)
+                return org;
+            return {
+                ...org,
+                ...modifiedOrganization,
+                info: { ...org.info, ...filterDefinedProperties(organization.info) },
+                details: {
+                    ...org.details,
+                    ...filterDefinedProperties(organization.details),
+                },
+            };
+        });
+    };
+    static modifyProfilePicture = (personal_info, documentData) => {
+        if (!documentData)
+            return personal_info;
+        const picture = documentData.attachment[0].file_url;
+        const modifiedPersonalInfo = {
+            ...personal_info,
+            picture: picture,
+        };
+        return modifiedPersonalInfo;
+    };
+    static modifySecurityByResetUserSecurity = (userSecurity, resetUserSecurity) => {
+        if (!resetUserSecurity?.reset_security_data)
+            return userSecurity;
+        const { reset_password, reset_security_questions, reset_security_code } = resetUserSecurity.reset_security_data;
+        if (reset_security_questions) {
+            return {
+                ...userSecurity,
+                secret_question_1: reset_security_questions.secret_question_1,
+                secret_answer_1: reset_security_questions.secret_answer_1,
+                secret_question_2: reset_security_questions.secret_question_2,
+                secret_answer_2: reset_security_questions.secret_answer_2,
+            };
+        }
+        if (reset_security_code) {
+            return {
+                ...userSecurity,
+                security_code: reset_security_code.new_security_code,
+            };
+        }
+        if (reset_password) {
+            return {
+                ...userSecurity,
+                password: reset_password.new_password,
+            };
+        }
+        return userSecurity;
+    };
+    // #endregion
+    // #region "Sort"
+    static sortEntity = (entityList) => {
+        return entityList.sort((a, b) => {
+            const sortByIsPrimary = this.sortByIsPrimary(a, b);
+            if (sortByIsPrimary != 0) {
+                return sortByIsPrimary;
+            }
+            const sortByVerificationStatus = this.sortByVerificationStatus(a, b);
+            if (sortByVerificationStatus != 0) {
+                return sortByVerificationStatus;
+            }
+            return this.sortById(a, b);
+        });
+    };
+    static sortByIsPrimary = (a, b) => {
+        if (!isNullOrUndefined(a.is_primary) && !isNullOrUndefined(b.is_primary)) {
+            return b.is_primary - a.is_primary;
+        }
+        return 0;
+    };
+    static sortByVerificationStatus = (a, b) => {
+        if (!isNullOrUndefined(a.verification_status) &&
+            !isNullOrUndefined(b.verification_status)) {
+            const priority = {
+                [EntityVerificationStatus.Verified]: 4,
+                [EntityVerificationStatus.Pending]: 3,
+                [EntityVerificationStatus.Failed]: 2,
+                [EntityVerificationStatus.Not_Verified]: 1,
+                [EntityVerificationStatus.Undefined]: 0,
+            };
+            return priority[b.verification_status] - priority[a.verification_status];
+        }
+        return 0;
+    };
+    static sortById = (a, b) => {
+        if (!isNullOrUndefined(a.id) && !isNullOrUndefined(b.id)) {
+            return a.id - b.id;
+        }
+        return 0;
+    };
+    // #endregion
+    // #region "Utils"
+    static extractDeviceData = (data) => {
+        if (Array.isArray(data.device)) {
+            return data.device[0];
+        }
+        return data.device;
+    };
+    static fillUserDataByEntity(entity, entityData, data, id) {
+        switch (entity) {
+            case Entity.Entity_Address:
+                return createDefaultUserData({ addresses: [{ ...data[0], id }] });
+            case Entity.Entity_Bank:
+                return createDefaultUserData({ bank_account: [{ ...data[0], id }] });
+            case Entity.Entity_Device:
+                return createDefaultUserData({ device: [{ ...data[0], id }] });
+            case Entity.Entity_Email:
+                return createDefaultUserData({ email: [{ ...data[0], id }] });
+            case Entity.Entity_Identification:
+                return createDefaultUserData({ identification: [{ ...data[0], id }] });
+            case Entity.Organization:
+                return createDefaultUserData({
+                    organization: [
+                        data[0]?.info?.id
+                            ? { ...data[0], id }
+                            : { info: { ...data[0], id } },
+                    ],
+                });
+            case Entity.Entity_Phone:
+                return createDefaultUserData({ phone: [{ ...data[0], id }] });
+            case Entity.Ticket:
+                return createDefaultUserData({ ticket: [{ ...data }] });
+            case Entity.Account:
+                return createDefaultUserData({ account: [{ ...data[0], id }] });
+            case Entity.Entity_Custom_Field:
+                return createDefaultUserData({ custom_field: data });
+            case Entity.Entity_Device_History:
+                return createDefaultUserData({ device_history: [{ ...data[0], id }] });
+            case Entity.User_Personal_Info:
+                return createDefaultUserData({ personal_info: data });
+            case Entity.User:
+                switch (entityData) {
+                    case EntityData.Personal_Info:
+                        return createDefaultUserData({ personal_info: data });
+                    case EntityData.Verification:
+                        return createDefaultUserData({ security: data });
+                    default:
+                        return createDefaultUserData({ addresses: [] });
+                }
+            default:
+                return createDefaultUserData({ addresses: [] });
+        }
+    }
+    /**
+     * Adds a newly created ticket to the user-level ticket list, and to the entity
+     * its sub-entity points at when it has one. Applying the same ticket twice
+     * leaves a single copy of it.
+     *
+     * Mutates `userData` in place, so it may be called on a draft inside a
+     * reducer.
+     */
+    static addTicket(userData, ticket) {
+        applyTicket(userData, ticket, "add");
+    }
+    /**
+     * Applies an updated ticket to the user-level ticket list, and to the entity
+     * its sub-entity points at when it has one. Unlike `addTicket`, both lists are
+     * only updated in place — a ticket that is not already there is never
+     * appended.
+     *
+     * Mutates `userData` in place, so it may be called on a draft inside a
+     * reducer.
+     */
+    static modifyTicket(userData, ticket) {
+        applyTicket(userData, ticket, "modify");
+    }
+    /**
+     * Takes a ticket off the user-level ticket list, and off the entity its
+     * sub-entity points at when it has one. That entity's `verification_status`
+     * and `status` are left untouched — the ticket holds no record of what they
+     * were before it was filed, so there is nothing to restore them to.
+     *
+     * Mutates `userData` in place, so it may be called on a draft inside a
+     * reducer.
+     */
+    static removeTicket(userData, ticket) {
+        applyTicket(userData, ticket, "remove");
+    }
+    static fillPromotionData = (data) => {
+        if (!data ||
+            (!data.giftData && !data.referralCode && !data.referralCodeType))
+            return;
+        const customField = { promotion_data: {} };
+        if (data.giftData) {
+            customField.promotion_data.gift_data = [data.giftData];
+        }
+        if (data.referralCode && data.referralCodeType) {
+            customField.promotion_data.referral_data = {
+                code: data.referralCode,
+                type: data.referralCodeType,
+            };
+        }
+        return customField;
+    };
+}
+export { UserHelper };

package/dist/helpers.d.ts

@@ -0,0 +1 @@
+export * from "./helper";

package/dist/helpers.js

@@ -0,0 +1,2 @@
+// All helper exports
+export * from "./helper";

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./api";
+export * from "./constant";
+export * from "./content";
+export * from "./helper";
+export * from "./utils";
+export type * from "./types";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./api";
+export * from "./constant";
+export * from "./content";
+export * from "./helper";
+export * from "./utils";

package/dist/limited.d.ts

@@ -0,0 +1,5 @@
+export { LimitedProxy } from "./api/proxy/limitedProxy";
+export { LimitedService } from "./api/service/limitedService";
+export * from "./api/data/limited";
+export type * from "./types/api/data/limited";
+export type * from "./types/api/service/limitedService";

package/dist/limited.js

@@ -0,0 +1,5 @@
+// Limited-related exports - Complete limited domain
+export { LimitedProxy } from "./api/proxy/limitedProxy";
+export { LimitedService } from "./api/service/limitedService";
+// Limited data exports
+export * from "./api/data/limited";

package/dist/order.d.ts

@@ -0,0 +1,5 @@
+export { OrderProxy } from "./api/proxy/orderProxy";
+export { OrderService } from "./api/service/orderService";
+export * from "./api/data/order";
+export type * from "./types/api/data/order";
+export type * from "./types/api/service/orderService";

package/dist/order.js

@@ -0,0 +1,5 @@
+// Order-related exports - Complete order domain
+export { OrderProxy } from "./api/proxy/orderProxy";
+export { OrderService } from "./api/service/orderService";
+// Order data exports
+export * from "./api/data/order";

package/dist/organization.d.ts

@@ -0,0 +1,5 @@
+export { OrganizationProxy } from "./api/proxy/organizationProxy";
+export { OrganizationService } from "./api/service/organizationService";
+export * from "./api/data/organization";
+export type * from "./types/api/data/organization";
+export type * from "./types/api/service/organizationService";

package/dist/organization.js

@@ -0,0 +1,5 @@
+// Organization-related exports - Complete organization domain
+export { OrganizationProxy } from "./api/proxy/organizationProxy";
+export { OrganizationService } from "./api/service/organizationService";
+// Organization data exports
+export * from "./api/data/organization";

package/dist/program.d.ts

@@ -0,0 +1,4 @@
+export { ProgramProxy } from "./api/proxy/programProxy";
+export { ProgramService } from "./api/service/programService";
+export * from "./api/data/program";
+export type * from "./types/api/service/programService";

package/dist/program.js

@@ -0,0 +1,5 @@
+// Program-related exports - Complete program domain
+export { ProgramProxy } from "./api/proxy/programProxy";
+export { ProgramService } from "./api/service/programService";
+// Program data exports (if exists)
+export * from "./api/data/program";

package/dist/promotion.d.ts

@@ -0,0 +1,3 @@
+export { PromotionProxy } from "./api/proxy/promotionProxy";
+export { PromotionService } from "./api/service/promotionService";
+export type * from "./types/api/service/promotionService";

package/dist/promotion.js

@@ -0,0 +1,3 @@
+// Promotion-related exports - Complete promotion domain
+export { PromotionProxy } from "./api/proxy/promotionProxy";
+export { PromotionService } from "./api/service/promotionService";

package/dist/regex.d.ts

@@ -0,0 +1 @@
+export * from "./constant/regex";

package/dist/regex.js

@@ -0,0 +1,2 @@
+// Regex exports
+export * from "./constant/regex";

package/dist/structures.d.ts

@@ -0,0 +1 @@
+export * from "./constant/structure";

package/dist/structures.js

@@ -0,0 +1,2 @@
+// Structures exports
+export * from "./constant/structure";

package/dist/transaction.d.ts

@@ -0,0 +1,5 @@
+export { TransactionProxy } from "./api/proxy/transactionProxy";
+export { TransactionService } from "./api/service/transactionService";
+export * from "./api/data/transaction";
+export type * from "./types/api/data/transaction";
+export type * from "./types/api/service/transactionService";

package/dist/transaction.js

@@ -0,0 +1,5 @@
+// Transaction-related exports - Complete transaction domain
+export { TransactionProxy } from "./api/proxy/transactionProxy";
+export { TransactionService } from "./api/service/transactionService";
+// Transaction data exports
+export * from "./api/data/transaction";

package/dist/types/api/api.d.ts

@@ -0,0 +1,8 @@
+type APIConfig = {
+    baseUrl: string;
+    nodeUrl: string;
+    programId: string;
+    lang: string;
+    domain: string;
+};
+export type { APIConfig };

package/dist/types/api/api.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/bc-api.d.ts

@@ -0,0 +1,9 @@
+type BlockchainAPIConfig = {
+    baseUrl: string;
+};
+/**
+ * A page request flattened into the dotted query params the Cosmos REST gateway
+ * expects — `pagination.limit`, `pagination.key`, and friends.
+ */
+type PaginationQueryParams = Record<string, string | number | boolean>;
+export type { BlockchainAPIConfig, PaginationQueryParams };

package/dist/types/api/bc-api.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/common/index.d.ts

@@ -0,0 +1,9 @@
+import { BaseResult } from "../../banking/common/baseresult";
+type ErrorHandler = (error: unknown) => void;
+type ApiResponse<T extends BaseResult> = {
+    data: T;
+    success: boolean;
+    message: string;
+    error: string | null;
+};
+export type { ApiResponse, ErrorHandler };

package/dist/types/api/common/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/context/clientContext.d.ts

@@ -0,0 +1,28 @@
+import type { GeoHelper } from "../../../helper/geoHelper";
+type InitialContext = {
+    baseUrl: string;
+    nodeUrl: string;
+    programId: string;
+    lang?: string;
+    installationId?: string;
+    token?: string;
+    userId?: number;
+};
+/**
+ * Source of truth for per-request credential + config state.
+ *
+ * Services read via getters at the moment a request is issued — never from
+ * captured constructor values — so fresh credentials always win.
+ *
+ * Proxy methods write via setters after a successful auth operation.
+ * Nothing outside the SDK should call the setters.
+ */
+interface ClientContextProvider {
+    getBaseUrl(): string;
+    getNodeUrl(): string;
+    getProgramId(): number;
+    getLang(): string;
+    setLang(lang: string): void;
+    getGeoHelper(): GeoHelper;
+}
+export type { InitialContext, ClientContextProvider };

package/dist/types/api/context/clientContext.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/context/index.d.ts

@@ -0,0 +1 @@
+export type * from "./clientContext";

package/dist/types/api/context/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/data/account.d.ts

@@ -0,0 +1,7 @@
+interface IGetAccountData {
+    account_id: number;
+}
+interface IGetAccountLimitsData {
+    account_id: number;
+}
+export type { IGetAccountData, IGetAccountLimitsData };