@hinkal/common 0.2.14 → 0.2.16

package/API/rewardsUserCalls.d.ts

@@ -0,0 +1,51 @@
+import { AchievementProgressItem, RewardsUser, SwapStreakClient, TaskProgress } from '../types';
+interface ConnectRewardsUserRes {
+    message: string;
+    user: RewardsUser;
+    isFirstTimeUser: boolean;
+    signature: string;
+}
+export declare const connectRewardsUser: (ethereumAddress: string, signature: string, firstProxyAddress: string) => Promise<ConnectRewardsUserRes>;
+interface InputDataTypes {
+    ethereumAddress: string;
+    signature: string;
+    username?: string;
+    profileImage?: string;
+    proxyAddress?: string;
+}
+interface UpdateRewardsUserRes {
+    message: string;
+    user: RewardsUser;
+}
+export declare const updateRewardsUser: (inputData: InputDataTypes) => Promise<UpdateRewardsUserRes>;
+interface GetSwapStreakRes {
+    message: string;
+    swapStreak: SwapStreakClient;
+}
+export declare const getSwapStreak: (ethereumAddress: string) => Promise<GetSwapStreakRes>;
+interface GetTasksProgressRes {
+    success: boolean;
+    userTasks: TaskProgress[];
+    userAchievements: AchievementProgressItem[];
+    brotherhoodTasks: TaskProgress[];
+    completedTasks: string[];
+    brotherhoodCompletedTasks: string[];
+    pointsToShowInCongratsPopup: number;
+}
+export declare const getTasksProgress: (ethereumAddress: string) => Promise<GetTasksProgressRes>;
+interface DisconnectSocialNetworkRes {
+    message: string;
+    user: RewardsUser;
+}
+interface DisconnectSocialNetworkProps {
+    ethereumAddress: string;
+    socialWebsiteId: string;
+    signature: string;
+    proxyAddress: string;
+}
+export declare const disconnectSocialNetwork: ({ ethereumAddress, socialWebsiteId, signature, proxyAddress, }: DisconnectSocialNetworkProps) => Promise<DisconnectSocialNetworkRes>;
+interface GetNftMultiplierRes {
+    nftMultiplier: number;
+}
+export declare const getNftMultiplier: (ethereumAddress: string) => Promise<GetNftMultiplierRes>;
+export {};

package/API/rewardsUserCalls.mjs

@@ -0,0 +1,44 @@
+import { DATA_SERVER_URL as r } from "./getServerURL.mjs";
+import { DATA_SERVER_CONFIG as e } from "../constants/server.constants.mjs";
+import { httpClient as s } from "../data-structures/http/HttpClient.mjs";
+import "axios";
+import { getSignatureHeader as o } from "../functions/utils/get-signature-header.mjs";
+const u = async (t, a, n) => await s.post(
+  `${r}${e.connectRewardsUser}`,
+  {
+    ethereumAddress: t,
+    proxyAddress: n
+  },
+  o(a)
+), m = async (t) => await s.patch(
+  `${r}${e.updateRewardsUser}`,
+  t,
+  o(t.signature)
+), R = async (t) => await s.get(`${r}${e.getSwapStreak}`, {
+  params: { ethereumAddress: t }
+}), S = async (t) => await s.get(
+  `${r}${e.getTasksProgress(t)}`
+), l = async ({
+  ethereumAddress: t,
+  socialWebsiteId: a,
+  signature: n,
+  proxyAddress: c
+}) => await s.patch(
+  `${r}${e.disconnectSocialNetwork}`,
+  {
+    ethereumAddress: t,
+    socialWebsiteId: a,
+    proxyAddress: c
+  },
+  o(n)
+), y = async (t) => await s.get(
+  `${r}${e.getNftMultiplier(t)}`
+);
+export {
+  u as connectRewardsUser,
+  l as disconnectSocialNetwork,
+  y as getNftMultiplier,
+  R as getSwapStreak,
+  S as getTasksProgress,
+  m as updateRewardsUser
+};

package/API/scheduled-transactions-calls.cjs

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

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

@@ -0,0 +1,6 @@
+import { ScheduledTransactionResponseItem } from '../types';
+interface ScheduledTransactionResponseInterface {
+    transactions: ScheduledTransactionResponseItem[];
+}
+export declare const getScheduledTransactions: (chainId: number, hashedEthereumAddress: string) => Promise<ScheduledTransactionResponseInterface>;
+export {};

package/API/scheduled-transactions-calls.mjs

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

package/API/seedless-calls.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./getServerURL.cjs"),t=require("../constants/server.constants.cjs"),n=require("../data-structures/http/HttpClient.cjs");require("axios");const r=async e=>n.httpClient.post(`${s.DATA_SERVER_URL}${t.DATA_SERVER_CONFIG.seedlessInit}`,e),l=async e=>n.httpClient.post(`${s.DATA_SERVER_URL}${t.DATA_SERVER_CONFIG.seedlessBackup}`,e),R=async e=>n.httpClient.post(`${s.DATA_SERVER_URL}${t.DATA_SERVER_CONFIG.seedlessStatus}`,e),c=async e=>n.httpClient.post(`${s.DATA_SERVER_URL}${t.DATA_SERVER_CONFIG.seedlessCheckPassword}`,e),o=async e=>n.httpClient.post(`${s.DATA_SERVER_URL}${t.DATA_SERVER_CONFIG.seedlessSalt}`,e);exports.seedlessBackup=l;exports.seedlessCheckPassword=c;exports.seedlessInit=r;exports.seedlessSalt=o;exports.seedlessStatus=R;

package/API/seedless-calls.d.ts

@@ -0,0 +1,53 @@
+interface SeedlessInitProps {
+    sessionToken: string;
+    ethereumAddress: string;
+    ciphertextB64: string;
+    ivB64: string;
+    saltMnemonicB64: string;
+    saltSharesB64: string;
+    shareMongoB64: string;
+    shareMongoIvB64: string;
+    passwordHashB64: string;
+    passwordSaltB64: string;
+}
+interface SeedlessInitRes {
+    success: boolean;
+}
+export declare const seedlessInit: (payload: SeedlessInitProps) => Promise<SeedlessInitRes>;
+interface SeedlessBackupProps {
+    sessionToken: string;
+}
+interface SeedlessBackupRes {
+    success: boolean;
+    ciphertextB64: string;
+    ivB64: string;
+    saltMnemonicB64: string;
+    saltSharesB64: string;
+    shareMongoB64: string;
+    shareMongoIvB64: string;
+}
+export declare const seedlessBackup: (payload: SeedlessBackupProps) => Promise<SeedlessBackupRes>;
+interface SeedlessStatusProps {
+    sessionToken: string;
+}
+interface SeedlessStatusRes {
+    success: boolean;
+    isFirstLogin: boolean;
+}
+export declare const seedlessStatus: (payload: SeedlessStatusProps) => Promise<SeedlessStatusRes>;
+interface SeedlessCheckPasswordProps {
+    sessionToken: string;
+    password: string;
+}
+interface SeedlessCheckPasswordRes {
+    success: boolean;
+}
+export declare const seedlessCheckPassword: (payload: SeedlessCheckPasswordProps) => Promise<SeedlessCheckPasswordRes>;
+interface SeedlessSaltProps {
+    sessionToken: string;
+}
+interface SeedlessSaltRes {
+    passwordSaltB64: string;
+}
+export declare const seedlessSalt: (payload: SeedlessSaltProps) => Promise<SeedlessSaltRes>;
+export {};

package/API/seedless-calls.mjs

@@ -0,0 +1,12 @@
+import { DATA_SERVER_URL as e } from "./getServerURL.mjs";
+import { DATA_SERVER_CONFIG as t } from "../constants/server.constants.mjs";
+import { httpClient as o } from "../data-structures/http/HttpClient.mjs";
+import "axios";
+const l = async (s) => o.post(`${e}${t.seedlessInit}`, s), p = async (s) => o.post(`${e}${t.seedlessBackup}`, s), d = async (s) => o.post(`${e}${t.seedlessStatus}`, s), $ = async (s) => o.post(`${e}${t.seedlessCheckPassword}`, s), u = async (s) => o.post(`${e}${t.seedlessSalt}`, s);
+export {
+  p as seedlessBackup,
+  $ as seedlessCheckPassword,
+  l as seedlessInit,
+  u as seedlessSalt,
+  d as seedlessStatus
+};

package/API/send-telegram-callback.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../constants/server.constants.cjs"),a=require("./getServerURL.cjs"),n=require("../data-structures/http/HttpClient.cjs");require("axios");const l=async({ethereumAddress:e,telegramUser:t})=>await n.httpClient.post(`${a.DATA_SERVER_URL}${r.DATA_SERVER_CONFIG.getTelegramCallback}`,{ethereumAddress:e,telegramUser:t});exports.sendTelegramCallback=l;

package/API/send-telegram-callback.d.ts

@@ -0,0 +1,7 @@
+import { TelegramUser } from '../types';
+interface TelegramCallbackProps {
+    ethereumAddress: string;
+    telegramUser: TelegramUser;
+}
+export declare const sendTelegramCallback: ({ ethereumAddress, telegramUser }: TelegramCallbackProps) => Promise<any>;
+export {};

package/API/send-telegram-callback.mjs

@@ -0,0 +1,11 @@
+import { DATA_SERVER_CONFIG as r } from "../constants/server.constants.mjs";
+import { DATA_SERVER_URL as o } from "./getServerURL.mjs";
+import { httpClient as e } from "../data-structures/http/HttpClient.mjs";
+import "axios";
+const c = async ({ ethereumAddress: t, telegramUser: a }) => await e.post(`${o}${r.getTelegramCallback}`, {
+  ethereumAddress: t,
+  telegramUser: a
+});
+export {
+  c as sendTelegramCallback
+};

package/API/simulate-batch-tx.cjs

@@ -0,0 +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.getServerURL(e)}${s.API_CONFIG.ROUTES.simulateBatchTx}`,{batchCalls:t});exports.simulateBatchTx=i;

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

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

package/API/simulate-batch-tx.mjs

@@ -0,0 +1,13 @@
+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, r) => await s.post(
+  `${o(t)}${e.ROUTES.simulateBatchTx}`,
+  {
+    batchCalls: r
+  }
+);
+export {
+  c as simulateBatchTx
+};

package/API/solana-calls.cjs

@@ -0,0 +1 @@
+"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

@@ -0,0 +1,34 @@
+import { AnchorStealthAddressStructure } from '../types/circom-data.types';
+interface GenerateProoflessDepositLimitlessInput {
+    payer: string;
+    ethereumAddress: string;
+    mint: string;
+    amount: string;
+    stealthAddressStructure: AnchorStealthAddressStructure;
+}
+interface GenerateMultiPaymentDepositLimitlessInput {
+    payer: string;
+    ethereumAddress: string;
+    mint: string;
+    amounts: string[];
+    stealthAddressStructure: AnchorStealthAddressStructure;
+}
+interface GenerateProoflessDepositLimitlessOutput {
+    serializedTransaction: string;
+    blockhash: string;
+    lastValidBlockHeight: number;
+}
+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;
+}
+interface GenerateAddAccessTokenOutput {
+    serializedTransaction: string;
+    blockhash: string;
+    lastValidBlockHeight: number;
+}
+export declare const generateAddAccessToken: (chainId: number, input: GenerateAddTokenPublicKeyInput) => Promise<GenerateAddAccessTokenOutput>;
+export {};

package/API/solana-calls.mjs

@@ -0,0 +1,19 @@
+import { httpClient as s } from "../data-structures/http/HttpClient.mjs";
+import "axios";
+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 {
+  l as generateAddAccessToken,
+  c as generateMultiPaymentDepositLimitless,
+  a as generateProoflessDepositLimitless
+};

package/API/tenderly.api.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("axios"),i="7o1iPUgCIjLI0rSxj2yuz9-Z3052uUc4",d="hinkal-org",l="project",u=`https://api.tenderly.co/api/v1/account/${d}/project/${l}`,a={"X-Access-Key":i},r=async e=>(await s.post(`${u}/simulate`,{...e},{headers:a})).data,n="https://optimism.gateway.tenderly.co/2A3r4RCMoAZVmQOpNqRO29",o=async e=>(await s.post(n,{jsonrpc:"2.0",id:0,method:"tenderly_simulateTransaction",params:e.params},{headers:a})).data,c=async e=>(await s.post(n,{jsonrpc:"2.0",id:0,method:"tenderly_simulateBundle",params:e.params},{headers:a})).data,p=async(e,t)=>(await s.post(n,{jsonrpc:"2.0",id:0,method:"tenderly_getStorageChanges",params:[{address:e,offset:t}]},{headers:a})).data,m={rpcGetStorageChanges:p,rpcSimulateTransaction:o,rpcSimulateBundle:c,simulateTx:r};exports.WALLET_API=m;exports.rpcGetStorageChanges=p;exports.rpcSimulateBundle=c;exports.rpcSimulateTransaction=o;exports.simulateTx=r;exports.tenderlyRpcLinkOptimism=n;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../constants/chains.constants.cjs"),s=require("../data-structures/http/HttpClient.cjs");require("axios");const d="7o1iPUgCIjLI0rSxj2yuz9-Z3052uUc4",h="hinkal-org",u="project",y=`https://api.tenderly.co/api/v1/account/${h}/project/${u}`,a={"X-Access-Key":d},c=async t=>await s.httpClient.post(`${y}/simulate`,{...t},{headers:a}),r={[n.chainIds.optimism]:"https://optimism.gateway.tenderly.co/2A3r4RCMoAZVmQOpNqRO29",[n.chainIds.base]:"https://base.gateway.tenderly.co/73UtIBn1YiCyhqRJuKTkWl",[n.chainIds.ethMainnet]:"https://mainnet.gateway.tenderly.co/SW3mROrzKEQYSq3RkStJ7",[n.chainIds.avalanche]:"https://avalanche.gateway.tenderly.co/2YdoJTNLCUHfzwvqIUVgwZ",[n.chainIds.arbMainnet]:"https://arbitrum.gateway.tenderly.co/4dUF2wEnsmvFw9fqLpoLga",[n.chainIds.polygon]:"https://polygon.gateway.tenderly.co/32hCaUScB41nXgyzCmeDVu"},i=async(t,e)=>await s.httpClient.post(r[t],{jsonrpc:"2.0",id:0,method:"tenderly_simulateTransaction",params:e.params},{headers:a}),p=async(t,e)=>await s.httpClient.post(r[t],{jsonrpc:"2.0",id:0,method:"tenderly_simulateBundle",params:e.params},{headers:a}),l=async(t,e,o)=>await s.httpClient.post(r[t],{jsonrpc:"2.0",id:0,method:"tenderly_getStorageChanges",params:[{address:e,offset:o}]},{headers:a}),m={rpcGetStorageChanges:l,rpcSimulateTransaction:i,rpcSimulateBundle:p,simulateTx:c};exports.WALLET_API=m;exports.rpcGetStorageChanges=l;exports.rpcSimulateBundle=p;exports.rpcSimulateTransaction=i;exports.simulateTx=c;exports.tenderlyRpcLinks=r;

package/API/tenderly.api.d.ts

@@ -1,12 +1,14 @@
 import type { RpcSimulateResult, RpcSimulateTransactionBody, RpcSimulateTransactionResponse, RpcTransactionParams, SimulateTxBody, SimulateTxResponse } from '../types/tenderly.api.types';
 export declare const simulateTx: (simulateTxBody: SimulateTxBody) => Promise<SimulateTxResponse>;
-export declare const tenderlyRpcLinkOptimism = "https://optimism.gateway.tenderly.co/2A3r4RCMoAZVmQOpNqRO29";
-export declare const rpcSimulateTransaction: (simulateTxBody: RpcSimulateTransactionBody) => Promise<RpcSimulateTransactionResponse>;
-export declare const rpcSimulateBundle: (simulateTxBody: RpcSimulateTransactionBody<RpcTransactionParams[]>) => Promise<RpcSimulateTransactionResponse<RpcSimulateResult[]>>;
-export declare const rpcGetStorageChanges: (address: string, offset: string) => Promise<any>;
+export declare const tenderlyRpcLinks: {
+    [x: number]: string;
+};
+export declare const rpcSimulateTransaction: (chainId: number, simulateTxBody: RpcSimulateTransactionBody) => Promise<RpcSimulateTransactionResponse>;
+export declare const rpcSimulateBundle: (chainId: number, simulateTxBody: RpcSimulateTransactionBody<RpcTransactionParams[]>) => Promise<RpcSimulateTransactionResponse<RpcSimulateResult[]>>;
+export declare const rpcGetStorageChanges: (chainId: number, address: string, offset: string) => Promise<any>;
 export declare const WALLET_API: {
-    rpcGetStorageChanges: (address: string, offset: string) => Promise<any>;
-    rpcSimulateTransaction: (simulateTxBody: RpcSimulateTransactionBody) => Promise<RpcSimulateTransactionResponse>;
-    rpcSimulateBundle: (simulateTxBody: RpcSimulateTransactionBody<RpcTransactionParams[]>) => Promise<RpcSimulateTransactionResponse<RpcSimulateResult[]>>;
+    rpcGetStorageChanges: (chainId: number, address: string, offset: string) => Promise<any>;
+    rpcSimulateTransaction: (chainId: number, simulateTxBody: RpcSimulateTransactionBody) => Promise<RpcSimulateTransactionResponse>;
+    rpcSimulateBundle: (chainId: number, simulateTxBody: RpcSimulateTransactionBody<RpcTransactionParams[]>) => Promise<RpcSimulateTransactionResponse<RpcSimulateResult[]>>;
     simulateTx: (simulateTxBody: SimulateTxBody) => Promise<SimulateTxResponse>;
 };

package/API/tenderly.api.mjs

@@ -1,47 +1,57 @@
-import e from "axios";
-const o = "7o1iPUgCIjLI0rSxj2yuz9-Z3052uUc4", r = "hinkal-org", c = "project", p = `https://api.tenderly.co/api/v1/account/${r}/project/${c}`, a = { "X-Access-Key": o }, i = async (s) => (await e.post(
-  `${p}/simulate`,
-  { ...s },
+import { chainIds as s } from "../constants/chains.constants.mjs";
+import { httpClient as a } from "../data-structures/http/HttpClient.mjs";
+import "axios";
+const c = "7o1iPUgCIjLI0rSxj2yuz9-Z3052uUc4", p = "hinkal-org", i = "project", l = `https://api.tenderly.co/api/v1/account/${p}/project/${i}`, n = { "X-Access-Key": c }, m = async (t) => await a.post(
+  `${l}/simulate`,
+  { ...t },
   {
-    headers: a
+    headers: n
   }
-)).data, n = "https://optimism.gateway.tenderly.co/2A3r4RCMoAZVmQOpNqRO29", d = async (s) => (await e.post(
-  n,
-  { jsonrpc: "2.0", id: 0, method: "tenderly_simulateTransaction", params: s.params },
+), r = {
+  [s.optimism]: "https://optimism.gateway.tenderly.co/2A3r4RCMoAZVmQOpNqRO29",
+  [s.base]: "https://base.gateway.tenderly.co/73UtIBn1YiCyhqRJuKTkWl",
+  [s.ethMainnet]: "https://mainnet.gateway.tenderly.co/SW3mROrzKEQYSq3RkStJ7",
+  [s.avalanche]: "https://avalanche.gateway.tenderly.co/2YdoJTNLCUHfzwvqIUVgwZ",
+  [s.arbMainnet]: "https://arbitrum.gateway.tenderly.co/4dUF2wEnsmvFw9fqLpoLga",
+  [s.polygon]: "https://polygon.gateway.tenderly.co/32hCaUScB41nXgyzCmeDVu"
+  // Arc Testnet is not supported by Tenderly
+}, y = async (t, e) => await a.post(
+  r[t],
+  { jsonrpc: "2.0", id: 0, method: "tenderly_simulateTransaction", params: e.params },
   {
-    headers: a
+    headers: n
   }
-)).data, m = async (s) => (await e.post(
-  n,
-  { jsonrpc: "2.0", id: 0, method: "tenderly_simulateBundle", params: s.params },
-  { headers: a }
-)).data, l = async (s, t) => (await e.post(
-  n,
+), d = async (t, e) => await a.post(
+  r[t],
+  { jsonrpc: "2.0", id: 0, method: "tenderly_simulateBundle", params: e.params },
+  { headers: n }
+), h = async (t, e, o) => await a.post(
+  r[t],
   {
     jsonrpc: "2.0",
     id: 0,
     method: "tenderly_getStorageChanges",
     params: [
       {
-        address: s,
-        offset: t
+        address: e,
+        offset: o
       }
     ]
   },
   {
-    headers: a
+    headers: n
   }
-)).data, h = {
-  rpcGetStorageChanges: l,
-  rpcSimulateTransaction: d,
-  rpcSimulateBundle: m,
-  simulateTx: i
+), C = {
+  rpcGetStorageChanges: h,
+  rpcSimulateTransaction: y,
+  rpcSimulateBundle: d,
+  simulateTx: m
 };
 export {
-  h as WALLET_API,
-  l as rpcGetStorageChanges,
-  m as rpcSimulateBundle,
-  d as rpcSimulateTransaction,
-  i as simulateTx,
-  n as tenderlyRpcLinkOptimism
+  C as WALLET_API,
+  h as rpcGetStorageChanges,
+  d as rpcSimulateBundle,
+  y as rpcSimulateTransaction,
+  m as simulateTx,
+  r as tenderlyRpcLinks
 };

package/API/token-calls.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("axios"),o=require("../constants/server.constants.cjs"),n=require("./getServerURL.cjs"),s=async(e,t)=>(await r.post(`${n.getServerURL(e)}${o.API_CONFIG.ROUTES.getTokensInfo}`,{tokenAddresses:t})).data;exports.tokensInfoCall=s;
+"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.d.ts

@@ -1,2 +1,2 @@
 import { ERC20Token } from '../types';
-export declare const tokensInfoCall: (chainId: number, tokenAddresses: string[]) => Promise<(ERC20Token | undefined)[]>;
+export declare const tokensInfoCall: (chainId: number, tokenAddresses: string[], waitForOffsetUpdate?: boolean) => Promise<(ERC20Token | undefined)[]>;

package/API/token-calls.mjs

@@ -1,9 +1,14 @@
-import r from "axios";
-import { API_CONFIG as e } from "../constants/server.constants.mjs";
-import { getServerURL as a } from "./getServerURL.mjs";
-const f = async (o, t) => (await r.post(`${a(o)}${e.ROUTES.getTokensInfo}`, {
-  tokenAddresses: t
-})).data;
+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, e = !1) => await s.post(
+  `${n(o)}${r.ROUTES.getTokensInfo}`,
+  {
+    tokenAddresses: t,
+    waitForOffsetUpdate: e
+  }
+);
 export {
-  f as tokensInfoCall
+  l as tokensInfoCall
 };

package/API/unspent-utxos-calls.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../constants/server.constants.cjs"),r=require("./getRelayerURL.cjs"),o=require("../data-structures/http/HttpClient.cjs"),a=e=>{const t=e.getConstructableParams();return{...t,amount:t.amount.toString(),randomization:t.randomization?.toString()}},U=(e,t)=>o.httpClient.post(`${r.getRelayerURL(e)}${s.RELAYER_CONFIG.storeUnspentUtxos}`,{hashedEthereumAddress:t.hashedEthereumAddress,chainId:t.chainId,utxos:t.utxos.map(n=>a(n))}),i=(e,t)=>o.httpClient.get(`${r.getRelayerURL(e)}${s.RELAYER_CONFIG.getUnspentUtxos(t)}`),p=(e,t,n)=>o.httpClient.delete(`${r.getRelayerURL(e)}${s.RELAYER_CONFIG.deleteUnspentUtxos}`,{data:{hashedEthereumAddress:t,nullifiers:n}});exports.deleteUnspentUtxos=p;exports.getUnspentUtxos=i;exports.storeUnspentUtxos=U;

package/API/unspent-utxos-calls.d.ts

@@ -0,0 +1,26 @@
+import { IUtxoConstructor, Utxo } from '../data-structures/utxo/Utxo';
+interface StoreUnspentUtxosRequestBody {
+    hashedEthereumAddress: string;
+    chainId: number;
+    utxos: Utxo[];
+}
+interface StoreUnspentUtxosResponse {
+    status: string;
+    message: string;
+}
+export declare const storeUnspentUtxos: (chainId: number, body: StoreUnspentUtxosRequestBody) => Promise<StoreUnspentUtxosResponse>;
+interface UnspentUtxo {
+    id: string;
+    utxo: IUtxoConstructor<string>;
+}
+interface GetUnspentUtxosResponse {
+    status: string;
+    utxos: UnspentUtxo[];
+}
+export declare const getUnspentUtxos: (chainId: number, hashedEthereumAddress: string) => Promise<GetUnspentUtxosResponse>;
+interface DeleteUnspentUtxosResponse {
+    status: string;
+    message: string;
+}
+export declare const deleteUnspentUtxos: (chainId: number, hashedEthereumAddress: string, nullifiers: string[]) => Promise<DeleteUnspentUtxosResponse>;
+export {};

package/API/unspent-utxos-calls.mjs

@@ -0,0 +1,27 @@
+import { RELAYER_CONFIG as o } from "../constants/server.constants.mjs";
+import { getRelayerURL as s } from "./getRelayerURL.mjs";
+import { httpClient as r } from "../data-structures/http/HttpClient.mjs";
+const a = (e) => {
+  const t = e.getConstructableParams();
+  return {
+    ...t,
+    amount: t.amount.toString(),
+    randomization: t.randomization?.toString()
+  };
+}, U = (e, t) => r.post(`${s(e)}${o.storeUnspentUtxos}`, {
+  hashedEthereumAddress: t.hashedEthereumAddress,
+  chainId: t.chainId,
+  utxos: t.utxos.map((n) => a(n))
+}), d = (e, t) => r.get(
+  `${s(e)}${o.getUnspentUtxos(t)}`
+), u = (e, t, n) => r.delete(
+  `${s(e)}${o.deleteUnspentUtxos}`,
+  {
+    data: { hashedEthereumAddress: t, nullifiers: n }
+  }
+);
+export {
+  u as deleteUnspentUtxos,
+  d as getUnspentUtxos,
+  U as storeUnspentUtxos
+};

package/API/weeklyAnalyticCalls.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./getServerURL.cjs"),a=require("../constants/server.constants.cjs"),s=require("../data-structures/http/HttpClient.cjs");require("axios");const n=async({ethereumAddress:t})=>await s.httpClient.get(`${r.DATA_SERVER_URL}${a.DATA_SERVER_CONFIG.getUserAnalytics}`,{params:{ethereumAddress:t}}),o=async({brotherhoodId:t,ethereumAddress:e})=>await s.httpClient.get(`${r.DATA_SERVER_URL}${a.DATA_SERVER_CONFIG.getBrotherhoodAnalytics}`,{params:{brotherhoodId:t,ethereumAddress:e}});exports.getBrotherhoodAnalytics=o;exports.getUserAnalytics=n;

package/API/weeklyAnalyticCalls.d.ts

@@ -0,0 +1,22 @@
+import { AllPoints, BrotherhoodWeeklyAnalytic, UserWeeklyAnalytic } from '../types';
+interface GetUserAnalyticsProps {
+    ethereumAddress: string;
+}
+interface GetUserAnalyticsRes {
+    success: boolean;
+    currentWeek: UserWeeklyAnalytic;
+    previousWeeks: UserWeeklyAnalytic[];
+    allTime: AllPoints;
+}
+export declare const getUserAnalytics: ({ ethereumAddress }: GetUserAnalyticsProps) => Promise<GetUserAnalyticsRes>;
+interface GetBrotherhoodAnalyticsRes {
+    success: boolean;
+    currentWeek: BrotherhoodWeeklyAnalytic | undefined;
+    allTime: AllPoints | undefined;
+}
+interface GetBrotherhoodAnalyticsProps {
+    brotherhoodId?: number;
+    ethereumAddress?: string | undefined | null;
+}
+export declare const getBrotherhoodAnalytics: ({ brotherhoodId, ethereumAddress, }: GetBrotherhoodAnalyticsProps) => Promise<GetBrotherhoodAnalyticsRes>;
+export {};

package/API/weeklyAnalyticCalls.mjs

@@ -0,0 +1,16 @@
+import { DATA_SERVER_URL as r } from "./getServerURL.mjs";
+import { DATA_SERVER_CONFIG as o } from "../constants/server.constants.mjs";
+import { httpClient as e } from "../data-structures/http/HttpClient.mjs";
+import "axios";
+const p = async ({ ethereumAddress: t }) => await e.get(`${r}${o.getUserAnalytics}`, {
+  params: { ethereumAddress: t }
+}), A = async ({
+  brotherhoodId: t,
+  ethereumAddress: a
+}) => await e.get(`${r}${o.getBrotherhoodAnalytics}`, {
+  params: { brotherhoodId: t, ethereumAddress: a }
+});
+export {
+  A as getBrotherhoodAnalytics,
+  p as getUserAnalytics
+};

package/README.md

@@ -74,6 +74,67 @@ function actionPrivateWallet(
 
 where onChainCreation indicates the amounts of tokens that are uncertain before the transaction is executed on-chain. The ops array contains encoded user operations.
 
+##### User operations
+
+To generate user operations (`ops`) you will need the `emporiumOp` function.
+```typescript
+import {emporiumOp} from "@hinkal/common";
+```
+
+The function accepts the following arguments:
+  1. `endpoint` *(required)* - target address or contract instance (with address). The contract instance will be used to properly encode the call function, if any, in the custom operation.
+  2. `func` *(optional)* - the name of the function to be called on the target address.
+  3. `args` *(optional)* - arguments of the function to be called on the target address.
+  4. `invokeWallet` *(optional)* - bool flag that determines the type of transaction. There are two types: stateful and stateless interaction. The default is false (stateless).
+  5. `value` *(optional)* - the amount of native currency to transfer to the target address.
+
+The `emporiumOp` function will generate data for subsequent calls, supporting both stateful interaction (with state preservation) and stateless interaction (without state preservation). This is determined by the `invokeWallet` flag.
+
+To execute on a smart contract, the user operation will be received in the following format:
+```solidity
+(address endpoint, bool invokeWallet, uint256 value, bytes data)
+```
+
+This will make it possible to make that kind of call:
+```solidity
+(bool success, bytes memory err) = endpoint.call{value: value}(data);
+```
+
+##### Stateless and stateful
+
+The best way to demonstrate how this works is with an example.
+
+**Stateless interaction**
+
+Let's say we need to exchange USDC for ETH using DEX. 
+
+```typescript
+const operations = [
+  emporiumOp(usdcContractInstance, 'approve', [swapRouterAddress, amountIn]),
+  emporiumOp(swapRouterContractInstance, 'exactInputSingle', [swapSingleParams]),
+  emporiumOp(wethContractInstance, 'withdraw', [amountOut]),
+];
+```
+
+To perform a DEX swap, DEX does not need to know historical data about the calling party (e.g. when and what swaps have been performed from this account in the past). It only needs the current token balance for the exchange.
+
+In this case it will be **stateless interaction**, so there is no need to change the default value of the `invokeWallet` flag.
+
+**Stateful interaction**
+
+Another example is when the protocol with which an account interacts needs to know what actions this account has done before, for example, to gain rewards. In this case, some account state will be required.
+
+Let's imagine that you already have Curve LP tokens and need to make a stake.
+
+```solidity
+const operations = [
+  emporiumOp(lpTokenInstance, 'approve', [gaugeAddressInstance, amount]), // without flag, because is's stateless interaction
+  emporiumOp(gaugeAddressInstance, 'deposit', [amount, invokeWalletAddress], true), // with flag, because it's stateful interaction
+];
+```
+
+As you can see, in this case `approve` is a stateless interaction, but `deposit` is a stateful interaction, because under the hood Curve will record this address and timestamp in order to calculate the checkpoint correctly in the future.
+
 ### Access Tokens
 
 Before interacting with Hinkal smart contracts, users need to mint an access token after passing compliance checks.

package/constants/activity.constants.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("../types/circom-data.types.cjs");require("../types/transactions.types.cjs");const t=require("../types/activities.types.cjs"),e=[t.ActivityTypes.SHIELD,t.ActivityTypes.RECIEVE,t.ActivityTypes.ONBOARDING_DEPOSIT,t.ActivityTypes.SEND,t.ActivityTypes.UNSHIELD,t.ActivityTypes.DAPP_INTERACTION];exports.TVL_CHANGER_ACTIVITY_TYPES=e;

package/constants/activity.constants.d.ts

@@ -0,0 +1,2 @@
+import { ActivityTypes } from '../types';
+export declare const TVL_CHANGER_ACTIVITY_TYPES: ActivityTypes[];