@sabaaa1/common 0.0.7 → 0.0.8

package/types/sandbox.types.d.ts

@@ -0,0 +1,205 @@
+import { MerkleTreeJson } from '../data-structures/merkle-tree/MerkleTree';
+import { TokenAmountInfo } from './activities.types';
+import { type TypedData } from './circom-data.types';
+import { EncryptedOutputWithSign } from './commitments.types';
+import { ExternalActionId } from './external-action.types';
+import { type ApprovedUtxo, type FeeStructure, IntegrationProvider, type ParsedInLogicMetadata } from './hinkal.types';
+import { SubAccount } from './proxy.types';
+import { RelayerTransaction } from './relayer.types';
+import type { ERC20Token, TokenChanges } from './token.types';
+import type { AppMetaData, WCTransactionParameters } from './wc.types';
+import { WithId } from './with-id.types';
+import { AdminTransactionType } from './admin.types';
+export declare enum SandboxRequestType {
+    ReceiveFromShieldedAccount = "ReceiveFromShieldedAccount",
+    SwapTokens = "SwapTokens",
+    ShieldTokens = "ShieldTokens",
+    SignMessage = "SignMessage",
+    FundApproveAndTransact = "FundApproveAndTransact",
+    PrivateTransactionFromProxy = "PrivateTransactionFromProxy",
+    Approve = "Approve",
+    InsideTransact = "InsideTransact",
+    FundAndApprove = "FundAndApprove",
+    ProxySend = "ProxySend",
+    Send = "Send",
+    Fund = "Fund",
+    ProxySwapTokens = "ProxySwapTokens",
+    BatchTransaction = "BatchTransaction"
+}
+export interface SandboxTransferableTransaction {
+    hash: string;
+    from: string;
+    to: string;
+    gas: bigint;
+    gasPrice: bigint;
+    value: bigint;
+    isRelayerOff: boolean;
+}
+export interface TransferTokenRequest {
+    type: SandboxRequestType.Send | SandboxRequestType.Fund;
+    amounts: bigint[];
+    erc20Tokens: ERC20Token[];
+    to: string;
+    isRelayerOff: boolean;
+    ownerPublicAddress: string;
+    action: AdminTransactionType;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+}
+export interface PrivateTransactionBaseRequest {
+    appMetaData: AppMetaData;
+    ownerPublicAddress: string;
+    feeStructure?: FeeStructure;
+}
+export interface FundApproveAndTransactRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.FundApproveAndTransact;
+    spenderAddress: string;
+    subAccount: SubAccount;
+    tokenChanges: TokenChanges<bigint>[];
+    txParams: WCTransactionParameters;
+    autoDepositBack: boolean;
+    maxGasInDollar?: string;
+}
+export interface PrivateTransactionFromProxyRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.PrivateTransactionFromProxy;
+    subAccount: SubAccount;
+    tokenChanges: TokenChanges<bigint>[];
+    proxyApprovalData?: {
+        approvalToken: ERC20Token;
+        approvalAmount: string;
+    };
+    txParams: WCTransactionParameters;
+    autoDepositBack: boolean;
+    maxGasInDollar?: string;
+}
+export interface ApproveRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.Approve;
+    approvalAmount: string;
+    approvalToken: ERC20Token;
+    txParams: WCTransactionParameters;
+}
+export interface InsideTransactRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.InsideTransact;
+    tokenChanges: TokenChanges<bigint>[];
+    parsedInLogicMetadata: ParsedInLogicMetadata;
+    txParams: WCTransactionParameters;
+}
+export interface FundAndApproveRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.FundAndApprove;
+    subAccount: SubAccount;
+    tokenChanges: TokenChanges<bigint>[];
+    txParams: WCTransactionParameters;
+    spenderAddress?: string;
+}
+export interface BatchTransactionRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.BatchTransaction;
+    tokenChanges: TokenChanges<bigint>[];
+    batchCalls: WCTransactionParameters[];
+    subAccount: SubAccount;
+    revokedTokens?: TokenAmountInfo[];
+    autoDepositBack?: boolean;
+    maxGasInDollar?: string;
+}
+export interface ReceiveFromSubAccountRequest {
+    type: SandboxRequestType.ReceiveFromShieldedAccount;
+    amounts: bigint[];
+    erc20Tokens: ERC20Token[];
+    subAccount: SubAccount;
+    ownerPublicAddress: string;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+}
+export interface ShieldTokensRequest {
+    type: SandboxRequestType.ShieldTokens;
+    amounts: bigint[];
+    erc20Tokens: ERC20Token[];
+    ownerPublicAddress: string;
+}
+export interface SwapTokensRequest {
+    type: SandboxRequestType.SwapTokens;
+    amountChanges: bigint[];
+    erc20Tokens: ERC20Token[];
+    externalActionId: ExternalActionId;
+    swapData: string;
+    ownerPublicAddress: string;
+    integrationProvider: IntegrationProvider;
+    action: AdminTransactionType;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+    bridgedToken?: ERC20Token;
+    bridgedTokenAmount?: bigint;
+}
+export interface ProxySwapTokensRequest {
+    type: SandboxRequestType.ProxySwapTokens;
+    amountChanges: bigint[];
+    erc20Tokens: ERC20Token[];
+    externalActionId: ExternalActionId;
+    swapData: string;
+    isTheSameChainSwap: boolean;
+    ownerPublicAddress: string;
+    integrationProvider: IntegrationProvider;
+    subAccount: SubAccount;
+    action: AdminTransactionType;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+    bridgedToken?: ERC20Token;
+    bridgedTokenAmount?: bigint;
+    autoDepositBack?: boolean;
+    maxGasInDollar?: string;
+}
+export interface SignMessageRequest {
+    type: SandboxRequestType.SignMessage;
+    messageToSign?: string;
+    typedData?: TypedData;
+    subAccount: SubAccount;
+}
+export interface SendProxySendRequest {
+    type: SandboxRequestType.ProxySend;
+    amounts: bigint[];
+    erc20Tokens: ERC20Token[];
+    to: string;
+    subAccount: SubAccount;
+    ownerPublicAddress: string;
+    action: AdminTransactionType;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+}
+export interface PrepareHinkalFromSerializedArgs {
+    signature: string;
+    ethereumAddress: string;
+    chainId: number;
+    nullifiers: string[];
+    merkleTreeHinkal: MerkleTreeJson;
+    merkleTreeAccessToken: MerkleTreeJson;
+    encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+    approvals: Record<string, ApprovedUtxo[]>;
+    generateProofRemotely: boolean;
+    serializedCache: Record<string, string>;
+    stealthPairCache: Record<string, string>;
+    stealthAddressCache: Record<string, string>;
+}
+export type SandboxRequest = (TransferTokenRequest | ReceiveFromSubAccountRequest | SwapTokensRequest | ShieldTokensRequest | SignMessageRequest | FundApproveAndTransactRequest | PrivateTransactionFromProxyRequest | ApproveRequest | InsideTransactRequest | FundAndApproveRequest | SendProxySendRequest | ProxySwapTokensRequest | BatchTransactionRequest) & {
+    prepareHinkalArgs: PrepareHinkalFromSerializedArgs;
+    isTorRoutingOn: boolean;
+};
+export type SandboxRuntimeMessageHandler = (message: WithId<SandboxRequest>) => Promise<{
+    result: string;
+} | undefined>;
+export interface SandboxResponseError {
+    id: number;
+    success: false;
+    error: Error;
+    erroredTx?: RelayerTransaction;
+}
+export interface SandboxResponseBase {
+    id: number;
+    success: true;
+}
+export interface SandboxResponseTx extends SandboxResponseBase {
+    tx: SandboxTransferableTransaction;
+}
+export interface SandboxResponseSignature extends SandboxResponseBase {
+    signature: string;
+}
+export type SandboxResponseSuccess = SandboxResponseTx | SandboxResponseSignature;
+export type SandboxResponse = SandboxResponseError | SandboxResponseSuccess;

package/types/sandbox.types.mjs

@@ -0,0 +1,4 @@
+var n = /* @__PURE__ */ ((r) => (r.ReceiveFromShieldedAccount = "ReceiveFromShieldedAccount", r.SwapTokens = "SwapTokens", r.ShieldTokens = "ShieldTokens", r.SignMessage = "SignMessage", r.FundApproveAndTransact = "FundApproveAndTransact", r.PrivateTransactionFromProxy = "PrivateTransactionFromProxy", r.Approve = "Approve", r.InsideTransact = "InsideTransact", r.FundAndApprove = "FundAndApprove", r.ProxySend = "ProxySend", r.Send = "Send", r.Fund = "Fund", r.ProxySwapTokens = "ProxySwapTokens", r.BatchTransaction = "BatchTransaction", r))(n || {});
+export {
+  n as SandboxRequestType
+};

package/types/session.types.d.ts

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

package/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/types/slippage.types.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var r=(e=>(e.Swap="Swap",e))(r||{});exports.SlippageType=r;

package/types/slippage.types.d.ts

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

package/types/slippage.types.mjs

@@ -0,0 +1,4 @@
+var a = /* @__PURE__ */ ((r) => (r.Swap = "Swap", r))(a || {});
+export {
+  a as SlippageType
+};

package/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/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/types/token-prices.types.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e={INITIAL:"initial",FETCHING:"fetching",ERROR:"error",SUCCESS:"success"};exports.TOKEN_PRICE_STATUS=e;

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

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

package/types/token-prices.types.mjs

@@ -0,0 +1,9 @@
+const E = {
+  INITIAL: "initial",
+  FETCHING: "fetching",
+  ERROR: "error",
+  SUCCESS: "success"
+};
+export {
+  E as TOKEN_PRICE_STATUS
+};

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

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

package/types/token.types.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var i=(t=>(t[t.Classic=0]="Classic",t[t.ERC20Permit=1]="ERC20Permit",t[t.DAIPermit=2]="DAIPermit",t))(i||{});exports.ApprovalType=i;

package/types/token.types.d.ts

@@ -0,0 +1,77 @@
+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;
+}
+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;
+};

package/types/token.types.mjs

@@ -0,0 +1,4 @@
+var t = /* @__PURE__ */ ((i) => (i[i.Classic = 0] = "Classic", i[i.ERC20Permit = 1] = "ERC20Permit", i[i.DAIPermit = 2] = "DAIPermit", i))(t || {});
+export {
+  t as ApprovalType
+};

package/types/transactions.types.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("ethers"),p=d.BigNumber.from(0),r={blockNumber:0,timeStamp:0,methodId:"",input:"",decodedInput:{erc20TokenAddresses:[],amountChanges:[],flatFees:[0n,0n].map(e=>d.BigNumber.from(e)),externalActionId:p,externalActionMetadata:"",encryptedOutputs:[],hookData:{hookContract:"",preHookContract:"",preHookMetadata:"",postHookMetadata:""},stealthAddressStructure:{extraRandomization:0n,stealthAddress:0n,H0:0n,H1:0n}},logs:[],hash:"",gas:0,gasPrice:0,isError:"",status:""};var m=(e=>(e[e.NotStarted=0]="NotStarted",e[e.Loading=1]="Loading",e[e.Confirmed=2]="Confirmed",e[e.Failed=3]="Failed",e))(m||{}),l=(e=>(e[e.None=0]="None",e[e.Deposit=1]="Deposit",e[e.Mint=2]="Mint",e[e.PoolAdd=3]="PoolAdd",e[e.PoolRemove=4]="PoolRemove",e[e.Redeem=5]="Redeem",e[e.Swap=6]="Swap",e[e.Bridge=7]="Bridge",e[e.Transfer=8]="Transfer",e[e.Withdraw=9]="Withdraw",e[e.Send=10]="Send",e[e.HinkalStake=11]="HinkalStake",e[e.HinkalUnstake=12]="HinkalUnstake",e[e.Fund=13]="Fund",e[e.Receive=14]="Receive",e))(l||{});exports.TransactionAction=l;exports.TransactionStatus=m;exports.emptyDecodedTx=r;

package/types/transactions.types.d.ts

@@ -0,0 +1,78 @@
+import { BigNumber } from 'ethers';
+import { HookDataType, StealthAddressStructure } from './circom-data.types';
+export interface RawTx {
+    blockNumber: number;
+    timeStamp: number;
+    isError: string;
+    methodId: string;
+    input: string;
+    logs: Log[];
+    hash: string;
+    gas: number;
+    gasPrice: number;
+    contract?: string;
+}
+type Log = {
+    topics: string[];
+    data: string;
+};
+export interface EventLog {
+    address: string;
+    topics: string[];
+    data: string;
+    blockNumber: string;
+    blockHash: string;
+    timeStamp: string;
+    gasPrice: string;
+    gasUsed: string;
+    logIndex: string;
+    transactionHash: string;
+    transactionIndex: string;
+}
+export interface DecodedTx<T = bigint, K = BigNumber> extends RawTx {
+    decodedInput: {
+        erc20TokenAddresses: string[];
+        amountChanges: K[];
+        flatFees: K[];
+        externalActionId: K;
+        externalActionMetadata: string;
+        encryptedOutputs: string[];
+        hookData: HookDataType;
+        stealthAddressStructure: StealthAddressStructure<T>;
+    };
+    status: string;
+}
+export interface DecodedTxWithUtxos<T = bigint, K = BigNumber> extends DecodedTx<T, K> {
+    utxosArray?: OnChainUtxo<T>[];
+}
+export type OnChainUtxo<AmountType = bigint> = {
+    amount: AmountType;
+    erc20TokenAddress: string;
+    timeStamp: string;
+    tokenId: number;
+};
+export declare const emptyDecodedTx: DecodedTx;
+export declare enum TransactionStatus {
+    NotStarted = 0,
+    Loading = 1,
+    Confirmed = 2,
+    Failed = 3
+}
+export declare enum TransactionAction {
+    None = 0,
+    Deposit = 1,
+    Mint = 2,
+    PoolAdd = 3,
+    PoolRemove = 4,
+    Redeem = 5,
+    Swap = 6,
+    Bridge = 7,
+    Transfer = 8,
+    Withdraw = 9,
+    Send = 10,
+    HinkalStake = 11,
+    HinkalUnstake = 12,
+    Fund = 13,
+    Receive = 14
+}
+export {};