@gurge/sdk 0.3.5 → 0.3.8

package/common/src/API/API.d.ts

@@ -0,0 +1,127 @@
+import { getIdleRelay } from './relayCalls';
+import { getTokenPreviousDayPrices, getTokenPrices } from './getTokenPrice';
+import { getReclaimVerificationRequest, getUserKycStatus, getZkMeAccessToken, setAiPriseVerificationUrl } from './kycCalls';
+import { getOdosPriceForToken } from './callOdosAPI';
+import { simulateTransaction } from './simulate-transaction';
+import { simulateBatchTx } from './simulate-batch-tx';
+import { tokensInfoCall } from './token-calls';
+import { getTokenData } from './get-token-data';
+import { decryptUtxoEnclaveCall, getUtxosEnclaveCall, storeUtxoEnclaveCall } from './enclaveUtxoCalls';
+import { generateAumPoints, generateTradingPoints } from './generate-trading-points';
+import { createBrotherhood, editBrotherhood, getBrotherhood, getBrotherhoodUsers, getCurrentUserBrotherhood, getCurrentUserBrotherhoodUsers, getPublicBrotherhoods, joinBrotherhood, leaveBrotherhood } from './brotherhoodCalls';
+import { getBrotherhoodsLeaderboard, getUserCurrentLeaderboard } from './leaderboardCalls';
+import { getCurrentUserAppliedReferralCode, getCurrentUserReferral, submitReferralCode } from './referralsCalls';
+import { getAccessCodeBenefits, submitAccessCode } from './accessCodeCalls';
+import { checkUsernameAvailability, connectRewardsUser, disconnectSocialNetwork, getNftMultiplier, getRewardsUser, getSwapStreak, getTasksProgress, updateRewardsUser } from './rewardsUserCalls';
+import { getBrotherhoodAnalytics, getUserAnalytics } from './weeklyAnalyticCalls';
+import { sendTelegramCallback } from './send-telegram-callback';
+import { getProxyAccounts, updateProxyAccounts } from './proxyAccountsCalls';
+import { monitor } from './callMonitor';
+import { callRelayerSolanaTransactBatchAPI } from './callRelayer';
+import { seedlessBackup, seedlessCheckPassword, seedlessInit, seedlessSalt, seedlessStatus } from './seedless-calls';
+import { getScheduledTransactions } from './scheduled-transactions-calls';
+import { addTemporaryWalletNonce, getTemporaryWalletNonces, removeTemporaryWalletNonce } from './temporaryWalletCalls';
+import { encodeMoonPayBuyUrl, generateMoonPayQuote } from './onrampCalls';
+import { getTokenPriceChartData } from './get-token-price-chart-data';
+import { getPrivateTransactionRatio, savePrivacyScoreAndGetPrivacyRank } from './privacy-score-calls';
+import { allocatePrivateSendRecipientInfos } from './privateSendRecipientInfoCalls';
+import { reservePrivateSendNonceRange, syncPrivateSendNonce } from './privateSendNonceCalls';
+import { getSnapshotServerEvents } from './snapshot-event-calls';
+import { sendPrivateSendEmailNotifications } from './privateSendEmailNotificationsCalls';
+import { checkTronSubsidyEligibility, recordTronSubsidyUsage } from './tronSubsidyCalls';
+import { deleteDashboardAccount, getDashboardAccount, updateDashboardAccount } from './dashboardAccountCalls';
+import { addDashboardContact, deleteDashboardContact, getDashboardContacts, updateDashboardContact } from './dashboardContactCalls';
+import { changePayoutStatus, createDashboardPayout, getDashboardPayouts } from './dashboardPayoutCalls';
+import { editMember, removeMember, sendDashboardInvitationEmail, updateUserProfile } from './dashboardAccountMemberCalls';
+import { getDashboardBalances, syncDashboardBalances } from './dashboardBalanceCalls';
+import { createDashboardTransactions, getDashboardTransactions } from './dashboardTransactionCalls';
+export type IAPI = {
+    getUserKycStatus: typeof getUserKycStatus;
+    setAiPriseVerificationUrl: typeof setAiPriseVerificationUrl;
+    getReclaimVerificationRequest: typeof getReclaimVerificationRequest;
+    getZkMeAccessToken: typeof getZkMeAccessToken;
+    getTokenPrices: typeof getTokenPrices;
+    getOdosPriceForToken: typeof getOdosPriceForToken;
+    getTokenPriceChartData: typeof getTokenPriceChartData;
+    getTokenPreviousDayPrices: typeof getTokenPreviousDayPrices;
+    getIdleRelay: typeof getIdleRelay;
+    simulateTransaction: typeof simulateTransaction;
+    simulateBatchTx: typeof simulateBatchTx;
+    tokensInfoCall: typeof tokensInfoCall;
+    getTokenData: typeof getTokenData;
+    decryptUtxoEnclaveCall: typeof decryptUtxoEnclaveCall;
+    storeUtxoEnclaveCall: typeof storeUtxoEnclaveCall;
+    getUtxosEnclaveCall: typeof getUtxosEnclaveCall;
+    generateTradingPoints: typeof generateTradingPoints;
+    getBrotherhoodUsers: typeof getBrotherhoodUsers;
+    getCurrentUserBrotherhoodUsers: typeof getCurrentUserBrotherhoodUsers;
+    editBrotherhood: typeof editBrotherhood;
+    createBrotherhood: typeof createBrotherhood;
+    getCurrentUserBrotherhood: typeof getCurrentUserBrotherhood;
+    getPublicBrotherhoods: typeof getPublicBrotherhoods;
+    leaveBrotherhood: typeof leaveBrotherhood;
+    joinBrotherhood: typeof joinBrotherhood;
+    getUserAnalytics: typeof getUserAnalytics;
+    connectRewardsUser: typeof connectRewardsUser;
+    getBrotherhood: typeof getBrotherhood;
+    updateRewardsUser: typeof updateRewardsUser;
+    getRewardsUser: typeof getRewardsUser;
+    checkUsernameAvailability: typeof checkUsernameAvailability;
+    getUserCurrentLeaderboard: typeof getUserCurrentLeaderboard;
+    getBrotherhoodsLeaderboard: typeof getBrotherhoodsLeaderboard;
+    getCurrentUserReferral: typeof getCurrentUserReferral;
+    submitReferralCode: typeof submitReferralCode;
+    getCurrentUserAppliedReferralCode: typeof getCurrentUserAppliedReferralCode;
+    submitAccessCode: typeof submitAccessCode;
+    getAccessCodeBenefits: typeof getAccessCodeBenefits;
+    sendTelegramCallback: typeof sendTelegramCallback;
+    generateAumPoints: typeof generateAumPoints;
+    getSwapStreak: typeof getSwapStreak;
+    getBrotherhoodAnalytics: typeof getBrotherhoodAnalytics;
+    getTasksProgress: typeof getTasksProgress;
+    disconnectSocialNetwork: typeof disconnectSocialNetwork;
+    getProxyAccounts: typeof getProxyAccounts;
+    updateProxyAccounts: typeof updateProxyAccounts;
+    getNftMultiplier: typeof getNftMultiplier;
+    monitor: typeof monitor;
+    callRelayerSolanaTransactBatchAPI: typeof callRelayerSolanaTransactBatchAPI;
+    seedlessInit: typeof seedlessInit;
+    seedlessBackup: typeof seedlessBackup;
+    seedlessCheckPassword: typeof seedlessCheckPassword;
+    seedlessStatus: typeof seedlessStatus;
+    seedlessSalt: typeof seedlessSalt;
+    getScheduledTransactions: typeof getScheduledTransactions;
+    getTemporaryWalletNonces: typeof getTemporaryWalletNonces;
+    addTemporaryWalletNonce: typeof addTemporaryWalletNonce;
+    removeTemporaryWalletNonce: typeof removeTemporaryWalletNonce;
+    encodeMoonPayBuyUrl: typeof encodeMoonPayBuyUrl;
+    generateMoonPayQuote: typeof generateMoonPayQuote;
+    getPrivateTransactionRatio: typeof getPrivateTransactionRatio;
+    savePrivacyScoreAndGetPrivacyRank: typeof savePrivacyScoreAndGetPrivacyRank;
+    allocatePrivateSendRecipientInfos: typeof allocatePrivateSendRecipientInfos;
+    syncPrivateSendNonce: typeof syncPrivateSendNonce;
+    reservePrivateSendNonceRange: typeof reservePrivateSendNonceRange;
+    getSnapshotServerEvents: typeof getSnapshotServerEvents;
+    sendPrivateSendEmailNotifications: typeof sendPrivateSendEmailNotifications;
+    checkTronSubsidyEligibility: typeof checkTronSubsidyEligibility;
+    recordTronSubsidyUsage: typeof recordTronSubsidyUsage;
+    getDashboardAccount: typeof getDashboardAccount;
+    updateDashboardAccount: typeof updateDashboardAccount;
+    deleteDashboardAccount: typeof deleteDashboardAccount;
+    updateUserProfile: typeof updateUserProfile;
+    addDashboardContact: typeof addDashboardContact;
+    deleteDashboardContact: typeof deleteDashboardContact;
+    updateDashboardContact: typeof updateDashboardContact;
+    getDashboardContacts: typeof getDashboardContacts;
+    sendDashboardInvitationEmail: typeof sendDashboardInvitationEmail;
+    removeMember: typeof removeMember;
+    editMember: typeof editMember;
+    createDashboardPayout: typeof createDashboardPayout;
+    getDashboardPayouts: typeof getDashboardPayouts;
+    syncDashboardBalances: typeof syncDashboardBalances;
+    getDashboardBalances: typeof getDashboardBalances;
+    changePayoutStatus: typeof changePayoutStatus;
+    createDashboardTransactions: typeof createDashboardTransactions;
+    getDashboardTransactions: typeof getDashboardTransactions;
+};
+export declare const API: IAPI;

package/common/src/API/accessCodeCalls.d.ts

@@ -0,0 +1,23 @@
+interface SubmitAccessCodeProps {
+    accessCode: string;
+    ethereumAddress: string;
+    signature: string;
+    proxyAddress: string;
+}
+export interface SubmitAccessCodeRes {
+    message: string;
+    success: boolean;
+    benefits?: {
+        instantPoints: number;
+        multiplier: number;
+        multiplierDurationDays: number;
+    };
+}
+export declare const submitAccessCode: ({ accessCode, ethereumAddress, signature, proxyAddress, }: SubmitAccessCodeProps) => Promise<SubmitAccessCodeRes>;
+export interface GetAccessCodeBenefitsRes {
+    instantPoints: number;
+    multiplier: number;
+    multiplierDurationDays: number;
+}
+export declare const getAccessCodeBenefits: (accessCode: string) => Promise<GetAccessCodeBenefitsRes>;
+export {};

package/common/src/API/admin-calls.d.ts

@@ -0,0 +1,9 @@
+import { AdminDataType } from '../types/admin.types';
+export declare const emitTxPublicData: (adminData: AdminDataType | undefined) => Promise<any>;
+export declare const emitReferralTx: (payload: {
+    txHash: string;
+    ref: string;
+    chainId: number;
+    tokenAddresses: string[];
+    amountChanges: number[];
+}) => Promise<any>;

package/common/src/API/brotherhoodCalls.d.ts

@@ -0,0 +1,82 @@
+import { Brotherhood, BrotherhoodUser, BrotherhoodUserWeeklyAnalyticLeaderboardEntry, PublicBrotherhoodWithStats } from '../types';
+interface GetBrotherhoodProps {
+    brotherhoodId: number;
+}
+interface GetBrotherhoodRes {
+    brotherhood: Brotherhood | undefined;
+}
+export declare const getBrotherhood: ({ brotherhoodId }: GetBrotherhoodProps) => Promise<GetBrotherhoodRes>;
+interface GetBrotherhoodUsersRes {
+    message: number;
+    brotherhoodUsers: BrotherhoodUser[];
+    brotherhoodUserWeeklyAnalytics: BrotherhoodUserWeeklyAnalyticLeaderboardEntry[];
+}
+export declare const getBrotherhoodUsers: (brotherhoodId: number) => Promise<GetBrotherhoodUsersRes>;
+export declare const getCurrentUserBrotherhoodUsers: (ethereumAddress: string) => Promise<GetBrotherhoodUsersRes>;
+interface EditBrotherhoodProps {
+    ethereumAddress: string;
+    name: string;
+    isPublic: boolean;
+    description: string;
+    signature?: string;
+    proxyAddress?: string;
+    profileImage: string | undefined;
+    inviteButtonName: string | undefined;
+    inviteButtonLink: string | undefined;
+}
+interface EditBrotherhoodRes {
+    message: string;
+    brotherhood: Brotherhood;
+}
+export declare const editBrotherhood: (inputData: EditBrotherhoodProps) => Promise<EditBrotherhoodRes>;
+interface CreateBrotherhoodProps {
+    ethereumAddress: string;
+    profileImage: string | undefined;
+    name: string;
+    isPublic: boolean;
+    description: string;
+    signature?: string;
+    proxyAddress?: string;
+}
+interface CreateBrotherhoodRes {
+    message: string;
+    brotherhood: Brotherhood;
+}
+export declare const createBrotherhood: (inputData: CreateBrotherhoodProps) => Promise<CreateBrotherhoodRes>;
+interface GetCurrentUserBrotherhoodProps {
+    ethereumAddress: string;
+}
+interface GetCurrentUserBrotherhoodRes {
+    message: string;
+    brotherhood: Brotherhood | undefined;
+}
+export declare const getCurrentUserBrotherhood: ({ ethereumAddress, }: GetCurrentUserBrotherhoodProps) => Promise<GetCurrentUserBrotherhoodRes>;
+interface GetPublicBrotherhoodsRes {
+    message: string;
+    brotherhoods: PublicBrotherhoodWithStats[];
+}
+export declare const getPublicBrotherhoods: () => Promise<GetPublicBrotherhoodsRes>;
+interface LeaveBrotherhoodProps {
+    brotherhoodId: number;
+    transferEthereumAddress: string | undefined;
+    ethereumAddress: string;
+    signature: string;
+    proxyAddress: string;
+}
+interface LeaveBrotherhoodRes {
+    message: string;
+}
+export declare const leaveBrotherhood: ({ brotherhoodId, transferEthereumAddress, ethereumAddress, signature, proxyAddress, }: LeaveBrotherhoodProps) => Promise<LeaveBrotherhoodRes>;
+interface JoinBrotherhoodProps {
+    ethereumAddress: string;
+    brotherhoodId: number;
+    signature: string;
+    invitationToken?: string;
+    proxyAddress: string;
+}
+interface JoinBrotherhoodRes {
+    message: string;
+    brotherhood: Brotherhood;
+}
+export declare const joinBrotherhood: ({ brotherhoodId, ethereumAddress, signature, invitationToken, proxyAddress, }: JoinBrotherhoodProps) => Promise<JoinBrotherhoodRes>;
+export {};

package/common/src/API/callLifiAPI.d.ts

@@ -0,0 +1,33 @@
+export interface LifiRequestData {
+    fromChain: number;
+    toChain: number;
+    fromToken: string;
+    toToken: string;
+    fromAddress: string;
+    toAddress?: string;
+    fromAmount: string;
+    order: 'FASTEST' | 'CHEAPEST';
+    slippage: number;
+}
+export interface LifiBridgeResponse {
+    id: string;
+    type: 'swap' | 'cross' | 'lifi';
+    tool: string;
+    transactionRequest: {
+        from: string;
+        to: string;
+        chainId: string;
+        value: string;
+        data: string;
+    };
+    estimate: {
+        tool: string;
+        fromAmount: string;
+        toAmount: string;
+        toAmountMin: string;
+    };
+}
+export declare const callLifiAPI: (requestBody: LifiRequestData) => Promise<{
+    status: "success";
+    lifiResponse: LifiBridgeResponse;
+}>;

package/common/src/API/callMonitor.d.ts

@@ -0,0 +1,9 @@
+export declare const monitor: (address: string) => Promise<void>;
+type MonitorBatchResponse = {
+    riskyAddresses: {
+        address: string;
+        blockedReason?: string;
+    }[];
+};
+export declare const monitorBatch: (addresses: string[]) => Promise<MonitorBatchResponse>;
+export {};

package/common/src/API/callNearIntentsAPI.d.ts

@@ -0,0 +1,3 @@
+import { NearIntentsQuoteRequest, NearIntentsQuoteResponse, NearIntentsToken } from '../types/near-intents.types';
+export declare const getNearIntentsQuote: (requestBody: NearIntentsQuoteRequest) => Promise<NearIntentsQuoteResponse>;
+export declare const getNearIntentsTokens: () => Promise<NearIntentsToken[]>;

package/common/src/API/callOdosAPI.d.ts

@@ -0,0 +1,63 @@
+export interface OdosSwapRequest {
+    chainId: number;
+    inputTokens: {
+        tokenAddress: string;
+        amount: string;
+    }[];
+    outputTokens: {
+        tokenAddress: string;
+        proportion: number;
+    }[];
+    userAddr: string;
+    gasPrice?: number;
+    slippageLimitPercent?: number;
+    sourceBlacklist?: Array<string>;
+    sourceWhitelist?: Array<string>;
+    simulate?: boolean;
+    pathVizImage?: string;
+    pathVizImageConfig?: {
+        linkColors?: string[];
+        nodeColor?: string;
+        nodeTextColor?: string;
+        legendTextColor?: string;
+        width: number;
+        height: number;
+    };
+    disableRFQs?: boolean;
+    referralCode?: string;
+    compact?: boolean;
+    likeAsset?: boolean;
+}
+export interface OdosSwapData {
+    blockNumber: number;
+    gasEstimate: number;
+    gasEstimateValue: number;
+    inputTokens: {
+        tokenAddress: string;
+        amount: number;
+    }[];
+    outputTokens: {
+        tokenAddress: string;
+        amount: number;
+    }[];
+    netOutValues: Array<number>;
+    outValues: Array<string>;
+    transaction: {
+        gas: number;
+        gasPrice: number;
+        chainId: number;
+        value: string;
+        to: string;
+        data: string;
+        nonce: number;
+    };
+    simulation: {
+        isSuccess: boolean;
+        amountsOut: Array<number>;
+        simGasUsed: number;
+        gasEstimate: number;
+        simulationError: string;
+    };
+}
+export declare function callOdosAPI(chainId: number, requestBody: OdosSwapRequest): Promise<any>;
+export declare const getOdosPriceForToken: (chainId: number, tokenAddress: string) => Promise<number | undefined>;

package/common/src/API/callOkxAPI.d.ts

@@ -0,0 +1,10 @@
+import { OKXQuote, OKXSwapResponse } from '../types/okx.types';
+interface OKXSwapRequest {
+    quote: OKXQuote;
+}
+export declare function callOkxAPI(requestBody: OKXSwapRequest): Promise<{
+    okxResponse: OKXSwapResponse;
+    status: string;
+    message?: string;
+}>;
+export {};

package/common/src/API/callOneInchAPI.d.ts

@@ -0,0 +1,18 @@
+export interface OneInchRequest {
+    fromTokenAddress: string;
+    toTokenAddress: string;
+    amount: bigint;
+    fromAddress: string;
+    slippage: number;
+    destReceiver?: string;
+    disableEstimate?: boolean;
+    allowPartialFill?: boolean;
+}
+export interface OneInchTx {
+    data: string;
+}
+export interface OneInchResponse {
+    tx: OneInchTx;
+    toAmount: string;
+}
+export declare const callOneInchAPI: (chainId: number, request: OneInchRequest) => Promise<OneInchResponse>;

package/common/src/API/callRelayer.d.ts

@@ -0,0 +1,41 @@
+import { CircomDataJsonType, CommitmentValidationDataType, DimDataType } from '../types/circom-data.types';
+import { AuthorizationData } from '../types/hinkal.types';
+import { AdminDataType } from '../types/admin.types';
+import { SolanaTransactionBody } from '../types/solana.types';
+export interface HinkalTransactionRequestBody {
+    chainId: number;
+    a: [string, string];
+    b: [[string, string], [string, string]];
+    c: [string, string];
+    dimData: DimDataType;
+    circomData: CircomDataJsonType;
+    commitmentValidationData?: CommitmentValidationDataType;
+    withUniswapWorkAround?: boolean;
+    authorizationData?: AuthorizationData;
+    adminData?: AdminDataType;
+    recipientAddress?: string;
+    tronProofSignature?: {
+        v: number;
+        r: string;
+        s: string;
+    };
+}
+export declare function callRelayerTransactAPI(requestBody: HinkalTransactionRequestBody): Promise<any>;
+export interface HinkalTransactionBatchRequestBody {
+    chainId: number;
+    transactions: HinkalTransactionRequestBody[];
+    hashedEthereumAddress: string;
+    txCompletionTime?: number;
+    ref?: string;
+    hashedDashboardAccountId?: string;
+}
+export interface SolanaTransactionBatchRequestBody {
+    chainId: number;
+    transactions: SolanaTransactionBody[];
+    hashedEthereumAddress: string;
+    txCompletionTime?: number;
+    ref?: string;
+    hashedDashboardAccountId?: string;
+}
+export declare function callRelayerTransactBatchAPI(requestBody: HinkalTransactionBatchRequestBody): Promise<any>;
+export declare function callRelayerSolanaTransactBatchAPI(requestBody: SolanaTransactionBatchRequestBody): Promise<any>;

package/common/src/API/checkRisk.d.ts

@@ -0,0 +1 @@
+export declare const checkRisk: (address: string) => Promise<any>;

package/common/src/API/dashboardAccountCalls.d.ts

@@ -0,0 +1,24 @@
+import { AccountMember, DashboardAccountClient } from '../types';
+interface GetAndUpdateDashboardAccountResponse {
+    dashboardAccount: DashboardAccountClient;
+    currentMember: AccountMember;
+}
+export declare const getDashboardAccount: () => Promise<GetAndUpdateDashboardAccountResponse>;
+interface UpdateDashboardAccountData {
+    organizationName?: string;
+    defaultDeliveryMethod?: string;
+    organizationEmail?: string;
+    defaultNetworkChainId?: number;
+    organizationImage?: string;
+    ethereumAddress?: string;
+    tronAddress?: string;
+    solanaAddress?: string;
+    notifications?: {
+        payoutApprovalRequested: boolean;
+        largePayoutAlerts: boolean;
+        balanceLowWarning: boolean;
+    };
+}
+export declare const updateDashboardAccount: (data: UpdateDashboardAccountData) => Promise<GetAndUpdateDashboardAccountResponse>;
+export declare const deleteDashboardAccount: () => Promise<any>;
+export {};

package/common/src/API/dashboardAccountMemberCalls.d.ts

@@ -0,0 +1,34 @@
+import { AccountMember, DashboardAccountClient } from '../types';
+interface UpdateUserProfileData {
+    username?: string;
+    email?: string;
+    profileImage?: string;
+}
+interface UpdateUserProfileResponse {
+    currentMember: AccountMember;
+}
+export declare const updateUserProfile: (data: UpdateUserProfileData) => Promise<UpdateUserProfileResponse>;
+interface SendDashboardInvitationEmailData {
+    email: string;
+    username: string;
+}
+interface SendDashboardInvitationEmailResponse {
+    updatedAccount: DashboardAccountClient;
+}
+export declare const sendDashboardInvitationEmail: ({ email, username }: SendDashboardInvitationEmailData) => Promise<SendDashboardInvitationEmailResponse>;
+interface RemoveMemberData {
+    email: string;
+}
+interface RemoveMemberResponse {
+    updatedAccount: DashboardAccountClient;
+}
+export declare const removeMember: ({ email }: RemoveMemberData) => Promise<RemoveMemberResponse>;
+interface EditMemberData {
+    email: string;
+    newUsername: string;
+}
+interface EditMemberResponse {
+    updatedAccount: DashboardAccountClient;
+}
+export declare const editMember: ({ email, newUsername }: EditMemberData) => Promise<EditMemberResponse>;
+export {};

package/common/src/API/dashboardBalanceCalls.d.ts

@@ -0,0 +1,12 @@
+import { DashboardDbBalance, DeserializedEncryptedBalances } from '../types';
+interface SyncDashboardBalancesProps {
+    privateBalances: DashboardDbBalance[];
+    publicBalances: DashboardDbBalance[];
+}
+export declare const syncDashboardBalances: ({ privateBalances, publicBalances }: SyncDashboardBalancesProps) => Promise<any>;
+interface SyncDashboardBalancesResponse {
+    balances: DeserializedEncryptedBalances;
+    updatedAt: string;
+}
+export declare const getDashboardBalances: () => Promise<SyncDashboardBalancesResponse>;
+export {};

package/common/src/API/dashboardContactCalls.d.ts

@@ -0,0 +1,9 @@
+import { Contact } from '../types';
+interface ContactResponse {
+    contacts: Contact[];
+}
+export declare const addDashboardContact: (contact: Contact) => Promise<ContactResponse>;
+export declare const deleteDashboardContact: (contact: Contact) => Promise<ContactResponse>;
+export declare const updateDashboardContact: (contact: Contact, contactToEditAddress: string) => Promise<ContactResponse>;
+export declare const getDashboardContacts: () => Promise<ContactResponse>;
+export {};

package/common/src/API/dashboardPayoutCalls.d.ts

@@ -0,0 +1,14 @@
+import { DashboardPayout, PayoutItem, PayoutStatus } from '../types';
+interface CreateDashboardPayoutResponse {
+    payout: DashboardPayout;
+}
+export declare const createDashboardPayout: ({ payoutItems }: {
+    payoutItems: PayoutItem[];
+}) => Promise<CreateDashboardPayoutResponse>;
+export declare const getDashboardPayouts: () => Promise<any>;
+interface ChangePayoutStatusProps {
+    payoutId: string;
+    status: PayoutStatus;
+}
+export declare const changePayoutStatus: ({ payoutId, status }: ChangePayoutStatusProps) => Promise<any>;
+export {};

package/common/src/API/dashboardTransactionCalls.d.ts

@@ -0,0 +1,3 @@
+import { DashboardTransaction } from '../types';
+export declare const createDashboardTransactions: (transactions: Omit<DashboardTransaction, "hashedDashboardAccountId">[]) => Promise<any>;
+export declare const getDashboardTransactions: () => Promise<any>;

package/common/src/API/deposit-and-withdraw-status-calls.d.ts

@@ -0,0 +1,21 @@
+import { DepositAndWithdrawPhase } from '../types';
+interface UpdateDepositAndWithdrawStatusRequestBody {
+    id?: string;
+    hashedEthereumAddress: string;
+    chainId: number;
+    phase: DepositAndWithdrawPhase;
+    depositTxHash?: string;
+    scheduleId?: string;
+}
+interface DepositAndWithdrawStatusResponse {
+    status: string;
+    id?: string;
+    message?: string;
+    phase?: DepositAndWithdrawPhase;
+    depositTxHash?: string;
+    scheduleId?: string;
+    updatedAt?: string;
+}
+export declare const updateDepositAndWithdrawStatus: (body: UpdateDepositAndWithdrawStatusRequestBody) => Promise<DepositAndWithdrawStatusResponse>;
+export declare const safeUpdateDepositAndWithdrawStatus: (body: UpdateDepositAndWithdrawStatusRequestBody) => Promise<DepositAndWithdrawStatusResponse | undefined>;
+export {};

package/common/src/API/enclaveRecipientInfoCalls.d.ts

@@ -0,0 +1,14 @@
+interface StoreRecipientInfosRequest {
+    ethAddress: string;
+    encryptedSignature: string;
+    key: string;
+    targetCount: number;
+    isSolanaLedger: boolean;
+    txMessageForSolanaLedger: string | undefined;
+}
+interface StoreRecipientInfosResponse {
+    status: 'success';
+    generated: number;
+}
+export declare const storeRecipientInfosViaEnclave: (request: StoreRecipientInfosRequest) => Promise<StoreRecipientInfosResponse>;
+export {};

package/common/src/API/enclaveSignatureCalls.d.ts

@@ -0,0 +1,5 @@
+interface IStoreAndGetSignatureResponse {
+    signature: string;
+}
+export declare const storeAndGetSignatureEnclaveCall: (ethAddress: string, encryptedSignature: string, key: string, isSolanaLedger: boolean, txMessageForSolanaLedger?: string) => Promise<IStoreAndGetSignatureResponse>;
+export {};

package/common/src/API/enclaveUtxoCalls.d.ts

@@ -0,0 +1,46 @@
+import { EncryptedOutputWithSign } from '../types/commitments.types';
+import { IUtxoConstructor } from '../data-structures/utxo/Utxo';
+type DecryptUtxoEnclaveCallResponse = {
+    utxos: IUtxoConstructor<string>[];
+    encryptedOutputs: EncryptedOutputWithSign[];
+    lastOutput: string;
+};
+export declare const decryptUtxoEnclaveCall: (chainId: number, keyCiphertext: string, inputCiphertext: string) => Promise<DecryptUtxoEnclaveCallResponse>;
+export interface StoreUtxoRequest {
+    recipientEthAddress: string;
+    encryptedUtxo: string;
+    key: string;
+    chainId: number;
+}
+export interface StoreUtxoResponse {
+    status: 'success';
+}
+export declare const storeUtxoEnclaveCall: (recipientEthAddress: string, encryptedUtxo: string, key: string, chainId: number) => Promise<StoreUtxoResponse>;
+export interface GetUtxosRequest {
+    ethAddress: string;
+    encryptedSignature: string;
+    key: string;
+    chainId: number;
+}
+export interface UtxoResponse {
+    amount: string;
+    erc20TokenAddress: string;
+    mintAddress?: string;
+    randomization: string;
+    stealthAddress: string;
+    timeStamp: string;
+    tokenId: number;
+    senderAddress: string;
+    /** Legacy field; maps to nullifyingKey for old deposits. */
+    shieldedPrivateKey?: string;
+    nullifyingKey?: string;
+    claimableSignature?: string;
+    spendingPublicKey?: string[];
+    H0?: [string, string];
+    isNewStyle?: boolean;
+}
+export interface GetUtxosResponse {
+    utxos: UtxoResponse[];
+}
+export declare const getUtxosEnclaveCall: (ethAddress: string, encryptedSignature: string, key: string, chainId: number, isSolanaLedger: boolean, txMessageForSolanaLedger?: string) => Promise<GetUtxosResponse>;
+export {};

package/common/src/API/fetchCommitmentsCache.d.ts

@@ -0,0 +1,19 @@
+import { MerkleTreeJson } from '../data-structures/merkle-tree/MerkleTree';
+import { EncryptedOutputWithCommitment, EncryptedOutputWithSign } from '../types';
+export interface ICommitmentsTreeSnapshot {
+    merkleTree: MerkleTreeJson;
+    latestBlockNumber: number;
+    encryptedOutputs: EncryptedOutputWithSign<string>[];
+    hinkalAddress: string;
+    chainId: number;
+    encryptedOutputsByCommitment: EncryptedOutputWithCommitment[];
+}
+export interface INullifiersSnapshot {
+    nullifiers: string[];
+    latestBlockNumber: number;
+}
+export interface ISnapshotsResponse {
+    commitments: ICommitmentsTreeSnapshot;
+    nullifiers: INullifiersSnapshot;
+}
+export declare const fetchSnapshots: (chainId: number) => Promise<ISnapshotsResponse>;