@kapa123456789/sdk 0.0.1

package/common/src/types/referral.types.d.ts

@@ -0,0 +1,12 @@
+export interface FilledReferredUser {
+    referralEthereumAddress: string;
+    joinedAt: Date;
+    points: number;
+    username?: string;
+    profileImageUrl?: string;
+}
+export interface Referral {
+    ethereumAddress: string;
+    referralCode: string;
+    referredUsers: FilledReferredUser[];
+}

package/common/src/types/remote-proof.types.d.ts

@@ -0,0 +1,15 @@
+import { NewZkCallDataType } from './snark.types';
+export type HandshakeResponseType = {
+    public_key: string;
+};
+export type RemoteProofType = {
+    pi_a: string[];
+    pi_b: string[][];
+    pi_c: string[];
+    protocol: string;
+};
+export type GenerateProofResponseType = {
+    proof: RemoteProofType;
+    public_signals: string[];
+    zk_calldata: NewZkCallDataType;
+};

package/common/src/types/rewards.types.d.ts

@@ -0,0 +1,34 @@
+export declare enum OldPointType {
+    CertificationPoints = "CertificationPoints",
+    TradePoints = "TradePoints",
+    LPPoints = "LPPoints",
+    ReferralPoints = "ReferralPoints",
+    GalxePoints = "GalxePoints",
+    ZealyPoints = "ZealyPoints",
+    TaskOnPoints = "TaskOnPoints",
+    BonusPoints = "BonusPoints"
+}
+export declare enum RafflePrizeType {
+    Gold = "Gold",
+    Silver = "Silver"
+}
+export type CountDown = {
+    daysLeft: number;
+    hoursLeft: number;
+    minutesLeft: number;
+    secondsLeft: number;
+};
+export interface DailyJobLock {
+    day: Date;
+    createdAt: Date;
+}
+export interface DailyBoxCounter {
+    date: Date;
+    rank: string;
+    count: number;
+}
+export interface DailyProxyProgress {
+    day: Date;
+    address: string;
+    chainId: number;
+}

package/common/src/types/schedule.types.cjs

@@ -0,0 +1 @@
+var e=function(e){return e.INSTANTLY=`Instantly`,e.FIFTEEN_MINUTES=`15m`,e.THIRTY_MINUTES=`30m`,e.ONE_HOUR=`1hr`,e.TWENTY_FOUR_HOURS=`24hrs`,e}({});exports.ScheduleDelayOption=e;

package/common/src/types/schedule.types.d.ts

@@ -0,0 +1,7 @@
+export declare enum ScheduleDelayOption {
+    INSTANTLY = "Instantly",
+    FIFTEEN_MINUTES = "15m",
+    THIRTY_MINUTES = "30m",
+    ONE_HOUR = "1hr",
+    TWENTY_FOUR_HOURS = "24hrs"
+}

package/common/src/types/schedule.types.mjs

@@ -0,0 +1,6 @@
+//#region libs/shared/common/src/types/schedule.types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.INSTANTLY = "Instantly", e.FIFTEEN_MINUTES = "15m", e.THIRTY_MINUTES = "30m", e.ONE_HOUR = "1hr", e.TWENTY_FOUR_HOURS = "24hrs", e;
+}({});
+//#endregion
+export { e as ScheduleDelayOption };

package/common/src/types/scheduled-transactions.types.cjs

@@ -0,0 +1 @@
+var e=function(e){return e.BEFORE_DEPOSIT=`before_deposit`,e.AFTER_DEPOSIT=`after_deposit`,e.BEFORE_SCHEDULE_WITHDRAW=`before_schedule_withdraw`,e.AFTER_SCHEDULE_WITHDRAW=`after_schedule_withdraw`,e}({});exports.DepositAndWithdrawPhase=e;

package/common/src/types/scheduled-transactions.types.d.ts

@@ -0,0 +1,42 @@
+import { Utxo } from '../data-structures/utxo/Utxo';
+export declare enum ScheduledTransactionStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    WAITING_FOR_RELAYER = "waiting_for_relayer",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+export declare enum DepositAndWithdrawPhase {
+    BEFORE_DEPOSIT = "before_deposit",
+    AFTER_DEPOSIT = "after_deposit",
+    BEFORE_SCHEDULE_WITHDRAW = "before_schedule_withdraw",
+    AFTER_SCHEDULE_WITHDRAW = "after_schedule_withdraw"
+}
+export interface ScheduledTransactionResponseItem {
+    chainId: number;
+    status: ScheduledTransactionStatus;
+    scheduledTime: string;
+    erc20TokenAddresses: string[];
+    amount: string;
+    createdAt: string;
+    externalAddress: string;
+    transactionHash?: string;
+}
+export interface RecipientUtxo {
+    recipientAddress: string;
+    utxo: Utxo;
+}
+export interface ClaimableUtxo {
+    chainId: number;
+    senderAddress: string;
+    utxo: Utxo;
+}
+export interface PendingEnclaveUtxo extends ClaimableUtxo {
+    recipientAddress: string;
+}
+export interface FallbackRecipientUtxoPlan {
+    recipientIndex: number;
+    recipientAddress: string;
+    shieldedPrivateKey: string;
+    utxo: Utxo;
+}

package/common/src/types/scheduled-transactions.types.mjs

@@ -0,0 +1,6 @@
+//#region libs/shared/common/src/types/scheduled-transactions.types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.BEFORE_DEPOSIT = "before_deposit", e.AFTER_DEPOSIT = "after_deposit", e.BEFORE_SCHEDULE_WITHDRAW = "before_schedule_withdraw", e.AFTER_SCHEDULE_WITHDRAW = "after_schedule_withdraw", e;
+}({});
+//#endregion
+export { e as DepositAndWithdrawPhase };

package/common/src/types/session.types.d.ts

@@ -0,0 +1,13 @@
+export interface SessionMetadata {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+}
+export interface Session {
+    topic: string;
+    metadata: SessionMetadata;
+    chainId: number;
+    ethereumAddress: string;
+    fromInjectedConnector?: boolean;
+}

package/common/src/types/signature.types.d.ts

@@ -0,0 +1,10 @@
+import { ConfirmationRequestType } from './confirmation-request.types';
+import { AppMetaData } from './wc.types';
+export interface SignedMessage {
+    timestamp: string;
+    chainId: number;
+    messageText: string;
+    messageType: ConfirmationRequestType.PERSONAL_SIGN | ConfirmationRequestType.SIGN_TYPE_V4;
+    subAccountAddress: string;
+    appMetaData: AppMetaData;
+}

package/common/src/types/slippage.types.d.ts

@@ -0,0 +1,3 @@
+export declare enum SlippageType {
+    Swap = "Swap"
+}

package/common/src/types/snark.types.d.ts

@@ -0,0 +1,40 @@
+interface ZkBaseInputType {
+    rootHashHinkal: bigint | undefined;
+    shieldedPrivateKey: string;
+    inAmounts: string[];
+    inBlindings: string[];
+    inNullifiers: string[];
+    inCommitmentSiblings: string[][];
+    inCommitmentSiblingSides: string[][];
+    outCommitments: string[];
+    rootHashAccessToken: bigint | undefined;
+    accessTokenSiblings: string[];
+    accessTokenSiblingSides: string[];
+    relayFee: bigint;
+    relay: string;
+}
+export interface ZkInputType extends ZkBaseInputType {
+    publicAmount: bigint;
+    recipientAddress: string;
+    erc20TokenAddress: string;
+    outAmounts: string[];
+    outShieldedPublicKey: string[];
+    outBlindings: string[];
+}
+export interface ZkExternalInputType extends ZkBaseInputType {
+    inSwapAmount: bigint;
+    inErc20TokenAddress: string;
+    outAmount: bigint;
+    outBlinding: bigint;
+    outSwapAmount: bigint;
+    outErc20TokenAddress: string;
+    outSwapBlinding: bigint;
+    externalActionId: bigint;
+    externalActionMetadataHash: bigint;
+}
+export interface ZkResultType {
+    proof: string;
+    publicSignals: string[];
+}
+export type NewZkCallDataType = [[string, string], [[string, string], [string, string]], [string, string], string[]];
+export {};

package/common/src/types/solana.types.d.ts

@@ -0,0 +1,91 @@
+import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+import { CommitmentValidationDataType, DimDataType } from './circom-data.types';
+import { OKXAccount } from './okx.types';
+import { Adapter } from '@solana/wallet-adapter-base';
+import { AdminDataType } from './admin.types';
+export interface SolanaEvent {
+    signature: string;
+    slot: number;
+    blockTime: number;
+    programId: PublicKey;
+    data: any;
+    eventName: string;
+}
+export type SolanaWallet = {
+    publicKey: PublicKey;
+    signTransaction<T extends Transaction | VersionedTransaction>(tx: T): Promise<T>;
+    signAllTransactions<T extends Transaction | VersionedTransaction>(txs: T[]): Promise<T[]>;
+    signMessage: (message: Uint8Array, display?: string) => Promise<{
+        signature: Uint8Array;
+        publicKey: PublicKey;
+    }>;
+    adapter?: Adapter;
+    isLedger?: boolean;
+};
+export interface SolanaArgs {
+    proofAArr: number[];
+    proofBArr: number[];
+    proofCArr: number[];
+    publicInputsArr: number[][];
+    encryptedOutputs: number[][];
+    relayerFee: string;
+    variableRate?: string | null;
+    dimensions: DimDataType;
+}
+export type SolanaTransactArgs = SolanaArgs;
+export interface SolanaSwapArgs extends SolanaArgs {
+    hinkalInstructions: Array<{
+        accountIndexes: number[];
+        data: number[];
+        programIndex: number;
+    }>;
+}
+export interface SolanaAccounts {
+    recipient: string;
+}
+export interface SolanaTransactAccounts extends SolanaAccounts {
+    mint?: string;
+}
+export interface SolanaSwapAccounts extends SolanaAccounts {
+    storageAccount: string;
+    storageVault: string;
+    swapperAccount: string;
+    mintFrom: string | null;
+    mintTo: string | null;
+    remainingAccounts: OKXAccount[];
+    addressLookupTableAccount: string[];
+}
+export interface SolanaTransactBody {
+    relayAddress: string;
+    functionName: 'transact' | 'transfer';
+    args: SolanaTransactArgs;
+    accounts: SolanaTransactAccounts;
+}
+export interface SolanaSwapBody {
+    relayAddress: string;
+    functionName: 'swap';
+    args: SolanaSwapArgs;
+    accounts: SolanaSwapAccounts;
+}
+export interface SolanaAccessTokenData {
+    accessKey: string;
+    ethereumAddress: string;
+}
+export type SolanaTransactionBody = (SolanaTransactBody | SolanaSwapBody) & {
+    chainId: number;
+    commitmentValidationData?: CommitmentValidationDataType;
+    recipientAmount?: string;
+    solanaAccessTokenData?: SolanaAccessTokenData;
+    adminData?: AdminDataType;
+};
+export interface SolanaTransactionParams {
+    mintFrom?: string;
+    mintTo?: string;
+    recipient?: string;
+    nullifierCount?: number;
+}
+export interface SolanaAccountKeys {
+    storageAccount: string;
+    swapperAccount: string;
+    relayerPublicKey: string;
+}

package/common/src/types/tenderly.api.types.d.ts

@@ -0,0 +1,196 @@
+export interface SendTransacrtionBase {
+    blockOverrides?: {
+        number: string;
+        timestamp: string;
+    };
+    stateOverrides?: {
+        nonce: number;
+        code: string;
+        balance: {
+            value: number;
+        };
+        storage: Map<string, string>;
+    };
+}
+export type SimulateTxBody = {
+    network_id: string;
+    from: string;
+    to: string;
+    input: string;
+    gas?: number;
+    block_number?: number;
+    transaction_index?: number;
+    gas_price?: string;
+    estimate_gas?: boolean;
+    value?: string;
+    save?: boolean;
+    save_if_fails?: boolean;
+};
+export type SimulateTxResponse = {
+    transaction: {
+        hash: string;
+        block_hash: string;
+        block_number: number;
+        from: string;
+        gas: number;
+        gas_price: number;
+        input: string;
+        nonce: number;
+        to: string;
+        index: number;
+        addresses: string[];
+        contract_ids: string[];
+        network_id: string;
+        timestamp: string;
+        transaction_info: {
+            contract_address: string;
+            method: 'approve';
+            logs: any[] | null;
+            balance_diff: any[] | null;
+            nonce_diff: any[] | null;
+            state_diff: any[] | null;
+            asset_changes: any[] | null;
+            exposure_changes: any[] | null;
+            balance_changes: any[] | null;
+        };
+        call_trace: any[] | null;
+        simulation: {
+            id: string;
+            project_id: string;
+            network_id: string;
+            blocknumber: number;
+            transaction_index: number;
+            block_header: object;
+            nonce: number;
+            contracts: any[];
+        };
+    };
+    simulation: object;
+};
+export type RpcTransactionParams = {
+    from: string;
+    to: string;
+    gas: string;
+    gasPrice?: string;
+    value: string | bigint;
+    input: string;
+    maxFeePerGas?: number;
+    maxPriorityFeePerGas?: number;
+};
+export type RpcSimulateTransactionBody<T extends RpcTransactionParams | RpcTransactionParams[] = RpcTransactionParams> = {
+    params: [
+        T,
+        string | 'latest' | 'earliest' | 'pending' | 'finalized' | 'safe',
+        {
+            [key in string]: {
+                balance: string;
+                nonce?: string;
+            };
+        }
+    ];
+};
+export type StorageStateChange = {
+    address: string;
+    balance?: {
+        previousValue: string;
+        newValue: string;
+    };
+    nonce?: {
+        previousValue: string;
+        newValue: string;
+    };
+    storage?: {
+        slot: string;
+        previousValue: string;
+        newValue: string;
+        ERC20ChangeType?: 'balance' | 'allowance';
+    }[];
+};
+export type RPCSimulationAssetChange = {
+    rawAmount: string;
+    amount: string | null;
+    dollarValue?: string;
+    from: string;
+    to: string;
+    type: string;
+    id?: string;
+    assetInfo: {
+        standard: string;
+        type: string;
+        contractAddress?: string;
+        symbol?: string;
+        name?: string;
+        logo?: string;
+        decimals?: number;
+        dollarValue?: string;
+    };
+};
+export type RPCSimulationExposureChange = {
+    assetInfo: {
+        standard: string;
+        type: string;
+        contractAddress: string;
+        symbol: string;
+        name: string;
+        logo: string;
+        decimals: number;
+        dollarValue: string;
+    };
+    type: string;
+    owner: string;
+    spender: string;
+    rawAmount: string;
+    amount: string;
+    dollarValue: string;
+};
+export interface RpcTrace {
+    type: string;
+    from: string;
+    to: string;
+    gas: string;
+    gasUsed: string;
+    input: string;
+    method?: string;
+    output?: string;
+    subtraces: number;
+    traceAddress: string[];
+    value?: string;
+    error?: string;
+    errorReason?: string;
+}
+export type RpcSimulateLog = {
+    name: string;
+    inputs: {
+        value: string;
+        type: string;
+        name: string;
+        indexed: boolean;
+    }[];
+    raw: {
+        address: string;
+        data: string;
+        topics: string[];
+    };
+};
+export type RpcSimulateResult = {
+    assetChanges: RPCSimulationAssetChange[];
+    status: boolean;
+    gasUsed: string;
+    cumulativeGasUsed: string;
+    blockNumber: string;
+    type: string;
+    logsBloom: string;
+    logs: RpcSimulateLog[];
+    stateChanges: StorageStateChange[];
+    trace?: RpcTrace[];
+    exposureChanges: RPCSimulationExposureChange[];
+};
+export type RpcSimulateTransactionResponse<T extends RpcSimulateResult | RpcSimulateResult[] = RpcSimulateResult> = {
+    jsonrpc: '2.0';
+    id: 0;
+    result: T;
+    error?: {
+        code: number;
+        message: string;
+    };
+};

package/common/src/types/token-prices.types.d.ts

@@ -0,0 +1,18 @@
+export declare const TOKEN_PRICE_STATUS: {
+    readonly INITIAL: "initial";
+    readonly FETCHING: "fetching";
+    readonly ERROR: "error";
+    readonly SUCCESS: "success";
+};
+export type TokenPriceStatus = (typeof TOKEN_PRICE_STATUS)[keyof typeof TOKEN_PRICE_STATUS];
+export interface TokenPriceState {
+    tokenPriceDollar: number | undefined;
+    tokenPriceFetchStatus: TokenPriceStatus;
+}
+export declare enum TokenPriceTimeframe {
+    ONE_WEEK = "1w",
+    ONE_MONTH = "1m",
+    THREE_MONTHS = "3m",
+    ONE_YEAR = "1y",
+    ALL_TIME = "allTime"
+}

package/common/src/types/token-with-id.types.d.ts

@@ -0,0 +1,4 @@
+export interface TokenWithId {
+    erc20TokenAddress: string;
+    tokenId: number;
+}

package/common/src/types/token.types.cjs

@@ -0,0 +1 @@
+var e=function(e){return e[e.Classic=0]=`Classic`,e[e.ERC20Permit=1]=`ERC20Permit`,e[e.DAIPermit=2]=`DAIPermit`,e}({});exports.ApprovalType=e;

package/common/src/types/token.types.d.ts

@@ -0,0 +1,88 @@
+export interface ERC20Token {
+    chainId: number;
+    erc20TokenAddress: string;
+    wrappedErc20TokenAddress?: string;
+    underlyingErc20TokenAddress?: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    nftTokenType?: string;
+    logoURI?: string;
+    logoURIs?: string[];
+    whitelisted?: boolean;
+    isCustom?: true;
+    tokenIds?: string[];
+    approvalType?: ApprovalType;
+    isVolatile?: boolean;
+    sharedAddress?: string;
+    isPendleToken?: boolean;
+    isHToken?: boolean;
+    hasHToken?: boolean;
+    aaveToken?: boolean;
+    allowanceStorageOffset?: number;
+    balanceStorageOffset?: number;
+    isVyper?: boolean;
+    isSpam?: boolean;
+    is2022Program?: boolean;
+}
+export declare enum ApprovalType {
+    Classic = 0,
+    ERC20Permit = 1,
+    DAIPermit = 2
+}
+export interface NFT {
+    tokenId: number;
+    image?: string;
+    name?: string;
+    timestamp?: string;
+}
+export interface TokenBalance {
+    token: ERC20Token;
+    balance: bigint;
+    timestamp?: string;
+    nfts?: NFT[];
+}
+export interface TokenBalanceWithUsdValue extends TokenBalance {
+    isBalanceLoading?: boolean;
+    usdValue?: number;
+    isUsdValueLoading?: boolean;
+}
+export interface PublicTokenBalances {
+    publicTokenBalances: TokenBalance[];
+    isPublicBalancesLoading: boolean;
+}
+export interface PublicTokenBalancesWithUsd {
+    publicTokenBalancesWithUSD: TokenBalanceWithUsdValue[];
+    publicTotalUSDBalances: number;
+    isPublicBalancesLoading: boolean;
+    isUsdBalanceLoading: boolean;
+}
+export interface TokenChanges<T = number> {
+    token: ERC20Token;
+    amount: T;
+    nftIds?: string[];
+}
+export interface GasTokensInfoEntry {
+    token: ERC20Token;
+    balance: string;
+    dollarValue: number;
+    isLoading: boolean;
+    isInsufficientGasBalance: boolean;
+    disabled: boolean;
+}
+export type VolatileTokenChange = {
+    tokenAddress: string;
+    amount: string;
+    targetAddress?: string;
+    originalIndex: number;
+};
+export interface PrivateRecipientInfo {
+    recipientInfo: string;
+    amount: bigint;
+    token: ERC20Token;
+}
+export interface TemporaryWalletBalance extends TokenBalanceWithUsdValue {
+    nonce: number;
+    ethAddress: string;
+    privateKey: string;
+}

package/common/src/types/token.types.mjs

@@ -0,0 +1,6 @@
+//#region libs/shared/common/src/types/token.types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e[e.Classic = 0] = "Classic", e[e.ERC20Permit = 1] = "ERC20Permit", e[e.DAIPermit = 2] = "DAIPermit", e;
+}({});
+//#endregion
+export { e as ApprovalType };

package/common/src/types/transaction.types.cjs

@@ -0,0 +1 @@
+var e=function(e){return e.ReceiveFromShieldedAccount=`ReceiveFromShieldedAccount`,e.SwapTokens=`SwapTokens`,e.PrivateTransactionFromProxy=`PrivateTransactionFromProxy`,e.ProxySend=`ProxySend`,e.Send=`Send`,e.Fund=`Fund`,e.ProxySwapTokens=`ProxySwapTokens`,e.BatchTransaction=`BatchTransaction`,e.SignSolanaTransaction=`SignSolanaTransaction`,e.SignAndSendSolanaTransaction=`SignAndSendSolanaTransaction`,e}({});exports.TransactionRequestType=e;