@gurge/sdk 0.3.150 → 0.3.151

package/common/src/types/remote-tx-build.types.d.ts

@@ -0,0 +1,298 @@
+import { CircomDataJsonType, CommitmentValidationDataType, DimDataType } from './circom-data.types';
+import { NewZkCallDataType } from './snark.types';
+import { AuthorizationData, FeeStructure } from './hinkal.types';
+import { ExternalActionId } from './external-action.types';
+import { AdminDataType } from './admin.types';
+import { SolanaArgs, SolanaSwapAccounts, SolanaSwapArgs, SolanaTransactAccounts } from './solana.types';
+export interface SignedEnclaveResponse {
+    data: string;
+    signature: string;
+}
+export interface SpeculativeUtxo {
+    amount: string;
+    erc20TokenAddress: string;
+    mintAddress: string;
+    timeStamp: string;
+    stealthAddress: string;
+    isBlocked: boolean;
+    H0: [string, string];
+}
+export interface SpeculativeTreeParams {
+    pendingLeaves: string[];
+    inputUtxos: SpeculativeUtxo[][];
+}
+export interface PrepareTxBase {
+    chainId: number;
+    hinkalAddress?: string;
+    erc20Addresses: string[];
+    externalAddress: string;
+    originalSender?: string;
+    relay?: string;
+    feeStructure?: FeeStructure;
+    externalActionId?: ExternalActionId;
+    externalActionMetadata?: string;
+    onChainCreation?: boolean[];
+    recipientAddress?: string[];
+    inputCommitments?: string[];
+    useBlockedUtxos?: boolean;
+    createBlockedUtxos?: boolean;
+    skipLock?: boolean;
+    forceEmptyUtxos?: boolean;
+    speculative?: SpeculativeTreeParams;
+}
+export type PrepareSolanaTxFunctionName = 'transact' | 'transfer' | 'swap';
+export type PrepareSolanaTxInstruction = SolanaSwapArgs['hinkalInstructions'][number];
+export interface PrepareSolanaTxAccountMeta {
+    pubkey: string;
+    isSigner: boolean;
+    isWritable: boolean;
+}
+export interface PrepareSolanaTxBase {
+    chainId: number;
+    mintAddresses: string[];
+    relayAddress: string;
+    recipient: string;
+    signer?: string;
+    functionName: PrepareSolanaTxFunctionName;
+    accounts: SolanaTransactAccounts | SolanaSwapAccounts;
+    onChainCreation?: boolean[];
+    hinkalInstructions?: PrepareSolanaTxInstruction[];
+    remainingAccounts?: PrepareSolanaTxAccountMeta[];
+    recipientAddress?: string;
+    inputCommitments?: string[];
+    useBlockedUtxos?: boolean;
+    recipientAmount?: string;
+    displayRecipient?: string;
+    speculative?: SpeculativeTreeParams;
+}
+export interface PrepareSolanaTxParams extends PrepareSolanaTxBase {
+    amountChanges: bigint[];
+    relayerFee?: bigint;
+    variableRate?: bigint;
+    swapperAccountSalt?: bigint;
+    recipientAmounts?: bigint[];
+    messageSeed?: bigint;
+}
+export type RemoteFeeStructureRequest = {
+    feeToken: string;
+    flatFee: string;
+    variableRate: string;
+};
+export interface PrepareSolanaTxRequestType extends Omit<PrepareSolanaTxBase, 'chainId'> {
+    chainId: number;
+    amountChanges: string[];
+    relayerFee?: string;
+    variableRate?: string;
+    swapperAccountSalt?: string;
+    recipientAmounts?: string[];
+    messageSeed?: string;
+    nullifyingKey: string;
+    spendingPublicKey: [string, string];
+}
+export interface EchoedPrepareSolanaTxRequestType extends Omit<PrepareSolanaTxBase, 'chainId' | 'signer' | 'onChainCreation' | 'hinkalInstructions' | 'remainingAccounts' | 'recipientAddress' | 'inputCommitments' | 'useBlockedUtxos'> {
+    chainId: string;
+    amountChanges: string[];
+    signer: string;
+    relayerFee: string;
+    variableRate: string;
+    onChainCreation: boolean[] | null;
+    hinkalInstructions: PrepareSolanaTxInstruction[] | null;
+    remainingAccounts: PrepareSolanaTxAccountMeta[] | null;
+    swapperAccountSalt: string;
+    recipientAddress: string;
+    recipientAmounts: string[] | null;
+    inputCommitments: string[] | null;
+    useBlockedUtxos: boolean;
+    messageSeed: string;
+}
+export interface PrepareTxParams extends PrepareTxBase {
+    amountChanges: bigint[];
+    recipientAmounts?: bigint[][];
+    selfOutputAmounts?: bigint[];
+    messageSeed?: bigint;
+    slippageValues?: bigint[];
+}
+export interface PrepareTxRequestType extends PrepareTxBase {
+    amountChanges: string[];
+    recipientAmounts?: string[][];
+    selfOutputAmounts?: string[];
+    messageSeed?: string;
+    nullifyingKey: string;
+    spendingPublicKey: [string, string];
+    slippageValues?: string[];
+}
+export interface EchoedPrepareTxRequestType {
+    chainId: string;
+    hinkalAddress: string;
+    erc20Addresses: string[];
+    amountChanges: string[];
+    externalAddress: string;
+    originalSender?: string;
+    relay: string;
+    feeStructure: {
+        feeToken: string;
+        flatFee: string;
+        variableRate: string;
+    } | null;
+    externalActionId: string;
+    externalActionMetadata: string;
+    onChainCreation: boolean[] | null;
+    recipientAddress: string[] | null;
+    recipientAmounts: string[][] | null;
+    selfOutputAmounts: string[] | null;
+    inputCommitments: string[] | null;
+    useBlockedUtxos: boolean;
+    createBlockedUtxos: boolean;
+    forceEmptyUtxos?: boolean;
+    messageSeed: string;
+    skipLock: boolean;
+    speculative?: SpeculativeTreeParams;
+    slippageValues: string[] | null;
+}
+export interface EstimateNullifiersParams {
+    chainId: number;
+    mintAddresses: string[];
+    amountChanges: bigint[];
+    useBlockedUtxos?: boolean;
+}
+export interface EstimateNullifiersRequestType extends Omit<EstimateNullifiersParams, 'amountChanges'> {
+    amountChanges: string[];
+    nullifyingKey: string;
+    spendingPublicKey: [string, string];
+}
+export interface EstimateNullifiersResponseType {
+    nullifierCount: number;
+}
+export interface PreparedJobType {
+    jobId: string;
+    signedMessageHash: string;
+}
+export interface EnclaveWitnessPreimage {
+    rootHashHinkal: string;
+    outTimeStamp: string;
+    outH1Ax: string;
+    outH1Ay: string;
+    h0Ax: string;
+    h0Ay: string;
+    outAmounts: string[][];
+    outNoteH0Ax: string[][];
+    outNoteH0Ay: string[][];
+    messageSeed: string;
+    encryptedOutputs: string[][];
+    onChainEncryptedOutput: string;
+    inAmounts: string[][];
+    inH0Ax: string[][];
+    inH0Ay: string[][];
+    inTimeStamps: string[][];
+}
+export interface PrepareTxResponseType extends PreparedJobType, EnclaveWitnessPreimage {
+    request: EchoedPrepareTxRequestType;
+}
+export interface PrepareSolanaTxResponseType extends PreparedJobType, EnclaveWitnessPreimage {
+    request: EchoedPrepareSolanaTxRequestType;
+    dimensions: DimDataType;
+}
+export interface PrepareStuckWithdrawRequestType {
+    chainId: number;
+    hinkalAddress?: string;
+    erc20Address: string;
+    externalAddress: string;
+    relay: string;
+    feeStructure: FeeStructure;
+    hashedEthereumAddress: string;
+    nullifyingKey: string;
+    spendingPublicKey: [string, string];
+}
+export interface EchoedPrepareStuckWithdrawRequestType {
+    chainId: string;
+    hinkalAddress: string;
+    erc20Address: string;
+    externalAddress: string;
+    relay: string;
+    feeStructure: {
+        feeToken: string;
+        flatFee: string;
+        variableRate: string;
+    };
+    hashedEthereumAddress: string;
+}
+export interface PreparedStuckWithdrawJobType extends PreparedJobType, EnclaveWitnessPreimage {
+    dimensions: DimDataType;
+}
+export interface PrepareStuckWithdrawResponseType {
+    jobs: PreparedStuckWithdrawJobType[];
+    request: EchoedPrepareStuckWithdrawRequestType;
+}
+export interface PrepareSolanaStuckWithdrawParams {
+    chainId: number;
+    mintAddress: string;
+    recipient: string;
+    relayAddress: string;
+    accounts: SolanaTransactAccounts;
+    feeStructures: Record<string, FeeStructure>;
+    hashedEthereumAddress: string;
+}
+export interface PrepareSolanaStuckWithdrawRequestType extends Omit<PrepareSolanaStuckWithdrawParams, 'feeStructures'> {
+    feeStructures: Record<string, RemoteFeeStructureRequest>;
+    nullifyingKey: string;
+    spendingPublicKey: [string, string];
+}
+export interface EchoedPrepareSolanaStuckWithdrawRequestType {
+    chainId: string;
+    mintAddress: string;
+    recipient: string;
+    relayAddress: string;
+    signer: string;
+    accounts: SolanaTransactAccounts;
+    feeStructures: Record<string, RemoteFeeStructureRequest>;
+    hashedEthereumAddress: string;
+}
+export interface PrepareSolanaStuckWithdrawResponseType {
+    jobs: PreparedStuckWithdrawJobType[];
+    request: EchoedPrepareSolanaStuckWithdrawRequestType;
+}
+export interface FinalizeTxRequestType {
+    jobId: string;
+    eddsaSignature: {
+        R8: [string, string];
+        S: string;
+    };
+}
+export interface FinalizeTxResponseType {
+    zkCallData: NewZkCallDataType;
+    circomData: CircomDataJsonType;
+    dimData: DimDataType;
+    commitmentValidationData?: CommitmentValidationDataType;
+    tronProofSignature?: {
+        v: number;
+        r: string;
+        s: string;
+    };
+}
+export interface FinalizeSolanaTxResponseType {
+    solanaArgs: SolanaArgs;
+    commitmentValidationData?: CommitmentValidationDataType;
+}
+export interface FinalizeTxRelayRequestType {
+    jobId: string;
+    eddsaSignature: {
+        R8: [string, string];
+        S: string;
+    };
+    chainId: number;
+    adminData?: AdminDataType;
+    authorizationData?: AuthorizationData;
+    withUniswapWorkAround?: boolean;
+}
+export interface FinalizeSolanaTxRelayRequestType {
+    jobId: string;
+    eddsaSignature: {
+        R8: [string, string];
+        S: string;
+    };
+    chainId: number;
+    adminData?: AdminDataType;
+}
+export interface FinalizeTxRelayResponseType {
+    txHash: string;
+}

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

@@ -5,13 +5,8 @@ export declare enum ScheduledTransactionStatus {
     WAITING_FOR_RELAYER = "waiting_for_relayer",
     SENT_ON_CHAIN = "sent_on_chain",
     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"
+    FAILED = "failed",
+    DEPOSIT_FAILED = "deposit_failed"
 }
 export interface ScheduledTransactionItemStatus {
     status: ScheduledTransactionStatus;
@@ -31,6 +26,27 @@ export interface ScheduledTransactionResponseItem {
     createdAt: string;
     externalAddress: string;
     transactionHash?: string;
+    destinationChainId?: number;
+    destinationTokenAddress?: string;
+    destinationTokenAmount?: string;
+}
+export interface ScheduledTransactionCacheLeg {
+    scheduledTime: string;
+    status: ScheduledTransactionStatus;
+    txHash: string | null;
+    externalAddress: string;
+    amount: string;
+    destinationChainId?: number;
+    destinationTokenAddress?: string;
+    destinationTokenAmount?: string;
+}
+export interface ScheduledTransactionCacheEntry {
+    scheduleId: string;
+    depositTxHash: string;
+    chainId: number;
+    erc20TokenAddress: string;
+    createdAt: string;
+    legs: ScheduledTransactionCacheLeg[];
 }
 export interface RecipientUtxo {
     recipientAddress: string;
@@ -40,15 +56,12 @@ export interface ClaimableUtxo {
     chainId: number;
     senderAddress: string;
     utxo: Utxo;
-    claimableSignature?: string;
-}
-export interface PendingEnclaveUtxo extends ClaimableUtxo {
-    recipientAddress: string;
+    claimableSignature: string;
 }
 export interface FallbackRecipientUtxoPlan {
     recipientIndex: number;
     recipientAddress: string;
     shieldedPrivateKey: string;
-    claimableSignature?: string;
+    claimableSignature: string;
     utxo: Utxo;
 }

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

@@ -1,5 +1,6 @@
 interface ZkBaseInputType {
     rootHashHinkal: bigint | undefined;
+    rootHashHinkalIndex: bigint | undefined;
     shieldedPrivateKey: string;
     inAmounts: string[];
     inBlindings: string[];
@@ -7,9 +8,6 @@ interface ZkBaseInputType {
     inCommitmentSiblings: string[][];
     inCommitmentSiblingSides: string[][];
     outCommitments: string[];
-    rootHashAccessToken: bigint | undefined;
-    accessTokenSiblings: string[];
-    accessTokenSiblingSides: string[];
     relayFee: bigint;
     relay: string;
 }

package/common/src/types/solana-transact.types.cjs

@@ -0,0 +1 @@
+var e=function(e){return e.Relayer=`relayer`,e.ProofOnly=`proofOnly`,e}({});exports.SolanaSubmitMode=e;

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

@@ -0,0 +1,35 @@
+import { UserKeys } from '../data-structures/crypto-keys/keys';
+import { Utxo } from '../data-structures/utxo/Utxo';
+import { AdminDataType } from './admin.types';
+import { CommitmentValidationDataType } from './circom-data.types';
+import { PrepareSolanaTxParams } from './remote-tx-build.types';
+import { SolanaArgs } from './solana.types';
+export declare enum SolanaSubmitMode {
+    Relayer = "relayer",
+    ProofOnly = "proofOnly"
+}
+export interface SolanaTransactNotes {
+    inputNullifiers: string[];
+    outCommitments: string[];
+    encryptedOutputs: string[];
+}
+export interface SolanaTransactProof {
+    args: SolanaArgs;
+    commitmentValidationData?: CommitmentValidationDataType;
+    notes?: SolanaTransactNotes;
+}
+export interface SolanaRelayerSubmit {
+    mode: SolanaSubmitMode.Relayer;
+    adminData?: AdminDataType;
+}
+export interface SolanaProofOnlySubmit {
+    mode: SolanaSubmitMode.ProofOnly;
+}
+export type SolanaTransactSubmit = SolanaRelayerSubmit | SolanaProofOnlySubmit;
+export interface HinkalSolanaTransactParams extends Omit<PrepareSolanaTxParams, 'inputCommitments'> {
+    submit: SolanaTransactSubmit;
+    inputUtxos?: Utxo[][];
+    userKeys?: UserKeys;
+    onTxSubmitLocally?: (notes: SolanaTransactNotes) => void;
+}
+export type SolanaTransactResult = string | SolanaTransactProof;

package/common/src/types/solana-transact.types.mjs

@@ -0,0 +1,6 @@
+//#region libs/shared/common/src/types/solana-transact.types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.Relayer = "relayer", e.ProofOnly = "proofOnly", e;
+}({});
+//#endregion
+export { e as SolanaSubmitMode };

package/common/src/types/solana.types.cjs

@@ -0,0 +1 @@
+var e=function(e){return e.Shield=`shield`,e.Send=`send`,e}({});exports.SolanaSponsoredTxKind=e;

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

@@ -31,9 +31,12 @@ export interface SolanaArgs {
     relayerFee: string;
     variableRate?: string | null;
     dimensions: DimDataType;
+    rootHashIndex: string;
 }
 export type SolanaTransactArgs = SolanaArgs;
 export interface SolanaSwapArgs extends SolanaArgs {
+    onChainEncryptedOutput: string;
+    onChainCreation: boolean[];
     hinkalInstructions: Array<{
         accountIndexes: number[];
         data: number[];
@@ -47,9 +50,6 @@ 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[];
@@ -73,12 +73,21 @@ export type SolanaTransactionBody = (SolanaTransactBody | SolanaSwapBody) & {
     recipientAmount?: string;
     adminData?: AdminDataType;
     displayRecipient?: string;
+    destinationChainId?: number;
+    destinationTokenAddress?: string;
+    destinationTokenAmount?: string;
 };
+export declare enum SolanaSponsoredTxKind {
+    Shield = "shield",
+    Send = "send"
+}
 export interface SolanaTransactionParams {
     mintFrom?: string;
     mintTo?: string;
     recipient?: string;
     nullifierCount?: number;
+    rootInsertCount?: number;
+    ataCreationCount?: number;
 }
 export interface SolanaAccountKeys {
     storageAccount: string;

package/common/src/types/solana.types.mjs

@@ -0,0 +1,6 @@
+//#region libs/shared/common/src/types/solana.types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.Shield = "shield", e.Send = "send", e;
+}({});
+//#endregion
+export { e as SolanaSponsoredTxKind };

package/common/src/types/temp-wallet.types.d.ts

@@ -0,0 +1,9 @@
+import { SubAccount } from './proxy.types';
+export interface DerivedTempWallet {
+    address: string;
+    privateKey: string;
+}
+export interface BridgeTempWallets {
+    sourceSubAccount: SubAccount;
+    destinationSubAccount: SubAccount;
+}

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

@@ -25,6 +25,76 @@ export type SimulateTxBody = {
     value?: string;
     save?: boolean;
     save_if_fails?: boolean;
+    state_objects?: {
+        [address: string]: {
+            balance?: string;
+            nonce?: number;
+            code?: string;
+            storage?: Record<string, string>;
+        };
+    };
+};
+export type SimulateBundleTxAssetChange = {
+    type: string;
+    from?: string;
+    to?: string;
+    amount?: string | null;
+    raw_amount?: string;
+    dollar_value?: string;
+    token_id?: string;
+    token_info?: {
+        standard?: string;
+        type?: string;
+        contract_address?: string;
+        symbol?: string;
+        name?: string;
+        logo?: string;
+        decimals?: number;
+        dollar_value?: string;
+    };
+};
+export type SimulateBundleTxCallTraceEntry = {
+    call_type?: string;
+    from?: string;
+    to?: string;
+    address?: string;
+    gas?: number;
+    gas_used?: number;
+    input?: string;
+    output?: string;
+    value?: string | number;
+    error?: string;
+    error_reason?: string;
+    function_name?: string;
+    calls?: SimulateBundleTxCallTraceEntry[] | null;
+};
+export type SimulateBundleTxStateDiffRaw = {
+    address?: string;
+    key?: string;
+    original?: string;
+    dirty?: string;
+};
+export type SimulateBundleTxStateDiff = {
+    address?: string;
+    raw?: SimulateBundleTxStateDiffRaw[] | null;
+};
+export type SimulateBundleTxResult = {
+    transaction?: {
+        status?: boolean;
+        gas_used?: number;
+        block_number?: number;
+        transaction_info?: {
+            asset_changes?: SimulateBundleTxAssetChange[] | null;
+            call_trace?: SimulateBundleTxCallTraceEntry | null;
+            state_diff?: SimulateBundleTxStateDiff[] | null;
+        };
+    };
+    error?: {
+        message?: string;
+    };
+};
+export type SimulateBundleTxResponse = {
+    simulation_results: SimulateBundleTxResult[];
 };
 export type SimulateTxResponse = {
     transaction: {

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

@@ -1 +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;
+var e=function(e){return e.Public=`public`,e.Confidential=`confidential`,e}({});exports.TemporaryWalletRecoveryDestination=e;

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

@@ -81,8 +81,18 @@ export interface PrivateRecipientInfo {
     amount: bigint;
     token: ERC20Token;
 }
+export declare enum TemporaryWalletRecoveryDestination {
+    Public = "public",
+    Confidential = "confidential"
+}
+export interface TemporaryWalletNonceEntry {
+    nonce: number;
+    recoveryDestination: TemporaryWalletRecoveryDestination;
+    createdAt?: string;
+}
 export interface TemporaryWalletBalance extends TokenBalanceWithUsdValue {
     nonce: number;
     ethAddress: string;
     privateKey: string;
+    recoveryDestination: TemporaryWalletRecoveryDestination;
 }

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

@@ -1,6 +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;
+	return e.Public = "public", e.Confidential = "confidential", e;
 }({});
 //#endregion
-export { e as ApprovalType };
+export { e as TemporaryWalletRecoveryDestination };

package/common/src/types/transact.types.cjs

@@ -0,0 +1 @@
+var e=function(e){return e.Relayer=`relayer`,e.Self=`self`,e.ProofOnly=`proofOnly`,e}({});exports.SubmitMode=e;

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

@@ -0,0 +1,53 @@
+import { ethers } from 'ethers';
+import { Types as TronWebTypes } from 'tronweb';
+import { UserKeys } from '../data-structures/crypto-keys/keys';
+import { Utxo } from '../data-structures/utxo/Utxo';
+import { AdminDataType } from './admin.types';
+import { CircomDataType, CommitmentValidationDataType, DimDataType } from './circom-data.types';
+import { AuthorizationData } from './hinkal.types';
+import { PrepareTxParams } from './remote-tx-build.types';
+import { NewZkCallDataType } from './snark.types';
+import { ERC20Token } from './token.types';
+export declare enum SubmitMode {
+    Relayer = "relayer",
+    Self = "self",
+    ProofOnly = "proofOnly"
+}
+export interface TronProofSignature {
+    v: number;
+    r: string;
+    s: string;
+}
+export interface TransactProof {
+    zkCallData: NewZkCallDataType;
+    circomData: CircomDataType;
+    dimData: DimDataType;
+    commitmentValidationData?: CommitmentValidationDataType;
+    tronProofSignature?: TronProofSignature;
+}
+export interface RelayerSubmit {
+    mode: SubmitMode.Relayer;
+    adminData?: AdminDataType;
+    authorizationData?: AuthorizationData;
+    withUniswapWorkAround?: boolean;
+}
+export interface SelfSubmit {
+    mode: SubmitMode.Self;
+    erc20Tokens: ERC20Token[];
+    approvalAmounts: bigint[];
+    preEstimateGas?: boolean;
+    returnTxData?: boolean;
+}
+export interface ProofOnlySubmit {
+    mode: SubmitMode.ProofOnly;
+}
+export type TransactSubmit = RelayerSubmit | SelfSubmit | ProofOnlySubmit;
+export interface HinkalTransactParams extends Omit<PrepareTxParams, 'inputCommitments'> {
+    submit: TransactSubmit;
+    inputUtxos?: Utxo[][];
+    userKeys?: UserKeys;
+    subAccountPrivateKey?: string;
+    emporiumOps?: string[];
+    onTxSubmitLocally?: (circomData: CircomDataType) => void;
+}
+export type TransactResult = string | ethers.TransactionResponse | ethers.TransactionRequest | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract> | TransactProof;

package/common/src/types/transact.types.mjs

@@ -0,0 +1,6 @@
+//#region libs/shared/common/src/types/transact.types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.Relayer = "relayer", e.Self = "self", e.ProofOnly = "proofOnly", e;
+}({});
+//#endregion
+export { e as SubmitMode };

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

@@ -135,7 +135,6 @@ export interface PrepareHinkalFromSerializedArgs {
     generateProofRemotely: boolean;
     serializedCache: Record<string, string>;
     stealthPairCache: Record<string, string>;
-    stealthAddressCache: Record<string, string>;
 }
 export type TransactionRequest = (TransferTokenRequest | ReceiveFromSubAccountRequest | SwapTokensRequest | PrivateTransactionFromProxyRequest | SendProxySendRequest | ProxySwapTokensRequest | BatchTransactionRequest | SignAndSendSolanaTransactionRequest) & {
     prepareHinkalArgs: PrepareHinkalFromSerializedArgs;

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

@@ -48,7 +48,6 @@ export type OnChainUtxo<AmountType = bigint> = {
     amount: AmountType;
     erc20TokenAddress: string;
     timeStamp: string;
-    tokenId: number;
 };
 export declare const emptyDecodedTx: DecodedTx;
 export declare enum TransactionStatus {