@meshconnect/web-link-sdk 3.2.15 → 3.2.16

package/utils/connectors/solana/transaction.js

@@ -0,0 +1,362 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { PublicKey, SystemProgram, TransactionMessage, VersionedTransaction, TransactionInstruction } from '@meshconnect/solana-web3.js';
+import { getSolanaProvider } from './providerDiscovery';
+var TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+var TOKEN_2022_PROGRAM_ID = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
+var ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+var isUserRejection = function (error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    var err = error;
+    var message = (err.message || '').toLowerCase();
+    return (message.includes('user rejected') ||
+        message.includes('declined') ||
+        message.includes('cancelled') ||
+        message.includes('denied') ||
+        err.code === 4001);
+};
+export function getAssociatedTokenAddress(mint_1, owner_1) {
+    return __awaiter(this, arguments, void 0, function (mint, owner, programId) {
+        var address;
+        if (programId === void 0) { programId = TOKEN_PROGRAM_ID.toBase58(); }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, PublicKey.findProgramAddress([owner.toBuffer(), new PublicKey(programId).toBuffer(), mint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)];
+                case 1:
+                    address = (_a.sent())[0];
+                    return [2 /*return*/, address];
+            }
+        });
+    });
+}
+function createTokenAccountInstruction(payer, associatedToken, owner, mint, programId) {
+    if (programId === void 0) { programId = TOKEN_PROGRAM_ID; }
+    var keys = [
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: associatedToken, isSigner: false, isWritable: true },
+        { pubkey: owner, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: programId, isSigner: false, isWritable: false }
+    ];
+    return new TransactionInstruction({
+        keys: keys,
+        programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+        data: Buffer.alloc(0)
+    });
+}
+export function createTransferCheckedInstruction(fromTokenAccount, toTokenAccount, owner, amount, decimals, tokenMint) {
+    if (decimals === void 0) { decimals = 9; }
+    var data = Buffer.alloc(10);
+    data[0] = 12; // TransferChecked instruction enum
+    data.writeBigUInt64LE(amount, 1); // 8-byte amount
+    data[9] = decimals; // single-byte decimal
+    var programId = TOKEN_2022_PROGRAM_ID;
+    return new TransactionInstruction({
+        keys: [
+            { pubkey: fromTokenAccount, isSigner: false, isWritable: true },
+            { pubkey: tokenMint, isSigner: false, isWritable: false },
+            { pubkey: toTokenAccount, isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: true, isWritable: false }
+        ],
+        programId: programId,
+        data: data
+    });
+}
+export function createSPLTransferInstruction(_a) {
+    var fromTokenAccount = _a.fromTokenAccount, toTokenAccount = _a.toTokenAccount, owner = _a.owner, amount = _a.amount;
+    var data = Buffer.alloc(9);
+    data[0] = 3; // Transfer instruction
+    data.writeBigUInt64LE(amount, 1);
+    return new TransactionInstruction({
+        keys: [
+            { pubkey: fromTokenAccount, isSigner: false, isWritable: true },
+            { pubkey: toTokenAccount, isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: true, isWritable: false }
+        ],
+        programId: TOKEN_PROGRAM_ID,
+        data: data
+    });
+}
+export function createTransferTransaction(config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var instructions, fromPubkey, messageV0;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, createTransferInstructions(config)];
+                case 1:
+                    instructions = _a.sent();
+                    fromPubkey = new PublicKey(config.fromAddress);
+                    messageV0 = new TransactionMessage({
+                        payerKey: fromPubkey,
+                        recentBlockhash: config.blockhash,
+                        instructions: instructions
+                    }).compileToV0Message();
+                    return [2 /*return*/, new VersionedTransaction(messageV0)];
+            }
+        });
+    });
+}
+function createTransferInstructions(config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var fromPubkey, toPubkey, instructions, tokenMintPubkey, fromTokenAccount, toTokenAccount;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fromPubkey = new PublicKey(config.fromAddress);
+                    toPubkey = new PublicKey(config.toAddress);
+                    instructions = [];
+                    if (!!config.tokenMint) return [3 /*break*/, 1];
+                    instructions.push(SystemProgram.transfer({
+                        fromPubkey: fromPubkey,
+                        toPubkey: toPubkey,
+                        lamports: Number(config.amount)
+                    }));
+                    return [3 /*break*/, 4];
+                case 1:
+                    tokenMintPubkey = new PublicKey(config.tokenMint);
+                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, fromPubkey, config.tokenProgram)];
+                case 2:
+                    fromTokenAccount = _a.sent();
+                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, toPubkey, config.tokenProgram)];
+                case 3:
+                    toTokenAccount = _a.sent();
+                    if (config.createATA) {
+                        instructions.push(createTokenAccountInstruction(fromPubkey, toTokenAccount, toPubkey, tokenMintPubkey, config.tokenProgram
+                            ? new PublicKey(config.tokenProgram)
+                            : TOKEN_PROGRAM_ID));
+                    }
+                    if (config.tokenProgram === TOKEN_2022_PROGRAM_ID.toBase58()) {
+                        instructions.push(createTransferCheckedInstruction(fromTokenAccount, toTokenAccount, fromPubkey, BigInt(config.amount), config.tokenDecimals, tokenMintPubkey));
+                    }
+                    else {
+                        instructions.push(createSPLTransferInstruction({
+                            fromTokenAccount: fromTokenAccount,
+                            toTokenAccount: toTokenAccount,
+                            owner: fromPubkey,
+                            amount: BigInt(config.amount)
+                        }));
+                    }
+                    _a.label = 4;
+                case 4: return [2 /*return*/, instructions];
+            }
+        });
+    });
+}
+export function handleManualSignAndSend(transaction, provider) {
+    return __awaiter(this, void 0, void 0, function () {
+        var signature, signedTransaction, signature, error_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 6, , 7]);
+                    if (!provider.signAndSendTransaction) return [3 /*break*/, 2];
+                    return [4 /*yield*/, provider.signAndSendTransaction(transaction)];
+                case 1:
+                    signature = (_b.sent()).signature;
+                    return [2 /*return*/, signature];
+                case 2: return [4 /*yield*/, provider.signTransaction(transaction)];
+                case 3:
+                    signedTransaction = _b.sent();
+                    if (!provider.sendTransaction) {
+                        throw new Error('Provider does not support sendTransaction');
+                    }
+                    return [4 /*yield*/, provider.sendTransaction(signedTransaction)];
+                case 4:
+                    signature = _b.sent();
+                    return [2 /*return*/, signature];
+                case 5: return [3 /*break*/, 7];
+                case 6:
+                    error_1 = _b.sent();
+                    console.error('Error in handleManualSignAndSend:', error_1);
+                    if (error_1 instanceof Error && ((_a = error_1.message) === null || _a === void 0 ? void 0 : _a.includes('User rejected'))) {
+                        throw new Error('Transaction was rejected by user');
+                    }
+                    throw error_1;
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+export function getTransferInstructions(instructions) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, _loop_1, instrIndex;
+        return __generator(this, function (_a) {
+            result = [];
+            _loop_1 = function (instrIndex) {
+                var ix = instructions[instrIndex];
+                var programId = new PublicKey(ix.programId);
+                var keys = ix.accounts.map(function (meta, accountIndex) {
+                    if (!meta.pubKey) {
+                        throw new Error("Account at instruction ".concat(instrIndex, ", index ").concat(accountIndex, " has no pubKey and is not fillable"));
+                    }
+                    var resolvedPubkey = new PublicKey(meta.pubKey);
+                    return {
+                        pubkey: resolvedPubkey,
+                        isSigner: meta.isSigner,
+                        isWritable: meta.isWritable
+                    };
+                });
+                result.push(new TransactionInstruction({
+                    keys: keys,
+                    programId: programId,
+                    data: Buffer.from(ix.data, 'base64')
+                }));
+            };
+            for (instrIndex = 0; instrIndex < instructions.length; instrIndex++) {
+                _loop_1(instrIndex);
+            }
+            return [2 /*return*/, result];
+        });
+    });
+}
+export var sendSOLTransaction = function (config) { return __awaiter(void 0, void 0, void 0, function () {
+    var provider, transaction, isManualWallet, signature, error_2, error_3;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 8, , 9]);
+                provider = getSolanaProvider(config.walletName);
+                return [4 /*yield*/, createTransferTransaction(config)];
+            case 1:
+                transaction = _a.sent();
+                isManualWallet = provider.isTrust ||
+                    provider.isTrustWallet ||
+                    config.walletName.toLowerCase().includes('trust');
+                if (!isManualWallet) return [3 /*break*/, 3];
+                return [4 /*yield*/, handleManualSignAndSend(transaction, provider)];
+            case 2: return [2 /*return*/, _a.sent()];
+            case 3:
+                if (!provider.signAndSendTransaction) return [3 /*break*/, 7];
+                _a.label = 4;
+            case 4:
+                _a.trys.push([4, 6, , 7]);
+                return [4 /*yield*/, provider.signAndSendTransaction(transaction)
+                    // @TODO: validate that signature was a successful tx
+                ];
+            case 5:
+                signature = (_a.sent()).signature;
+                // @TODO: validate that signature was a successful tx
+                return [2 /*return*/, signature];
+            case 6:
+                error_2 = _a.sent();
+                if (isUserRejection(error_2)) {
+                    throw new Error('Transaction was rejected by user');
+                }
+                return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
+            case 7: return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
+            case 8:
+                error_3 = _a.sent();
+                if (isUserRejection(error_3)) {
+                    throw new Error('Transaction was rejected by user');
+                }
+                throw error_3 instanceof Error
+                    ? error_3
+                    : new Error("Failed to send SOL transaction with ".concat(config.walletName, " wallet"));
+            case 9: return [2 /*return*/];
+        }
+    });
+}); };
+export var sendSOLTransactionWithInstructions = function (payload, transferConfig) { return __awaiter(void 0, void 0, void 0, function () {
+    var walletName, instructions, fromPubkey, transferInstructions, transaction, error_4;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                walletName = payload.transactionInstructions.walletName || 'Phantom';
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 5, , 6]);
+                return [4 /*yield*/, getTransferInstructions(payload.transactionInstructions.instructions)];
+            case 2:
+                instructions = _a.sent();
+                fromPubkey = new PublicKey(transferConfig.fromAddress);
+                return [4 /*yield*/, createTransferInstructions(transferConfig)];
+            case 3:
+                transferInstructions = _a.sent();
+                instructions.push.apply(instructions, transferInstructions);
+                transaction = new VersionedTransaction(new TransactionMessage({
+                    payerKey: fromPubkey,
+                    recentBlockhash: payload.transactionInstructions.blockhash,
+                    instructions: instructions
+                }).compileToV0Message());
+                return [4 /*yield*/, sendSolanaTransfer(walletName, transaction)];
+            case 4: return [2 /*return*/, _a.sent()];
+            case 5:
+                error_4 = _a.sent();
+                if (isUserRejection(error_4)) {
+                    throw new Error('Transaction was rejected by user');
+                }
+                throw error_4 instanceof Error
+                    ? error_4
+                    : new Error("Failed to send SOL transaction with ".concat(walletName, " wallet"));
+            case 6: return [2 /*return*/];
+        }
+    });
+}); };
+export var sendSolanaTransfer = function (walletName, transaction) { return __awaiter(void 0, void 0, void 0, function () {
+    var provider, isManualWallet, signature, error_5;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                provider = getSolanaProvider(walletName);
+                isManualWallet = provider.isTrust ||
+                    provider.isTrustWallet ||
+                    walletName.includes('trust');
+                if (!isManualWallet) return [3 /*break*/, 2];
+                return [4 /*yield*/, handleManualSignAndSend(transaction, provider)];
+            case 1: return [2 /*return*/, _a.sent()];
+            case 2:
+                if (!provider.signAndSendTransaction) return [3 /*break*/, 6];
+                _a.label = 3;
+            case 3:
+                _a.trys.push([3, 5, , 6]);
+                return [4 /*yield*/, provider.signAndSendTransaction(transaction)];
+            case 4:
+                signature = (_a.sent()).signature;
+                return [2 /*return*/, signature];
+            case 5:
+                error_5 = _a.sent();
+                if (isUserRejection(error_5)) {
+                    throw new Error('Transaction was rejected by user');
+                }
+                return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
+            case 6: return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
+        }
+    });
+}); };

package/utils/connectors/solana/types.d.ts

@@ -0,0 +1,71 @@
+import { Transaction, VersionedTransaction } from '@meshconnect/solana-web3.js';
+export declare enum SolanaWalletType {
+    PHANTOM = "phantom",
+    SOLFLARE = "solflare",
+    TRUST = "trustwallet",
+    EXODUS = "exodus",
+    UNKNOWN = "unknown"
+}
+export interface SolanaConnectResult {
+    accounts: string[];
+    chainId: string;
+    isConnected: boolean;
+}
+export interface SolanaProvider {
+    connect(options?: {
+        onlyIfTrusted?: boolean;
+    }): Promise<{
+        publicKey: {
+            toString(): string;
+            toBase58(): string;
+        };
+    }>;
+    disconnect(): Promise<void>;
+    walletType?: SolanaWalletType;
+    isConnected?: boolean;
+    publicKey?: {
+        toString(): string;
+        toBase58(): string;
+    };
+    on(event: 'connect' | 'disconnect' | 'accountChanged', callback: (publicKey?: any) => void): void;
+    signMessage(message: Uint8Array): Promise<{
+        signature: Uint8Array;
+    }>;
+    signTransaction(transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
+    signAndSendTransaction?(transaction: Transaction | VersionedTransaction): Promise<{
+        signature: string;
+    }>;
+    sendTransaction?(transaction: Transaction | VersionedTransaction): Promise<string>;
+    isPhantom?: boolean;
+    isSolflare?: boolean;
+    isTrust?: boolean;
+    isTrustWallet?: boolean;
+    isExodus?: boolean;
+}
+export interface WindowWithSolanaProviders extends Window {
+    solana?: SolanaProvider;
+    phantom?: {
+        solana?: SolanaProvider;
+    };
+    exodus?: {
+        solana?: SolanaProvider;
+    };
+    trustwallet?: {
+        solana?: SolanaProvider;
+    };
+    solflare?: SolanaProvider;
+    [key: string]: {
+        solana?: SolanaProvider;
+    } | SolanaProvider | undefined | any;
+}
+export interface TransactionConfig {
+    toAddress: string;
+    amount: bigint;
+    fromAddress: string;
+    blockhash: string;
+    walletName: string;
+    tokenMint?: string;
+    createATA?: boolean;
+    tokenProgram?: string;
+    tokenDecimals?: number;
+}

package/utils/connectors/solana/types.js

@@ -0,0 +1,8 @@
+export var SolanaWalletType;
+(function (SolanaWalletType) {
+    SolanaWalletType["PHANTOM"] = "phantom";
+    SolanaWalletType["SOLFLARE"] = "solflare";
+    SolanaWalletType["TRUST"] = "trustwallet";
+    SolanaWalletType["EXODUS"] = "exodus";
+    SolanaWalletType["UNKNOWN"] = "unknown";
+})(SolanaWalletType || (SolanaWalletType = {}));

package/utils/event-types.d.ts

@@ -0,0 +1,233 @@
+import { LinkPayload, TransferFinishedPayload } from './types';
+export type LinkEventType = IntegrationConnected | IntegrationConnectionError | TransferCompleted | IntegrationSelected | CredentialsEntered | TransferStarted | TransferPreviewed | TransferPreviewError | TransferExecutionError | PageLoaded | IntegrationMfaRequired | IntegrationMfaEntered | IntegrationOAuthStarted | IntegrationAccountSelectionRequired | TransferAssetSelected | TransferNetworkSelected | TransferAmountEntered | TransferMfaRequired | TransferMfaEntered | TransferKycRequired | TransferInitiated | TransferExecuted | TransferNoEligibleAssets | WalletMessageSigned | DoneEvent | CloseEvent | VerifyWalletRejected | VerifyDonePage | SDKinjectedWalletProviders | LegalTermsViewed | SeeWhatHappenedClicked | FundingOptionsUpdated | FundingOptionsViewed | GasIncreaseWarning | ExecuteFundingStep;
+declare const LINK_EVENT_TYPE_KEYS: readonly ["integrationConnected", "integrationConnectionError", "integrationMfaRequired", "integrationMfaEntered", "integrationOAuthStarted", "integrationAccountSelectionRequired", "transferCompleted", "integrationSelected", "credentialsEntered", "transferStarted", "transferPreviewed", "transferPreviewError", "transferExecutionError", "pageLoaded", "transferAssetSelected", "transferNetworkSelected", "transferAmountEntered", "transferMfaRequired", "transferMfaEntered", "transferKycRequired", "transferExecuted", "transferInitiated", "transferNoEligibleAssets", "walletMessageSigned", "verifyDonePage", "verifyWalletRejected", "connectionDeclined", "transferConfigureError", "connectionUnavailable", "transferDeclined", "done", "close", "SDKinjectedWalletProviders", "legalTermsViewed", "seeWhatHappenedClicked", "executeFundingStep", "fundingOptionsUpdated", "fundingOptionsViewed", "gasIncreaseWarning"];
+export type LinkEventTypeKeys = (typeof LINK_EVENT_TYPE_KEYS)[number];
+export declare function isLinkEventTypeKey(key: string): key is LinkEventTypeKeys;
+interface LinkEventBase {
+    type: LinkEventTypeKeys;
+}
+export interface PageLoaded {
+    type: 'pageLoaded';
+}
+export interface IntegrationConnected extends LinkEventBase {
+    type: 'integrationConnected';
+    payload: LinkPayload;
+}
+export interface IntegrationConnectionError extends LinkEventBase {
+    type: 'integrationConnectionError';
+    payload: {
+        errorMessage: string;
+    };
+}
+export interface TransferCompleted extends LinkEventBase {
+    type: 'transferCompleted';
+    payload: TransferFinishedPayload;
+}
+export interface IntegrationSelected extends LinkEventBase {
+    type: 'integrationSelected';
+    payload: {
+        integrationType: string;
+        integrationName: string;
+    };
+}
+export interface CredentialsEntered extends LinkEventBase {
+    type: 'credentialsEntered';
+}
+export interface TransferStarted extends LinkEventBase {
+    type: 'transferStarted';
+}
+export interface TransferInitiated extends LinkEventBase {
+    type: 'transferInitiated';
+    payload: {
+        integrationType?: string;
+        integrationName: string;
+        status: 'pending';
+    };
+}
+export interface TransferExecuted extends LinkEventBase {
+    type: 'transferExecuted';
+    payload: {
+        status: 'success' | 'pending';
+        txId: string;
+        fromAddress: string;
+        toAddress: string;
+        symbol: string;
+        amount: number;
+        networkId: string;
+    };
+}
+export interface TransferNoEligibleAssets extends LinkEventBase {
+    type: 'transferNoEligibleAssets';
+    payload: {
+        integrationType?: string;
+        integrationName: string;
+        noAssetsType?: string;
+        arrayOfTokensHeld: {
+            symbol: string;
+            amount: number;
+            amountInFiat?: number;
+            ineligibilityReason?: string;
+        }[];
+    };
+}
+export interface TransferPreviewed extends LinkEventBase {
+    type: 'transferPreviewed';
+    payload: {
+        amount: number;
+        symbol: string;
+        toAddress: string;
+        networkId: string;
+        previewId: string;
+        networkName?: string;
+        amountInFiat?: number;
+        estimatedNetworkGasFee?: {
+            fee?: number;
+            feeCurrency?: string;
+            feeInFiat?: number;
+        };
+    };
+}
+export interface TransferPreviewError extends LinkEventBase {
+    type: 'transferPreviewError';
+    payload: {
+        errorMessage: string;
+    };
+}
+export interface TransferExecutionError extends LinkEventBase {
+    type: 'transferExecutionError';
+    payload: {
+        errorMessage: string;
+    };
+}
+export interface IntegrationMfaRequired extends LinkEventBase {
+    type: 'integrationMfaRequired';
+}
+export interface IntegrationMfaEntered extends LinkEventBase {
+    type: 'integrationMfaEntered';
+}
+export interface IntegrationOAuthStarted extends LinkEventBase {
+    type: 'integrationOAuthStarted';
+}
+export interface IntegrationAccountSelectionRequired extends LinkEventBase {
+    type: 'integrationAccountSelectionRequired';
+}
+export interface TransferAssetSelected extends LinkEventBase {
+    type: 'transferAssetSelected';
+    payload: {
+        symbol: string;
+    };
+}
+export interface TransferNetworkSelected extends LinkEventBase {
+    type: 'transferNetworkSelected';
+    payload: {
+        id: string;
+        name: string;
+    };
+}
+export interface TransferAmountEntered extends LinkEventBase {
+    type: 'transferAmountEntered';
+}
+export interface TransferMfaRequired extends LinkEventBase {
+    type: 'transferMfaRequired';
+}
+export interface TransferMfaEntered extends LinkEventBase {
+    type: 'transferMfaEntered';
+}
+export interface TransferKycRequired extends LinkEventBase {
+    type: 'transferKycRequired';
+}
+export interface DoneEvent extends LinkEventBase {
+    type: 'done';
+    payload: SessionSummary;
+}
+export interface CloseEvent extends LinkEventBase {
+    type: 'close';
+    payload: SessionSummary;
+}
+export interface WalletMessageSigned extends LinkEventBase {
+    type: 'walletMessageSigned';
+    payload: {
+        signedMessageHash: string | undefined;
+        message: string | undefined;
+        address: string;
+        timeStamp: number;
+        isVerified: boolean;
+    };
+}
+export interface VerifyDonePage extends LinkEventBase {
+    type: 'verifyDonePage';
+}
+export interface VerifyWalletRejected extends LinkEventBase {
+    type: 'verifyWalletRejected';
+}
+export interface SessionSummary {
+    /**
+     *   Current page of application. Possible values:
+     * `startPage`
+     * `integrationsCatalogPage`
+     * `integrationLoginPage`
+     * `integrationMfaPage`
+     * `integrationAccountSelectPage`
+     * `integrationConnectedPage`
+     * `errorPage`
+     * `transferKycPage`
+     * `transferHoldingSelectionPage`
+     * `transferNetworkSelectionPage`
+     * `transferAmountSelectionPage`
+     * `transferPreviewPage`
+     * `transferMfaPage`
+     * `transferFundingPage`
+     * `transferExecutedPage`
+     * `termsAndConditionPage`
+     *
+     * This list may change in future.
+     */
+    page: string;
+    /** Selected integration */
+    selectedIntegration?: {
+        id?: string;
+        name?: string;
+    };
+    /** Transfer information */
+    transfer?: {
+        previewId?: string;
+        symbol?: string;
+        amount?: number;
+        amountInFiat?: number;
+        transactionId?: string;
+        networkId?: string;
+    };
+    errorMessage?: string;
+}
+export interface SDKinjectedWalletProviders extends LinkEventBase {
+    type: 'SDKinjectedWalletProviders';
+    payload: Array<{
+        icon?: string;
+        id: string;
+        name: string;
+    }>;
+}
+export interface LegalTermsViewed {
+    type: 'legalTermsViewed';
+}
+export interface SeeWhatHappenedClicked {
+    type: 'seeWhatHappenedClicked';
+}
+export interface FundingOptionsUpdated {
+    type: 'fundingOptionsUpdated';
+}
+export interface FundingOptionsViewed {
+    type: 'fundingOptionsViewed';
+}
+export interface GasIncreaseWarning {
+    type: 'gasIncreaseWarning';
+}
+export interface ExecuteFundingStep {
+    type: 'executeFundingStep';
+    payload: {
+        cryptocurrencyFundingOptionType: string;
+        status: string;
+        errorMessage?: string;
+    };
+}
+export {};