ggez-banking-sdk 0.3.31 → 0.4.2

package/dist/account.d.ts

@@ -1,6 +1,5 @@
-export { AccountClient } from "./api/clients/account";
-export { AccountService } from "./api/services/account";
+export { AccountClient } from "./api/client/account";
+export { AccountService } from "./api/service/account";
 export * from "./api/data/account";
-export type * from "./types/api/client/account";
 export type * from "./types/api/data/account";
 export type * from "./types/api/service/account";

package/dist/account.js

@@ -1,5 +1,5 @@
 // Account-related exports - Complete account domain
-export { AccountClient } from "./api/clients/account";
-export { AccountService } from "./api/services/account";
+export { AccountClient } from "./api/client/account";
+export { AccountService } from "./api/service/account";
 // Account data exports
 export * from "./api/data/account";

package/dist/api/api.d.ts

@@ -1,29 +1,41 @@
-import { AccountClient, AuthClient, BlockchainClient, ClientData, ErrorHandler, IPAddressAndLocationClient, LimitedClient, OrderClient, OrganizationClient, ProgramClient, PromotionClient, TransactionClient, UserClient } from "..";
+import { AccountClient, AuthClient, BlockchainClient, IPAddressAndLocationClient, LimitedClient, OrderClient, OrganizationClient, ProgramClient, PromotionClient, TransactionClient, UserClient } from "./client";
+import type { ClientData, ErrorHandler } from "../types";
+import type { ClientContextProvider } from "../types/api/context/clientContext";
+/**
+ * SDK entry point. Constructs the full dependency graph in one shot:
+ *
+ *   ClientContext + CookiesHelper
+ *     → Services (axios transport)
+ *       → Proxies (read context to build per-call axios config; cross-entity
+ *         orchestration like AuthProxy → UserProxy)
+ *         → Clients (consumer-facing payload/response shaping)
+ *
+ * Consumers interact with `api.<client>` methods only. Credentials and
+ * language are mutated via the exposed `context` setters. Session
+ * invalidation (token expiry detection, device-credential refresh,
+ * redirect to login) is the consumer's responsibility — the SDK is
+ * stateless about session lifecycle.
+ */
 declare class API {
-    private _account;
-    private _auth;
-    private _blockchain;
-    private _ipAddress;
-    private _limited;
-    private _order;
-    private _organization;
-    private _program;
-    private _promotion;
-    private _transaction;
-    private _user;
-    private errorHandler;
-    private clientData;
+    readonly context: ClientContextProvider;
+    readonly account: AccountClient;
+    readonly auth: AuthClient;
+    readonly blockchain: BlockchainClient;
+    readonly ipAddress: IPAddressAndLocationClient;
+    readonly limited: LimitedClient;
+    readonly order: OrderClient;
+    readonly organization: OrganizationClient;
+    readonly program: ProgramClient;
+    readonly promotion: PromotionClient;
+    readonly transaction: TransactionClient;
+    readonly user: UserClient;
+    private readonly cookiesHelper;
+    private readonly authProxy;
     constructor(clientData: ClientData, errorHandler: ErrorHandler);
-    get account(): AccountClient;
-    get auth(): AuthClient;
-    get blockchain(): BlockchainClient;
-    get ipAddress(): IPAddressAndLocationClient;
-    get limited(): LimitedClient;
-    get order(): OrderClient;
-    get organization(): OrganizationClient;
-    get program(): ProgramClient;
-    get promotion(): PromotionClient;
-    get transaction(): TransactionClient;
-    get user(): UserClient;
+    /**
+     * Clear session state on explicit user logout: zero the in-memory
+     * context, then drop the cookies.
+     */
+    logout(): Promise<void>;
 }
 export { API };

package/dist/api/api.js

@@ -1,95 +1,115 @@
-import { AccountClient, AuthClient, BlockchainClient, IPAddressAndLocationClient, LimitedClient, OrderClient, OrganizationClient, ProgramClient, PromotionClient, TransactionClient, UserClient, } from "..";
+import { AxiosHelper } from "../helper/api/axiosHelper";
+import { CookiesHelper } from "../helper/storage/cookiesHelper";
+import { AccountClient, AuthClient, BlockchainClient, IPAddressAndLocationClient, LimitedClient, OrderClient, OrganizationClient, ProgramClient, PromotionClient, TransactionClient, UserClient, } from "./client";
+import { AccountService, AuthService, BlockchainService, IPAddressAndLocationService, LimitedService, OrderService, OrganizationService, ProgramService, PromotionService, TransactionService, UserService, } from "./service";
+import { AccountProxy, AuthProxy, BlockchainProxy, IPAddressAndLocationProxy, LimitedProxy, OrderProxy, OrganizationProxy, ProgramProxy, PromotionProxy, TransactionProxy, UserProxy, } from "./proxy";
+import { DefaultClientContextProvider } from "./context";
+/**
+ * SDK entry point. Constructs the full dependency graph in one shot:
+ *
+ *   ClientContext + CookiesHelper
+ *     → Services (axios transport)
+ *       → Proxies (read context to build per-call axios config; cross-entity
+ *         orchestration like AuthProxy → UserProxy)
+ *         → Clients (consumer-facing payload/response shaping)
+ *
+ * Consumers interact with `api.<client>` methods only. Credentials and
+ * language are mutated via the exposed `context` setters. Session
+ * invalidation (token expiry detection, device-credential refresh,
+ * redirect to login) is the consumer's responsibility — the SDK is
+ * stateless about session lifecycle.
+ */
 class API {
-    // #region "Properties"
-    _account = null;
-    _auth = null;
-    _blockchain = null;
-    _ipAddress = null;
-    _limited = null;
-    _order = null;
-    _organization = null;
-    _program = null;
-    _promotion = null;
-    _transaction = null;
-    _user = null;
-    errorHandler;
-    clientData;
-    // #endregion
-    // #region "Constructor"
+    context;
+    account;
+    auth;
+    blockchain;
+    ipAddress;
+    limited;
+    order;
+    organization;
+    program;
+    promotion;
+    transaction;
+    user;
+    cookiesHelper;
+    authProxy;
     constructor(clientData, errorHandler) {
-        this.errorHandler = errorHandler;
-        this.clientData = clientData;
+        this.context = new DefaultClientContextProvider({
+            baseUrl: clientData.baseUrl,
+            nodeUrl: clientData.nodeUrl,
+            programId: clientData.programId,
+            lang: clientData.lang,
+            installationId: clientData.installationId,
+        });
+        this.cookiesHelper = new CookiesHelper(String(clientData.programId), clientData.domain ?? "", errorHandler);
+        // axios baseURL is sticky per-instance, so we build one config per
+        // base-URL variant from clientData. Per-call headers (Authorization,
+        // Source_Id, Time_Zone) are written by the proxy layer at call time.
+        const authConfig = AxiosHelper.getAuthAxiosConfig(clientData.baseUrl, clientData.lang, "");
+        const sessionConfig = AxiosHelper.getAxiosConfig("", clientData.baseUrl, clientData.lang, clientData.installationId);
+        const promotionConfig = AxiosHelper.getAuthAxiosConfig(clientData.nodeUrl, clientData.lang, "");
+        const shared = { context: this.context };
+        const authService = new AuthService({ config: authConfig, ...shared });
+        const userService = new UserService({ config: sessionConfig, ...shared });
+        const accountService = new AccountService({ config: sessionConfig, ...shared });
+        const blockchainService = new BlockchainService({ config: sessionConfig, ...shared });
+        const ipAddressAndLocationService = new IPAddressAndLocationService({
+            config: sessionConfig,
+            ...shared,
+        });
+        const limitedService = new LimitedService({ config: sessionConfig, ...shared });
+        const orderService = new OrderService({ config: sessionConfig, ...shared });
+        const organizationService = new OrganizationService({
+            config: sessionConfig,
+            ...shared,
+        });
+        const programService = new ProgramService({ config: sessionConfig, ...shared });
+        const promotionService = new PromotionService({
+            config: promotionConfig,
+            ...shared,
+        });
+        const transactionService = new TransactionService({
+            config: sessionConfig,
+            ...shared,
+        });
+        // AuthProxy and UserProxy reference each other (α2 login → getUser).
+        // Build AuthProxy first, then UserProxy, then wire via setUserProxy.
+        // AuthProxy and LimitedProxy are pre-session (mint their own auth) and
+        // don't extend BaseProxy. Every other proxy takes context so it can
+        // build session-authenticated configs.
+        this.authProxy = new AuthProxy(authService, this.context, this.cookiesHelper);
+        const userProxy = new UserProxy(this.context, userService, this.authProxy);
+        this.authProxy.setUserProxy(userProxy);
+        const accountProxy = new AccountProxy(this.context, accountService);
+        const blockchainProxy = new BlockchainProxy(this.context, blockchainService);
+        const ipAddressAndLocationProxy = new IPAddressAndLocationProxy(this.context, ipAddressAndLocationService);
+        const limitedProxy = new LimitedProxy(limitedService, this.authProxy, this.context);
+        const orderProxy = new OrderProxy(this.context, orderService);
+        const organizationProxy = new OrganizationProxy(this.context, organizationService);
+        const programProxy = new ProgramProxy(this.context, programService);
+        const promotionProxy = new PromotionProxy(this.context, promotionService);
+        const transactionProxy = new TransactionProxy(this.context, transactionService);
+        this.auth = new AuthClient(this.authProxy, this.context, errorHandler);
+        this.user = new UserClient(userProxy, errorHandler);
+        this.account = new AccountClient(accountProxy, errorHandler);
+        this.blockchain = new BlockchainClient(blockchainProxy, errorHandler);
+        this.ipAddress = new IPAddressAndLocationClient(ipAddressAndLocationProxy, errorHandler);
+        this.limited = new LimitedClient(limitedProxy, errorHandler);
+        this.order = new OrderClient(orderProxy, errorHandler);
+        this.organization = new OrganizationClient(organizationProxy, this.context, errorHandler);
+        this.program = new ProgramClient(programProxy, errorHandler);
+        this.promotion = new PromotionClient(promotionProxy, errorHandler);
+        this.transaction = new TransactionClient(transactionProxy, errorHandler);
     }
-    // #endregion
-    // #region "Clients"
-    get account() {
-        if (!this._account) {
-            this._account = new AccountClient(this.clientData, this.errorHandler);
-        }
-        return this._account;
-    }
-    get auth() {
-        if (!this._auth) {
-            this._auth = new AuthClient(this.clientData, this.errorHandler);
-        }
-        return this._auth;
-    }
-    get blockchain() {
-        if (!this._blockchain) {
-            this._blockchain = new BlockchainClient(this.clientData, this.errorHandler);
-        }
-        return this._blockchain;
-    }
-    get ipAddress() {
-        if (!this._ipAddress) {
-            this._ipAddress = new IPAddressAndLocationClient(this.clientData, this.errorHandler);
-        }
-        return this._ipAddress;
-    }
-    get limited() {
-        if (!this._limited) {
-            this._limited = new LimitedClient(this.clientData, this.errorHandler);
-        }
-        return this._limited;
-    }
-    get order() {
-        if (!this._order) {
-            this._order = new OrderClient(this.clientData, this.errorHandler);
-        }
-        return this._order;
-    }
-    get organization() {
-        if (!this._organization) {
-            this._organization = new OrganizationClient(this.clientData, this.errorHandler);
-        }
-        return this._organization;
-    }
-    get program() {
-        if (!this._program) {
-            this._program = new ProgramClient(this.clientData, this.errorHandler);
-        }
-        return this._program;
-    }
-    get promotion() {
-        if (!this._promotion) {
-            this._promotion = new PromotionClient(this.clientData, this.errorHandler);
-        }
-        return this._promotion;
-    }
-    get transaction() {
-        if (!this._transaction) {
-            this._transaction = new TransactionClient(this.clientData, this.errorHandler);
-        }
-        return this._transaction;
-    }
-    get user() {
-        if (!this._user) {
-            this._user = new UserClient(this.clientData, this.errorHandler);
-        }
-        return this._user;
+    /**
+     * Clear session state on explicit user logout: zero the in-memory
+     * context, then drop the cookies.
+     */
+    async logout() {
+        this.context.setToken("");
+        this.context.setUserId(0);
+        await this.cookiesHelper.clearCredentialCookies();
     }
 }
-const api = new API({}, (error) => {
-    console.error("API Error:", error);
-});
 export { API };

package/dist/api/{clients → client}/account.d.ts

@@ -1,10 +1,10 @@
-import type { AccountClientData } from "../../types/api/client/account";
-import type { ErrorHandler, RequestOptions } from "../../types/api/service/base";
+import type { ErrorHandler } from "../../types";
+import type { AccountProxy } from "../proxy/account";
 import { BaseClient } from "./base";
 declare class AccountClient extends BaseClient {
-    private accountService;
-    constructor(clientData: AccountClientData, errorHandler: ErrorHandler);
-    get: (accountId: number, options?: RequestOptions) => Promise<{
+    private accountProxy;
+    constructor(accountProxy: AccountProxy, errorHandler: ErrorHandler);
+    get: (accountId: number) => Promise<{
         data: import("../..").AccountData;
         success: boolean;
         message: string;
@@ -15,7 +15,7 @@ declare class AccountClient extends BaseClient {
         message: string;
         error: string;
     }>;
-    getLimits: (accountId: number, options?: RequestOptions) => Promise<{
+    getLimits: (accountId: number) => Promise<{
         data: import("../..").AccountData;
         success: boolean;
         message: string;

package/dist/api/{clients → client}/account.js

@@ -1,19 +1,15 @@
-import { AxiosHelper } from "../../helper/api/axiosHelper";
 import { createDefaultAccountData, fillResultByError } from "../data";
-import { AccountService } from "../services";
 import { BaseClient } from "./base";
 class AccountClient extends BaseClient {
-    accountService;
-    constructor(clientData, errorHandler) {
-        super(clientData, errorHandler);
-        const { token, baseUrl, lang, installationId, userId } = this.clientData;
-        const config = AxiosHelper.getAxiosConfig(token, baseUrl, lang, installationId);
-        this.accountService = new AccountService({ config, userId });
+    accountProxy;
+    constructor(accountProxy, errorHandler) {
+        super(errorHandler);
+        this.accountProxy = accountProxy;
     }
     // #region "GET"
-    get = async (accountId, options) => {
+    get = async (accountId) => {
         try {
-            const response = await this.accountService.get(accountId, options);
+            const response = await this.accountProxy.get(accountId);
             return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
@@ -22,9 +18,9 @@ class AccountClient extends BaseClient {
             return this.responseHelper.getErrorResponse(accountData, "get");
         }
     };
-    getLimits = async (accountId, options) => {
+    getLimits = async (accountId) => {
         try {
-            const response = await this.accountService.getLimits(accountId, options);
+            const response = await this.accountProxy.getLimits(accountId);
             return this.responseHelper.getResponse(response.data);
         }
         catch (error) {

package/dist/api/client/auth.d.ts

@@ -0,0 +1,26 @@
+import type { ErrorHandler, IGenerateLimitedTokenData, ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData, LoginClientResponse } from "../../types";
+import type { ClientContextProvider } from "../../types/api/context/clientContext";
+import type { AuthProxy } from "../proxy/auth";
+import { BaseClient } from "./base";
+declare class AuthClient extends BaseClient {
+    private authProxy;
+    private context;
+    constructor(authProxy: AuthProxy, context: ClientContextProvider, errorHandler: ErrorHandler);
+    loginUserCredentials: (data: ILoginUserCredentialsData) => Promise<LoginClientResponse>;
+    loginDeviceCredentials: (data: ILoginDeviceCredentialsData) => Promise<LoginClientResponse>;
+    loginGoogleCredentials: (data: ILoginGoogleCredentialsData) => Promise<LoginClientResponse>;
+    generateLimitedToken: (data: IGenerateLimitedTokenData) => Promise<{
+        data: import("../..").NodeTokenData;
+        success: boolean;
+        message: string;
+        error: null;
+    } | {
+        data: import("../..").TokenData;
+        success: boolean;
+        message: string;
+        error: string;
+    }>;
+    private shapeLoginResponse;
+    private shapeLoginError;
+}
+export { AuthClient };

package/dist/api/client/auth.js

@@ -0,0 +1,86 @@
+import { fillGenerateLimitedTokenData, fillLoginDeviceCredentialsData, fillLoginGoogleCredentialsData, fillLoginUserCredentialsData, fillResult, fillResultByError, createDefaultTokenData, } from "../data";
+import { ResultHelper } from "../../helper/api/resultHelper";
+import { BaseClient } from "./base";
+class AuthClient extends BaseClient {
+    authProxy;
+    context;
+    constructor(authProxy, context, errorHandler) {
+        super(errorHandler);
+        this.authProxy = authProxy;
+        this.context = context;
+    }
+    // #region "POST"
+    loginUserCredentials = async (data) => {
+        try {
+            const credentials = fillLoginUserCredentialsData(this.context.getProgramId(), data);
+            const result = await this.authProxy.loginAndFetchUser(credentials);
+            return this.shapeLoginResponse(result);
+        }
+        catch (error) {
+            return this.shapeLoginError(error, "loginUserCredentials");
+        }
+    };
+    loginDeviceCredentials = async (data) => {
+        try {
+            const credentials = fillLoginDeviceCredentialsData(this.context.getProgramId(), data);
+            const result = await this.authProxy.loginAndFetchUser(credentials);
+            return this.shapeLoginResponse(result);
+        }
+        catch (error) {
+            return this.shapeLoginError(error, "loginDeviceCredentials");
+        }
+    };
+    loginGoogleCredentials = async (data) => {
+        try {
+            const credentials = fillLoginGoogleCredentialsData(this.context.getProgramId(), data);
+            const result = await this.authProxy.loginAndFetchUser(credentials);
+            return this.shapeLoginResponse(result);
+        }
+        catch (error) {
+            return this.shapeLoginError(error, "loginGoogleCredentials");
+        }
+    };
+    generateLimitedToken = async (data) => {
+        try {
+            const tokenData = fillGenerateLimitedTokenData(data);
+            const response = await this.authProxy.generateLimitedToken(tokenData);
+            response.data.result = fillResult(response.data);
+            return this.responseHelper.getResponse(response.data);
+        }
+        catch (error) {
+            const result = fillResultByError(error);
+            const tokenData = createDefaultTokenData({ result });
+            return this.responseHelper.getErrorResponse(tokenData, "generateLimitedToken");
+        }
+    };
+    // #endregion
+    shapeLoginResponse(result) {
+        const tokenBody = result.tokenData.data;
+        tokenBody.result = fillResult(tokenBody);
+        const success = ResultHelper.isApproved(tokenBody.result);
+        return {
+            data: {
+                tokenData: tokenBody,
+                userData: result.userData ? result.userData.data : null,
+            },
+            success,
+            message: tokenBody.result.message,
+            error: null,
+        };
+    }
+    shapeLoginError(error, functionName) {
+        const result = fillResultByError(error);
+        const tokenData = createDefaultTokenData({ result });
+        this.errorHandler(`${result.message}, ${functionName}`);
+        return {
+            data: {
+                tokenData,
+                userData: null,
+            },
+            success: false,
+            message: result.message,
+            error: result.message,
+        };
+    }
+}
+export { AuthClient };

package/dist/api/client/base.d.ts

@@ -0,0 +1,13 @@
+import { ResponseHelper } from "../../helper/api/responseHelper";
+import type { ErrorHandler } from "../../types";
+/**
+ * BaseClient is the consumer-facing layer. It no longer holds transport
+ * state — Services own axios, Proxies own orchestration, Clients only shape
+ * payloads (via fillX) and responses (via ResponseHelper).
+ */
+declare abstract class BaseClient {
+    protected errorHandler: ErrorHandler;
+    protected responseHelper: ResponseHelper;
+    constructor(errorHandler: ErrorHandler);
+}
+export { BaseClient };

package/dist/api/client/base.js

@@ -0,0 +1,15 @@
+import { ResponseHelper } from "../../helper/api/responseHelper";
+/**
+ * BaseClient is the consumer-facing layer. It no longer holds transport
+ * state — Services own axios, Proxies own orchestration, Clients only shape
+ * payloads (via fillX) and responses (via ResponseHelper).
+ */
+class BaseClient {
+    errorHandler;
+    responseHelper;
+    constructor(errorHandler) {
+        this.errorHandler = errorHandler;
+        this.responseHelper = new ResponseHelper(errorHandler);
+    }
+}
+export { BaseClient };

package/dist/api/{clients → client}/blockchain.d.ts

@@ -1,9 +1,10 @@
-import type { BlockchainClientData, ErrorHandler, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData, RequestOptions } from "../../types";
+import type { ErrorHandler, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData } from "../../types";
+import type { BlockchainProxy } from "../proxy/blockchain";
 import { BaseClient } from "./base";
 declare class BlockchainClient extends BaseClient {
-    private blockchainService;
-    constructor(clientData: BlockchainClientData, errorHandler: ErrorHandler);
-    send: (data: IBlockchainSendRequestData, options?: RequestOptions) => Promise<{
+    private blockchainProxy;
+    constructor(blockchainProxy: BlockchainProxy, errorHandler: ErrorHandler);
+    send: (data: IBlockchainSendRequestData) => Promise<{
         data: import("../..").BlockchainData;
         success: boolean;
         message: string;
@@ -14,7 +15,7 @@ declare class BlockchainClient extends BaseClient {
         message: string;
         error: string;
     }>;
-    multiSend: (data: IBlockchainMultiSendRequestData, options?: RequestOptions) => Promise<{
+    multiSend: (data: IBlockchainMultiSendRequestData) => Promise<{
         data: import("../..").BlockchainData;
         success: boolean;
         message: string;
@@ -25,7 +26,7 @@ declare class BlockchainClient extends BaseClient {
         message: string;
         error: string;
     }>;
-    delegate: (data: IBlockchainDelegateRequestData, options?: RequestOptions) => Promise<{
+    delegate: (data: IBlockchainDelegateRequestData) => Promise<{
         data: import("../..").BlockchainData;
         success: boolean;
         message: string;
@@ -36,7 +37,7 @@ declare class BlockchainClient extends BaseClient {
         message: string;
         error: string;
     }>;
-    undelegate: (data: IBlockchainUndelegateRequestData, options?: RequestOptions) => Promise<{
+    undelegate: (data: IBlockchainUndelegateRequestData) => Promise<{
         data: import("../..").BlockchainData;
         success: boolean;
         message: string;

package/dist/api/{clients → client}/blockchain.js

@@ -1,20 +1,16 @@
-import { AxiosHelper } from "../../helper/api/axiosHelper";
 import { createDefaultBlockchainData, fillBlockchainDelegateData, fillBlockchainMultiSendData, fillBlockchainSendData, fillBlockchainUndelegateData, fillResultByError, } from "../data";
-import { BlockchainService } from "../services";
 import { BaseClient } from "./base";
 class BlockchainClient extends BaseClient {
-    blockchainService;
-    constructor(clientData, errorHandler) {
-        super(clientData, errorHandler);
-        const { token, baseUrl, lang, installationId, userId } = clientData;
-        const config = AxiosHelper.getAxiosConfig(token, baseUrl, lang, installationId);
-        this.blockchainService = new BlockchainService({ config, userId });
+    blockchainProxy;
+    constructor(blockchainProxy, errorHandler) {
+        super(errorHandler);
+        this.blockchainProxy = blockchainProxy;
     }
     // #region "POST"
-    send = async (data, options) => {
+    send = async (data) => {
         try {
             const blockchainSendData = fillBlockchainSendData(data);
-            const response = await this.blockchainService.send(blockchainSendData, options);
+            const response = await this.blockchainProxy.send(blockchainSendData);
             return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
@@ -23,10 +19,10 @@ class BlockchainClient extends BaseClient {
             return this.responseHelper.getErrorResponse(blockchainData, "send");
         }
     };
-    multiSend = async (data, options) => {
+    multiSend = async (data) => {
         try {
             const blockchainMultiSendData = fillBlockchainMultiSendData(data);
-            const response = await this.blockchainService.multiSend(blockchainMultiSendData, options);
+            const response = await this.blockchainProxy.multiSend(blockchainMultiSendData);
             return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
@@ -35,10 +31,10 @@ class BlockchainClient extends BaseClient {
             return this.responseHelper.getErrorResponse(blockchainData, "multiSend");
         }
     };
-    delegate = async (data, options) => {
+    delegate = async (data) => {
         try {
             const blockchainDelegateData = fillBlockchainDelegateData(data);
-            const response = await this.blockchainService.delegate(blockchainDelegateData, options);
+            const response = await this.blockchainProxy.delegate(blockchainDelegateData);
             return this.responseHelper.getResponse(response.data);
         }
         catch (error) {
@@ -47,10 +43,10 @@ class BlockchainClient extends BaseClient {
             return this.responseHelper.getErrorResponse(blockchainData, "delegate");
         }
     };
-    undelegate = async (data, options) => {
+    undelegate = async (data) => {
         try {
             const blockchainUndelegateData = fillBlockchainUndelegateData(data);
-            const response = await this.blockchainService.undelegate(blockchainUndelegateData, options);
+            const response = await this.blockchainProxy.undelegate(blockchainUndelegateData);
             return this.responseHelper.getResponse(response.data);
         }
         catch (error) {

package/dist/api/{clients → client}/ipAddressAndLocation.d.ts

@@ -1,14 +1,15 @@
-import { ErrorHandler, IPAddressAndLocationClientData } from "../../types";
+import type { ErrorHandler } from "../../types";
+import type { IPAddressAndLocationProxy } from "../proxy/ipAddressAndLocation";
 import { BaseClient } from "./base";
 declare class IPAddressAndLocationClient extends BaseClient {
-    private ipAddressAndLocationService;
-    constructor(clientData: IPAddressAndLocationClientData, errorHandler: ErrorHandler);
+    private ipAddressAndLocationProxy;
+    constructor(ipAddressAndLocationProxy: IPAddressAndLocationProxy, errorHandler: ErrorHandler);
     getGeoCoordinates: () => Promise<import("../..").GeoCoordinates> | {
         latitude: number;
         longitude: number;
         position_description: string;
     };
-    getIPAddress: () => Promise<string> | "";
+    getIPAddress: () => "" | Promise<string>;
     getGeoCoordinatesAndIPAddress: () => Promise<{
         geo_coordinates: import("../..").GeoCoordinates;
         ip_address: string;