@gurge/sdk 0.3.142 → 0.3.151

package/common/src/types/pay-activities.types.d.ts

@@ -0,0 +1,52 @@
+import { ERC20Token } from './token.types';
+export declare enum PayActivityStatus {
+    SUCCESSFUL = "SUCCESSFUL",
+    FAILED = "FAILED"
+}
+export declare enum PayActivityTypes {
+    PAID_PRIVATELY = "Paid Privately",
+    WITHDRAWN_TO_PUBLIC = "Withdrawn to Public",
+    PRIVATE_SEND = "Private Send",
+    SHIELD = "Shield",
+    UNSHIELD = "Unshield"
+}
+export declare enum TransferVisibility {
+    CONFIDENTIAL = "CONFIDENTIAL",
+    PUBLIC = "PUBLIC"
+}
+export interface PayActivityTokenAmount {
+    token: ERC20Token;
+    amount: string;
+    amountInDollar: string;
+}
+export interface PayActivityLeg {
+    recipientAddress: string;
+    token: ERC20Token;
+    amount: bigint;
+    tokenPriceDollar: number;
+}
+export interface PayActivityAddRequest {
+    activityType: PayActivityTypes;
+    status: PayActivityStatus;
+    to: string;
+    from: string;
+    tokens: PayActivityTokenAmount[];
+    sentFrom: TransferVisibility;
+    sentTo: TransferVisibility;
+    txHash: string;
+    destinationChainId?: number;
+    destinationTokenAddress?: string;
+    destinationTokenAmount?: string;
+}
+export interface PayActivity extends PayActivityAddRequest {
+    timestamp: Date;
+}
+export interface PayActivityClient extends PayActivityAddRequest {
+    timestamp: string;
+}
+export interface StoredPayActivity extends Omit<PayActivity, 'tokens'> {
+    tokens?: PayActivityTokenAmount[];
+    token?: ERC20Token;
+    amount?: string;
+    amountInDollar?: string;
+}

package/common/src/types/pay-routing.types.d.ts

@@ -0,0 +1,9 @@
+export interface RecipientRequest {
+    recipientAddress: string;
+    amount: bigint;
+}
+export interface RecipientRoutingResult {
+    directRecipients: RecipientRequest[];
+    directRecipientInfos: string[];
+    fallbackRecipients: RecipientRequest[];
+}

package/common/src/types/payout-notification.types.d.ts

@@ -0,0 +1,11 @@
+export declare enum PayoutNotificationKind {
+    APPROVAL_REQUESTED = "ApprovalRequested",
+    PAYOUT_RESOLVED = "PayoutResolved"
+}
+export interface PayoutNotification {
+    id: string;
+    payoutId: number;
+    kind: PayoutNotificationKind;
+    readAt: string | null;
+    createdAt: string;
+}

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

@@ -0,0 +1,4 @@
+export interface IPresaleReferral {
+    referralCode: string;
+    mintCount: string[];
+}

package/common/src/types/proxy-progress.types.d.ts

@@ -0,0 +1,5 @@
+export interface DailyProxyProgress {
+    day: Date;
+    address: string;
+    chainId: number;
+}

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

@@ -0,0 +1,19 @@
+export type SubAccount = {
+    index: number | null;
+    ethAddress?: string;
+    solanaAddress?: string;
+    name: string;
+    createdAt: string;
+    isHidden: boolean;
+    isFavorite: boolean;
+    iconIndex: number;
+    privateKey?: string;
+    solanaPrivateKey?: string;
+    isImported: boolean;
+};
+export type SubAccountLight = Omit<SubAccount, 'privateKey' | 'solanaPrivateKey' | 'isImported' | 'iconIndex'>;
+export type TemporarySubAccount = {
+    index: number;
+    ethAddress: string;
+    privateKey: string;
+};

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

@@ -0,0 +1,14 @@
+export type HandshakeResponseType = {
+    public_key: string;
+};
+export type EnclaveHandshake = {
+    keyCiphertext: string;
+    inputCiphertext: string;
+    key: Uint8Array;
+};
+export type RemoteProofType = {
+    pi_a: string[];
+    pi_b: string[][];
+    pi_c: string[];
+    protocol: string;
+};

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/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/scheduled-transactions.types.d.ts

@@ -0,0 +1,67 @@
+import { Utxo } from '../data-structures/utxo/Utxo';
+export declare enum ScheduledTransactionStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    WAITING_FOR_RELAYER = "waiting_for_relayer",
+    SENT_ON_CHAIN = "sent_on_chain",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    DEPOSIT_FAILED = "deposit_failed"
+}
+export interface ScheduledTransactionItemStatus {
+    status: ScheduledTransactionStatus;
+    scheduledTime: string;
+    txHash: string | null;
+}
+export interface DepositAndSendExtendedResult {
+    depositTxHash: string;
+    scheduleId: string;
+}
+export interface ScheduledTransactionResponseItem {
+    chainId: number;
+    status: ScheduledTransactionStatus;
+    scheduledTime: string;
+    erc20TokenAddresses: string[];
+    amount: string;
+    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;
+    utxo: Utxo;
+}
+export interface ClaimableUtxo {
+    chainId: number;
+    senderAddress: string;
+    utxo: Utxo;
+    claimableSignature: string;
+}
+export interface FallbackRecipientUtxoPlan {
+    recipientIndex: number;
+    recipientAddress: string;
+    shieldedPrivateKey: string;
+    claimableSignature: string;
+    utxo: Utxo;
+}

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,38 @@
+interface ZkBaseInputType {
+    rootHashHinkal: bigint | undefined;
+    rootHashHinkalIndex: bigint | undefined;
+    shieldedPrivateKey: string;
+    inAmounts: string[];
+    inBlindings: string[];
+    inNullifiers: string[];
+    inCommitmentSiblings: string[][];
+    inCommitmentSiblingSides: string[][];
+    outCommitments: 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-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;