@hinkal/common 0.2.21 → 0.2.23

package/API/kycCalls.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../constants/server.constants.cjs"),s=require("./getServerURL.cjs"),i=require("../data-structures/http/HttpClient.cjs");require("axios");async function o(e){return i.httpClient.post(`${s.SERVER_URL}${r.API_CONFIG.ROUTES.checkKycStatus}`,{ethereumAddress:e})}async function a(e,t,n){return i.httpClient.post(`${s.SERVER_URL}${r.API_CONFIG.ROUTES.startUserVerification}`,{ethereumAddress:e,verificationSessionId:t,verificationType:n})}async function R(e,t,n){return i.httpClient.post(`${s.SERVER_URL}${r.API_CONFIG.ROUTES.getUserSignature}`,{chainId:e,ethereumAddress:t,accessKey:n})}async function u(e,t,n,c){return i.httpClient.post(`${s.SERVER_URL}${r.API_CONFIG.ROUTES.startReclaimVerification}`,{ethereumAddress:t,providerId:e,userSignature:n,withSignature:c})}const S=async()=>(await i.httpClient.get(`${s.SERVER_URL}${r.API_CONFIG.ROUTES.zkMeAccessToken}`)).accessToken;exports.getAccessTokenSignature=R;exports.getReclaimVerificationRequest=u;exports.getUserKycStatus=o;exports.getZkMeAccessToken=S;exports.setAiPriseVerificationUrl=a;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../constants/server.constants.cjs"),n=require("./getServerURL.cjs"),c=require("../data-structures/http/HttpClient.cjs");require("axios");async function o(e,t){return c.httpClient.post(`${n.getServerURL(e)}${s.API_CONFIG.ROUTES.checkKycStatus}`,{ethereumAddress:t})}async function u(e,t,r,i){return c.httpClient.post(`${n.getServerURL(e)}${s.API_CONFIG.ROUTES.startUserVerification}`,{ethereumAddress:t,verificationSessionId:r,verificationType:i})}async function g(e,t,r){return c.httpClient.post(`${n.getServerURL(e)}${s.API_CONFIG.ROUTES.getUserSignature}`,{ethereumAddress:t,accessKey:r})}async function S(e,t,r,i,a){return c.httpClient.post(`${n.getServerURL(e)}${s.API_CONFIG.ROUTES.startReclaimVerification}`,{ethereumAddress:r,providerId:t,userSignature:i,withSignature:a})}const U=async e=>(await c.httpClient.get(`${n.getServerURL(e)}${s.API_CONFIG.ROUTES.zkMeAccessToken}`)).accessToken,R=async(e,t,r)=>await c.httpClient.post(`${n.getServerURL(e)}${s.API_CONFIG.ROUTES.userHasKyc}`,{ethereumAddress:t,hasKyc:r});exports.getAccessTokenSignature=g;exports.getReclaimVerificationRequest=S;exports.getUserKycStatus=o;exports.getZkMeAccessToken=U;exports.setAiPriseVerificationUrl=u;exports.userHasKyc=R;

package/API/kycCalls.d.ts

@@ -4,8 +4,8 @@ interface IGetKycStatus {
     verificationResult: KycVerificationResult;
     passportIds?: Passports[];
 }
-export declare function getUserKycStatus(ethereumOrSolanaAddress: string): Promise<IGetKycStatus>;
-export declare function setAiPriseVerificationUrl(ethereumAddress: string, verificationSessionId: string, verificationType: VERIFICATION_TYPE): Promise<any>;
+export declare function getUserKycStatus(chainId: number, ethereumOrSolanaAddress: string): Promise<IGetKycStatus>;
+export declare function setAiPriseVerificationUrl(chainId: number, ethereumAddress: string, verificationSessionId: string, verificationType: VERIFICATION_TYPE): Promise<any>;
 interface AccessTokenSignatureResponse {
     signatureData: SignatureData;
 }
@@ -14,6 +14,10 @@ interface ReclaimVerificationRequestResponse {
     reclaimProofRequestConfig: string;
     message?: string;
 }
-export declare function getReclaimVerificationRequest(providerId: string, ethereumAddress: string, userSignature: string, withSignature: boolean): Promise<ReclaimVerificationRequestResponse>;
-export declare const getZkMeAccessToken: () => Promise<any>;
+export declare function getReclaimVerificationRequest(chainId: number, providerId: string, ethereumAddress: string, userSignature: string, withSignature: boolean): Promise<ReclaimVerificationRequestResponse>;
+export declare const getZkMeAccessToken: (chainId: number) => Promise<any>;
+type IUserHasKyc = {
+    updated: boolean;
+};
+export declare const userHasKyc: (chainId: number, ethereumAddress: string, hasKyc: boolean) => Promise<IUserHasKyc>;
 export {};

package/API/kycCalls.mjs

@@ -1,39 +1,42 @@
-import { API_CONFIG as n } from "../constants/server.constants.mjs";
-import { SERVER_URL as s } from "./getServerURL.mjs";
+import { API_CONFIG as r } from "../constants/server.constants.mjs";
+import { getServerURL as n } from "./getServerURL.mjs";
 import { httpClient as c } from "../data-structures/http/HttpClient.mjs";
 import "axios";
-async function R(t) {
-  return c.post(`${s}${n.ROUTES.checkKycStatus}`, {
+async function f(e, t) {
+  return c.post(`${n(e)}${r.ROUTES.checkKycStatus}`, {
     ethereumAddress: t
   });
 }
-async function m(t, e, r) {
-  return c.post(`${s}${n.ROUTES.startUserVerification}`, {
+async function S(e, t, s, o) {
+  return c.post(`${n(e)}${r.ROUTES.startUserVerification}`, {
     ethereumAddress: t,
-    verificationSessionId: e,
-    verificationType: r
+    verificationSessionId: s,
+    verificationType: o
   });
 }
-async function p(t, e, r) {
-  return c.post(`${s}${n.ROUTES.getUserSignature}`, {
-    chainId: t,
-    ethereumAddress: e,
-    accessKey: r
+async function U(e, t, s) {
+  return c.post(`${n(e)}${r.ROUTES.getUserSignature}`, {
+    ethereumAddress: t,
+    accessKey: s
   });
 }
-async function S(t, e, r, i) {
-  return c.post(`${s}${n.ROUTES.startReclaimVerification}`, {
-    ethereumAddress: e,
+async function m(e, t, s, o, i) {
+  return c.post(`${n(e)}${r.ROUTES.startReclaimVerification}`, {
+    ethereumAddress: s,
     providerId: t,
-    userSignature: r,
+    userSignature: o,
     withSignature: i
   });
 }
-const U = async () => (await c.get(`${s}${n.ROUTES.zkMeAccessToken}`)).accessToken;
+const y = async (e) => (await c.get(`${n(e)}${r.ROUTES.zkMeAccessToken}`)).accessToken, R = async (e, t, s) => await c.post(`${n(e)}${r.ROUTES.userHasKyc}`, {
+  ethereumAddress: t,
+  hasKyc: s
+});
 export {
-  p as getAccessTokenSignature,
-  S as getReclaimVerificationRequest,
-  R as getUserKycStatus,
-  U as getZkMeAccessToken,
-  m as setAiPriseVerificationUrl
+  U as getAccessTokenSignature,
+  m as getReclaimVerificationRequest,
+  f as getUserKycStatus,
+  y as getZkMeAccessToken,
+  S as setAiPriseVerificationUrl,
+  R as userHasKyc
 };

package/API/passwordCalls.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("axios"),o=require("../constants/server.constants.cjs"),a=require("./getServerURL.cjs"),n=async(s,e)=>(await t.get(`${a.getServerURL(s)}${o.API_CONFIG.ROUTES.userHasPassword(e)}`)).data,u=async(s,e,r)=>(await t.post(`${a.getServerURL(s)}${o.API_CONFIG.ROUTES.userRegisterPassword}`,{ethereumAddress:e,passwordHash:r})).data;exports.userHasPassword=n;exports.userRegisterPassword=u;

package/API/passwordCalls.d.ts

@@ -0,0 +1,9 @@
+type OptionalUserPassword = {
+    passwordHash: string | null;
+};
+type UserPassword = {
+    passwordHash: string;
+};
+export declare const userHasPassword: (chainId: number, ethereumAddress: string) => Promise<OptionalUserPassword>;
+export declare const userRegisterPassword: (chainId: number, ethereumAddress: string, passwordHash: string) => Promise<UserPassword>;
+export {};

package/API/passwordCalls.mjs

@@ -0,0 +1,13 @@
+import o from "axios";
+import { API_CONFIG as t } from "../constants/server.constants.mjs";
+import { getServerURL as a } from "./getServerURL.mjs";
+const d = async (s, r) => (await o.get(
+  `${a(s)}${t.ROUTES.userHasPassword(r)}`
+)).data, m = async (s, r, e) => (await o.post(`${a(s)}${t.ROUTES.userRegisterPassword}`, {
+  ethereumAddress: r,
+  passwordHash: e
+})).data;
+export {
+  d as userHasPassword,
+  m as userRegisterPassword
+};

package/API/proxyAccountsCalls.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../constants/server.constants.cjs"),n=require("./getServerURL.cjs"),a=require("ethers"),A=require("../functions/utils/addresses.cjs"),c=require("../data-structures/http/HttpClient.cjs");require("axios");const i=(e,t)=>{const s=t.getShieldedPrivateKey(),r=`HinkalProxyAccounts|${e.toLowerCase()}|${s}`;return a.ethers.utils.keccak256(a.ethers.utils.toUtf8Bytes(r))},p=async(e,t)=>{const s=i(e,t);return await c.httpClient.get(`${n.SERVER_URL}${o.API_CONFIG.ROUTES.getProxyAccounts(s)}`)},P=async(e,t,s,r,u)=>{const y=i(e,t),d=A.hashEthereumAddress(e);return await c.httpClient.post(`${n.SERVER_URL}${o.API_CONFIG.ROUTES.updateProxyAccounts}`,{secureKey:y,hashedEthereumAddress:d,proxyAccounts:s,...r!==void 0&&{username:r},...u!==void 0&&{profileImage:u}})},h=async(e,t)=>{const s=i(e,t);return(await c.httpClient.get(`${n.SERVER_URL}${o.API_CONFIG.ROUTES.isVersion1Account(s)}`)).isVersion1Account};exports.getProxyAccounts=p;exports.isVersion1Account=h;exports.updateProxyAccounts=P;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("../constants/server.constants.cjs"),u=require("./getServerURL.cjs"),d=require("../functions/utils/addresses.cjs"),a=require("../data-structures/http/HttpClient.cjs");require("axios");const n=require("ethers"),i=(t,e)=>{const r=e.getShieldedPrivateKey(),s=`HinkalProxyAccounts|${t.toLowerCase()}|${r}`;return n.ethers.keccak256(n.ethers.toUtf8Bytes(s))},P=async(t,e,r)=>{const s=i(e,r);return await a.httpClient.get(`${u.getServerURL(t)}${c.API_CONFIG.ROUTES.getProxyAccounts(s)}`)},g=async(t,e,r,s)=>{const o=i(e,r),y=d.hashEthereumAddress(e);return await a.httpClient.post(`${u.getServerURL(t)}${c.API_CONFIG.ROUTES.updateProxyAccounts}`,{secureKey:o,hashedEthereumAddress:y,proxyAccounts:s})};exports.getProxyAccounts=P;exports.updateProxyAccounts=g;

package/API/proxyAccountsCalls.d.ts

@@ -1,9 +1,4 @@
 import type { SubAccountLight } from '../types/proxy.types';
 import { UserKeys } from '../data-structures/crypto-keys';
-export declare const getProxyAccounts: (ethereumAddress: string, userKeys: UserKeys) => Promise<{
-    proxyAccounts: SubAccountLight[];
-    username?: string | undefined;
-    profileImage?: string | undefined;
-}>;
-export declare const updateProxyAccounts: (ethereumAddress: string, userKeys: UserKeys, proxyAccounts: SubAccountLight[], username?: string, profileImage?: string) => Promise<any>;
-export declare const isVersion1Account: (ethereumAddress: string, userKeys: UserKeys) => Promise<boolean>;
+export declare const getProxyAccounts: (chainId: number, ethereumAddress: string, userKeys: UserKeys) => Promise<SubAccountLight[]>;
+export declare const updateProxyAccounts: (chainId: number, ethereumAddress: string, userKeys: UserKeys, proxyAccounts: SubAccountLight[]) => Promise<any>;

package/API/proxyAccountsCalls.mjs

@@ -1,32 +1,26 @@
-import { API_CONFIG as r } from "../constants/server.constants.mjs";
-import { SERVER_URL as n } from "./getServerURL.mjs";
-import { ethers as a } from "ethers";
-import { hashEthereumAddress as d } from "../functions/utils/addresses.mjs";
-import { httpClient as c } from "../data-structures/http/HttpClient.mjs";
+import { API_CONFIG as c } from "../constants/server.constants.mjs";
+import { getServerURL as a } from "./getServerURL.mjs";
+import { hashEthereumAddress as y } from "../functions/utils/addresses.mjs";
+import { httpClient as i } from "../data-structures/http/HttpClient.mjs";
 import "axios";
-const i = (t, e) => {
-  const o = e.getShieldedPrivateKey(), s = `HinkalProxyAccounts|${t.toLowerCase()}|${o}`;
-  return a.utils.keccak256(a.utils.toUtf8Bytes(s));
-}, S = async (t, e) => {
-  const o = i(t, e);
-  return await c.get(`${n}${r.ROUTES.getProxyAccounts(o)}`);
-}, g = async (t, e, o, s, u) => {
-  const p = i(t, e), y = d(t);
-  return await c.post(`${n}${r.ROUTES.updateProxyAccounts}`, {
-    secureKey: p,
-    hashedEthereumAddress: y,
-    proxyAccounts: o,
-    ...s !== void 0 && { username: s },
-    ...u !== void 0 && { profileImage: u }
+import { ethers as n } from "ethers";
+const p = (t, e) => {
+  const o = e.getShieldedPrivateKey(), r = `HinkalProxyAccounts|${t.toLowerCase()}|${o}`;
+  return n.keccak256(n.toUtf8Bytes(r));
+}, f = async (t, e, o) => {
+  const r = p(e, o);
+  return await i.get(
+    `${a(t)}${c.ROUTES.getProxyAccounts(r)}`
+  );
+}, S = async (t, e, o, r) => {
+  const s = p(e, o), u = y(e);
+  return await i.post(`${a(t)}${c.ROUTES.updateProxyAccounts}`, {
+    secureKey: s,
+    hashedEthereumAddress: u,
+    proxyAccounts: r
   });
-}, K = async (t, e) => {
-  const o = i(t, e);
-  return (await c.get(
-    `${n}${r.ROUTES.isVersion1Account(o)}`
-  )).isVersion1Account;
 };
 export {
-  S as getProxyAccounts,
-  K as isVersion1Account,
-  g as updateProxyAccounts
+  f as getProxyAccounts,
+  S as updateProxyAccounts
 };

package/API/relayCalls.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./getServerURL.cjs"),n=require("../constants/server.constants.cjs"),s=require("../data-structures/http/HttpClient.cjs");require("axios");const a=async(e,t=!1)=>await s.httpClient.get(`${r.RELAYER_URL}${n.RELAYER_CONFIG.getIdleRelay}?markAsPending=${t}&chainId=${e}`);exports.getIdleRelay=a;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./getRelayerURL.cjs"),n=require("../constants/server.constants.cjs"),s=require("../data-structures/http/HttpClient.cjs");require("axios");const l=async(e,t=!1)=>await s.httpClient.get(`${r.getRelayerURL(e)}${n.RELAYER_CONFIG.getIdleRelay}?markAsPending=${t}`);exports.getIdleRelay=l;

package/API/relayCalls.mjs

@@ -1,10 +1,10 @@
-import { RELAYER_URL as r } from "./getServerURL.mjs";
+import { getRelayerURL as r } from "./getRelayerURL.mjs";
 import { RELAYER_CONFIG as o } from "../constants/server.constants.mjs";
 import { httpClient as n } from "../data-structures/http/HttpClient.mjs";
 import "axios";
-const R = async (e, t = !1) => await n.get(
-  `${r}${o.getIdleRelay}?markAsPending=${t}&chainId=${e}`
+const l = async (e, t = !1) => await n.get(
+  `${r(e)}${o.getIdleRelay}?markAsPending=${t}`
 );
 export {
-  R as getIdleRelay
+  l as getIdleRelay
 };

package/API/restoreSnapshots.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../constants/server.constants.cjs"),r=require("./getServerURL.cjs"),s=require("../data-structures/http/HttpClient.cjs");require("axios");async function n(e){return s.httpClient.post(`${r.getServerURL(e)}${t.API_CONFIG.ROUTES.restoreSnapshots}`)}exports.restoreSnapshots=n;

package/API/restoreSnapshots.d.ts

@@ -0,0 +1 @@
+export declare function restoreSnapshots(chainId: number): Promise<any>;

package/API/restoreSnapshots.mjs

@@ -0,0 +1,10 @@
+import { API_CONFIG as t } from "../constants/server.constants.mjs";
+import { getServerURL as o } from "./getServerURL.mjs";
+import { httpClient as e } from "../data-structures/http/HttpClient.mjs";
+import "axios";
+async function i(r) {
+  return e.post(`${o(r)}${t.ROUTES.restoreSnapshots}`);
+}
+export {
+  i as restoreSnapshots
+};

package/API/scheduled-transactions-calls.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../constants/server.constants.cjs"),r=require("../data-structures/http/HttpClient.cjs"),n=require("./getServerURL.cjs"),s=e=>r.httpClient.get(`${n.RELAYER_URL}${t.RELAYER_CONFIG.getScheduledTransactions(e)}`);exports.getScheduledTransactions=s;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../constants/server.constants.cjs"),r=require("../data-structures/http/HttpClient.cjs"),s=require("./getRelayerURL.cjs"),i=(e,t)=>r.httpClient.get(`${s.getRelayerURL(e)}${n.RELAYER_CONFIG.getScheduledTransactions(t)}`),l=(e,t)=>r.httpClient.post(`${s.getRelayerURL(e)}${n.RELAYER_CONFIG.getScheduledTransactionsNullifierIndexes}`,t);exports.getScheduledTransactions=i;exports.getScheduledTransactionsNullifierIndexes=l;

package/API/scheduled-transactions-calls.d.ts

@@ -2,5 +2,13 @@ import { ScheduledTransactionResponseItem } from '../types';
 interface ScheduledTransactionResponseInterface {
     transactions: ScheduledTransactionResponseItem[];
 }
-export declare const getScheduledTransactions: (hashedEthereumAddress: string) => Promise<ScheduledTransactionResponseInterface>;
+export declare const getScheduledTransactions: (chainId: number, hashedEthereumAddress: string) => Promise<ScheduledTransactionResponseInterface>;
+interface ScheduledTransactionsNullifierIndexesRequest {
+    hashedEthereumAddress: string;
+    nullifiers: string[];
+}
+interface ScheduledTransactionsNullifierIndexesResponse {
+    indexes: number[];
+}
+export declare const getScheduledTransactionsNullifierIndexes: (chainId: number, body: ScheduledTransactionsNullifierIndexesRequest) => Promise<ScheduledTransactionsNullifierIndexesResponse>;
 export {};

package/API/scheduled-transactions-calls.mjs

@@ -1,9 +1,13 @@
 import { RELAYER_CONFIG as r } from "../constants/server.constants.mjs";
-import { httpClient as e } from "../data-structures/http/HttpClient.mjs";
-import { RELAYER_URL as o } from "./getServerURL.mjs";
-const c = (t) => e.get(
-  `${o}${r.getScheduledTransactions(t)}`
+import { httpClient as n } from "../data-structures/http/HttpClient.mjs";
+import { getRelayerURL as o } from "./getRelayerURL.mjs";
+const d = (e, t) => n.get(
+  `${o(e)}${r.getScheduledTransactions(t)}`
+), l = (e, t) => n.post(
+  `${o(e)}${r.getScheduledTransactionsNullifierIndexes}`,
+  t
 );
 export {
-  c as getScheduledTransactions
+  d as getScheduledTransactions,
+  l as getScheduledTransactionsNullifierIndexes
 };

package/API/simulate-batch-tx.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./getServerURL.cjs"),s=require("../constants/server.constants.cjs"),n=require("../data-structures/http/HttpClient.cjs");require("axios");const i=async(e,t)=>await n.httpClient.post(`${r.SERVER_URL}${s.API_CONFIG.ROUTES.simulateBatchTx}`,{chainId:e,batchCalls:t});exports.simulateBatchTx=i;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./getServerURL.cjs"),s=require("../constants/server.constants.cjs"),n=require("../data-structures/http/HttpClient.cjs");require("axios");const i=async(e,t)=>await n.httpClient.post(`${r.getServerURL(e)}${s.API_CONFIG.ROUTES.simulateBatchTx}`,{batchCalls:t});exports.simulateBatchTx=i;

package/API/simulate-batch-tx.d.ts

@@ -1,3 +1,3 @@
-import { TransactionSimulatorResult } from '../types/TransactionSimulator.types';
+import { TransactionSimulatorMinimalResult } from '../types/TransactionSimulator.types';
 import { WCTransactionParameters } from '../types';
-export declare const simulateBatchTx: (chainId: number, batchCalls: WCTransactionParameters[]) => Promise<TransactionSimulatorResult<string>>;
+export declare const simulateBatchTx: (chainId: number, batchCalls: WCTransactionParameters[]) => Promise<TransactionSimulatorMinimalResult<string>>;

package/API/simulate-batch-tx.mjs

@@ -1,12 +1,11 @@
-import { SERVER_URL as r } from "./getServerURL.mjs";
-import { API_CONFIG as s } from "../constants/server.constants.mjs";
-import { httpClient as e } from "../data-structures/http/HttpClient.mjs";
+import { getServerURL as o } from "./getServerURL.mjs";
+import { API_CONFIG as e } from "../constants/server.constants.mjs";
+import { httpClient as s } from "../data-structures/http/HttpClient.mjs";
 import "axios";
-const c = async (t, o) => await e.post(
-  `${r}${s.ROUTES.simulateBatchTx}`,
+const c = async (t, r) => await s.post(
+  `${o(t)}${e.ROUTES.simulateBatchTx}`,
   {
-    chainId: t,
-    batchCalls: o
+    batchCalls: r
   }
 );
 export {

package/API/solana-calls.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../data-structures/http/HttpClient.cjs");require("axios");const s=require("../constants/server.constants.cjs"),n=require("./getServerURL.cjs"),r=async e=>t.httpClient.post(`${n.SERVER_URL}${s.API_CONFIG.ROUTES.generateProoflessDepositLimitless}`,e),i=async e=>t.httpClient.post(`${n.SERVER_URL}${s.API_CONFIG.ROUTES.generateMultiPaymentDepositLimitless}`,e),o=async e=>t.httpClient.post(`${n.SERVER_URL}${s.API_CONFIG.ROUTES.generateAddAccessToken}`,e);exports.generateAddAccessToken=o;exports.generateMultiPaymentDepositLimitless=i;exports.generateProoflessDepositLimitless=r;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../data-structures/http/HttpClient.cjs");require("axios");const r=require("../constants/server.constants.cjs"),n=require("./getServerURL.cjs"),i=async(e,t)=>s.httpClient.post(`${n.getServerURL(e)}${r.API_CONFIG.ROUTES.generateProoflessDepositLimitless}`,t),o=async(e,t)=>s.httpClient.post(`${n.getServerURL(e)}${r.API_CONFIG.ROUTES.generateMultiPaymentDepositLimitless}`,t),l=async(e,t)=>s.httpClient.post(`${n.getServerURL(e)}${r.API_CONFIG.ROUTES.generateAddAccessToken}`,t);exports.generateAddAccessToken=l;exports.generateMultiPaymentDepositLimitless=o;exports.generateProoflessDepositLimitless=i;

package/API/solana-calls.d.ts

@@ -5,7 +5,6 @@ interface GenerateProoflessDepositLimitlessInput {
     mint: string;
     amount: string;
     stealthAddressStructure: AnchorStealthAddressStructure;
-    chainId: number;
 }
 interface GenerateMultiPaymentDepositLimitlessInput {
     payer: string;
@@ -13,25 +12,23 @@ interface GenerateMultiPaymentDepositLimitlessInput {
     mint: string;
     amounts: string[];
     stealthAddressStructure: AnchorStealthAddressStructure;
-    chainId: number;
 }
 interface GenerateProoflessDepositLimitlessOutput {
     serializedTransaction: string;
     blockhash: string;
     lastValidBlockHeight: number;
 }
-export declare const generateProoflessDepositLimitless: (input: GenerateProoflessDepositLimitlessInput) => Promise<GenerateProoflessDepositLimitlessOutput>;
-export declare const generateMultiPaymentDepositLimitless: (input: GenerateMultiPaymentDepositLimitlessInput) => Promise<GenerateProoflessDepositLimitlessOutput>;
+export declare const generateProoflessDepositLimitless: (chainId: number, input: GenerateProoflessDepositLimitlessInput) => Promise<GenerateProoflessDepositLimitlessOutput>;
+export declare const generateMultiPaymentDepositLimitless: (chainId: number, input: GenerateMultiPaymentDepositLimitlessInput) => Promise<GenerateProoflessDepositLimitlessOutput>;
 interface GenerateAddTokenPublicKeyInput {
     payer: string;
     accessKey: string;
     ethereumAddress: string;
-    chainId: number;
 }
 interface GenerateAddAccessTokenOutput {
     serializedTransaction: string;
     blockhash: string;
     lastValidBlockHeight: number;
 }
-export declare const generateAddAccessToken: (input: GenerateAddTokenPublicKeyInput) => Promise<GenerateAddAccessTokenOutput>;
+export declare const generateAddAccessToken: (chainId: number, input: GenerateAddTokenPublicKeyInput) => Promise<GenerateAddAccessTokenOutput>;
 export {};

package/API/solana-calls.mjs

@@ -1,19 +1,19 @@
-import { httpClient as t } from "../data-structures/http/HttpClient.mjs";
+import { httpClient as s } from "../data-structures/http/HttpClient.mjs";
 import "axios";
-import { API_CONFIG as s } from "../constants/server.constants.mjs";
-import { SERVER_URL as o } from "./getServerURL.mjs";
-const p = async (e) => t.post(
-  `${o}${s.ROUTES.generateProoflessDepositLimitless}`,
-  e
-), a = async (e) => t.post(
-  `${o}${s.ROUTES.generateMultiPaymentDepositLimitless}`,
-  e
-), c = async (e) => t.post(
-  `${o}${s.ROUTES.generateAddAccessToken}`,
-  e
+import { API_CONFIG as o } from "../constants/server.constants.mjs";
+import { getServerURL as r } from "./getServerURL.mjs";
+const a = async (e, t) => s.post(
+  `${r(e)}${o.ROUTES.generateProoflessDepositLimitless}`,
+  t
+), c = async (e, t) => s.post(
+  `${r(e)}${o.ROUTES.generateMultiPaymentDepositLimitless}`,
+  t
+), l = async (e, t) => s.post(
+  `${r(e)}${o.ROUTES.generateAddAccessToken}`,
+  t
 );
 export {
-  c as generateAddAccessToken,
-  a as generateMultiPaymentDepositLimitless,
-  p as generateProoflessDepositLimitless
+  l as generateAddAccessToken,
+  c as generateMultiPaymentDepositLimitless,
+  a as generateProoflessDepositLimitless
 };

package/API/temporaryWalletCalls.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../constants/server.constants.cjs"),n=require("../data-structures/http/HttpClient.cjs");require("axios");const a=require("./getServerURL.cjs"),l=async(e,t)=>n.httpClient.get(`${a.SERVER_URL}${o.API_CONFIG.ROUTES.getTemporaryWalletNonces(t,e)}`),c=async(e,t,r)=>n.httpClient.post(`${a.SERVER_URL}${o.API_CONFIG.ROUTES.addTemporaryWalletNonce}`,{hashedEthereumAddress:t,chainId:e,nonce:r}),s=async(e,t,r)=>n.httpClient.post(`${a.SERVER_URL}${o.API_CONFIG.ROUTES.removeTemporaryWalletNonce}`,{hashedEthereumAddress:t,chainId:e,nonce:r});exports.addTemporaryWalletNonce=c;exports.getTemporaryWalletNonces=l;exports.removeTemporaryWalletNonce=s;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../constants/server.constants.cjs"),n=require("./getServerURL.cjs"),l=require("../data-structures/http/HttpClient.cjs");require("axios");const a=async(e,r)=>l.httpClient.get(`${n.getServerURL(e)}${o.API_CONFIG.ROUTES.getTemporaryWalletNonces(r,e)}`),s=async(e,r,t)=>l.httpClient.post(`${n.getServerURL(e)}${o.API_CONFIG.ROUTES.addTemporaryWalletNonce}`,{hashedEthereumAddress:r,chainId:e,nonce:t}),c=async(e,r,t)=>l.httpClient.post(`${n.getServerURL(e)}${o.API_CONFIG.ROUTES.removeTemporaryWalletNonce}`,{hashedEthereumAddress:r,chainId:e,nonce:t});exports.addTemporaryWalletNonce=s;exports.getTemporaryWalletNonces=a;exports.removeTemporaryWalletNonce=c;

package/API/temporaryWalletCalls.mjs

@@ -1,20 +1,26 @@
 import { API_CONFIG as t } from "../constants/server.constants.mjs";
+import { getServerURL as m } from "./getServerURL.mjs";
 import { httpClient as a } from "../data-structures/http/HttpClient.mjs";
 import "axios";
-import { SERVER_URL as n } from "./getServerURL.mjs";
-const s = async (e, r) => a.get(
-  `${n}${t.ROUTES.getTemporaryWalletNonces(r, e)}`
-), y = async (e, r, o) => a.post(`${n}${t.ROUTES.addTemporaryWalletNonce}`, {
-  hashedEthereumAddress: r,
-  chainId: e,
-  nonce: o
-}), T = async (e, r, o) => a.post(`${n}${t.ROUTES.removeTemporaryWalletNonce}`, {
-  hashedEthereumAddress: r,
-  chainId: e,
-  nonce: o
-});
+const c = async (e, r) => a.get(
+  `${m(e)}${t.ROUTES.getTemporaryWalletNonces(r, e)}`
+), y = async (e, r, o) => a.post(
+  `${m(e)}${t.ROUTES.addTemporaryWalletNonce}`,
+  {
+    hashedEthereumAddress: r,
+    chainId: e,
+    nonce: o
+  }
+), T = async (e, r, o) => a.post(
+  `${m(e)}${t.ROUTES.removeTemporaryWalletNonce}`,
+  {
+    hashedEthereumAddress: r,
+    chainId: e,
+    nonce: o
+  }
+);
 export {
   y as addTemporaryWalletNonce,
-  s as getTemporaryWalletNonces,
+  c as getTemporaryWalletNonces,
   T as removeTemporaryWalletNonce
 };

package/API/token-calls.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../constants/server.constants.cjs"),s=require("./getServerURL.cjs"),o=require("../data-structures/http/HttpClient.cjs");require("axios");const i=async(e,t,n=!1)=>await o.httpClient.post(`${s.SERVER_URL}${r.API_CONFIG.ROUTES.getTokensInfo}`,{chainId:e,tokenAddresses:t,waitForOffsetUpdate:n});exports.tokensInfoCall=i;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../constants/server.constants.cjs"),s=require("./getServerURL.cjs"),o=require("../data-structures/http/HttpClient.cjs");require("axios");const i=async(e,t,r=!1)=>await o.httpClient.post(`${s.getServerURL(e)}${n.API_CONFIG.ROUTES.getTokensInfo}`,{tokenAddresses:t,waitForOffsetUpdate:r});exports.tokensInfoCall=i;

package/API/token-calls.mjs

@@ -1,13 +1,12 @@
-import { API_CONFIG as e } from "../constants/server.constants.mjs";
-import { SERVER_URL as n } from "./getServerURL.mjs";
+import { API_CONFIG as r } from "../constants/server.constants.mjs";
+import { getServerURL as n } from "./getServerURL.mjs";
 import { httpClient as s } from "../data-structures/http/HttpClient.mjs";
 import "axios";
-const l = async (o, t, r = !1) => await s.post(
-  `${n}${e.ROUTES.getTokensInfo}`,
+const l = async (o, t, e = !1) => await s.post(
+  `${n(o)}${r.ROUTES.getTokensInfo}`,
   {
-    chainId: o,
     tokenAddresses: t,
-    waitForOffsetUpdate: r
+    waitForOffsetUpdate: e
   }
 );
 export {