@drift-labs/sdk 2.97.0-beta.9 → 2.98.0-beta.1

package/lib/node/events/fetchLogs.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogParser = exports.fetchTransactionLogs = exports.fetchLogs = void 0;
+const promiseTimeout_1 = require("../util/promiseTimeout");
+const parse_1 = require("./parse");
+function mapTransactionResponseToLog(transaction) {
+    return {
+        txSig: transaction.transaction.signatures[0],
+        slot: transaction.slot,
+        logs: transaction.meta.logMessages,
+    };
+}
+async function fetchLogs(connection, address, finality, beforeTx, untilTx, limit, batchSize = 25) {
+    const signatures = await connection.getSignaturesForAddress(address, {
+        before: beforeTx,
+        until: untilTx,
+        limit,
+    }, finality);
+    const sortedSignatures = signatures.sort((a, b) => a.slot === b.slot ? 0 : a.slot < b.slot ? -1 : 1);
+    const filteredSignatures = sortedSignatures.filter((signature) => !signature.err);
+    if (filteredSignatures.length === 0) {
+        return undefined;
+    }
+    const chunkedSignatures = chunk(filteredSignatures, batchSize);
+    const transactionLogs = (await Promise.all(chunkedSignatures.map(async (chunk) => {
+        return await fetchTransactionLogs(connection, chunk.map((confirmedSignature) => confirmedSignature.signature), finality);
+    }))).flat();
+    const earliest = filteredSignatures[0];
+    const mostRecent = filteredSignatures[filteredSignatures.length - 1];
+    return {
+        transactionLogs: transactionLogs,
+        earliestTx: earliest.signature,
+        mostRecentTx: mostRecent.signature,
+        earliestSlot: earliest.slot,
+        mostRecentSlot: mostRecent.slot,
+        mostRecentBlockTime: mostRecent.blockTime,
+    };
+}
+exports.fetchLogs = fetchLogs;
+async function fetchTransactionLogs(connection, signatures, finality) {
+    const requests = new Array();
+    for (const signature of signatures) {
+        const args = [
+            signature,
+            { commitment: finality, maxSupportedTransactionVersion: 0 },
+        ];
+        requests.push({
+            methodName: 'getTransaction',
+            args,
+        });
+    }
+    const rpcResponses = await (0, promiseTimeout_1.promiseTimeout)(
+    // @ts-ignore
+    connection._rpcBatchRequest(requests), 10 * 1000 // 10 second timeout
+    );
+    if (rpcResponses === null) {
+        return Promise.reject('RPC request timed out fetching transactions');
+    }
+    const logs = new Array();
+    for (const rpcResponse of rpcResponses) {
+        if (rpcResponse.result) {
+            logs.push(mapTransactionResponseToLog(rpcResponse.result));
+        }
+    }
+    return logs;
+}
+exports.fetchTransactionLogs = fetchTransactionLogs;
+function chunk(array, size) {
+    return new Array(Math.ceil(array.length / size))
+        .fill(null)
+        .map((_, index) => index * size)
+        .map((begin) => array.slice(begin, begin + size));
+}
+class LogParser {
+    constructor(program) {
+        this.program = program;
+    }
+    parseEventsFromTransaction(transaction) {
+        const transactionLogObject = mapTransactionResponseToLog(transaction);
+        return this.parseEventsFromLogs(transactionLogObject);
+    }
+    parseEventsFromLogs(event) {
+        const records = [];
+        if (!event.logs)
+            return records;
+        let runningEventIndex = 0;
+        for (const eventLog of (0, parse_1.parseLogs)(this.program, event.logs)) {
+            eventLog.data.txSig = event.txSig;
+            eventLog.data.slot = event.slot;
+            eventLog.data.eventType = eventLog.name;
+            eventLog.data.txSigIndex = runningEventIndex;
+            // @ts-ignore
+            records.push(eventLog.data);
+            runningEventIndex++;
+        }
+        return records;
+    }
+}
+exports.LogParser = LogParser;

package/lib/node/events/parse.d.ts

@@ -0,0 +1,6 @@
+import { Program, Event } from '@coral-xyz/anchor';
+export declare function parseLogs(program: Program, logs: string[], programId?: string): Event[];
+export declare function parseLogsWithRaw(program: Program, logs: string[], programId?: string): {
+    events: Event[];
+    rawLogs: string[];
+};

package/lib/node/events/parse.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLogsWithRaw = exports.parseLogs = void 0;
+const driftProgramId = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
+const PROGRAM_LOG = 'Program log: ';
+const PROGRAM_DATA = 'Program data: ';
+const PROGRAM_LOG_START_INDEX = PROGRAM_LOG.length;
+const PROGRAM_DATA_START_INDEX = PROGRAM_DATA.length;
+function parseLogs(program, logs, programId = driftProgramId) {
+    const { events } = parseLogsWithRaw(program, logs, programId);
+    return events;
+}
+exports.parseLogs = parseLogs;
+function parseLogsWithRaw(program, logs, programId = driftProgramId) {
+    const events = [];
+    const rawLogs = [];
+    const execution = new ExecutionContext();
+    for (const log of logs) {
+        if (log.startsWith('Log truncated')) {
+            break;
+        }
+        const [event, newProgram, didPop] = handleLog(execution, log, program, programId);
+        if (event) {
+            events.push(event);
+            rawLogs.push(log);
+        }
+        if (newProgram) {
+            execution.push(newProgram);
+        }
+        if (didPop) {
+            execution.pop();
+        }
+    }
+    return { events, rawLogs };
+}
+exports.parseLogsWithRaw = parseLogsWithRaw;
+function handleLog(execution, log, program, programId = driftProgramId) {
+    // Executing program is drift program.
+    if (execution.stack.length > 0 && execution.program() === programId) {
+        return handleProgramLog(log, program, programId);
+    }
+    // Executing program is not drift program.
+    else {
+        return [null, ...handleSystemLog(log, programId)];
+    }
+}
+// Handles logs from *drift* program.
+function handleProgramLog(log, program, programId = driftProgramId) {
+    // This is a `msg!` log or a `sol_log_data` log.
+    if (log.startsWith(PROGRAM_LOG)) {
+        const logStr = log.slice(PROGRAM_LOG_START_INDEX);
+        const event = program.coder.events.decode(logStr);
+        return [event, null, false];
+    }
+    else if (log.startsWith(PROGRAM_DATA)) {
+        const logStr = log.slice(PROGRAM_DATA_START_INDEX);
+        const event = program.coder.events.decode(logStr);
+        return [event, null, false];
+    }
+    else {
+        return [null, ...handleSystemLog(log, programId)];
+    }
+}
+// Handles logs when the current program being executing is *not* drift.
+function handleSystemLog(log, programId = driftProgramId) {
+    // System component.
+    const logStart = log.split(':')[0];
+    const programStart = `Program ${programId} invoke`;
+    // Did the program finish executing?
+    if (logStart.match(/^Program (.*) success/g) !== null) {
+        return [null, true];
+        // Recursive call.
+    }
+    else if (logStart.startsWith(programStart)) {
+        return [programId, false];
+    }
+    // CPI call.
+    else if (logStart.includes('invoke')) {
+        return ['cpi', false]; // Any string will do.
+    }
+    else {
+        return [null, false];
+    }
+}
+// Stack frame execution context, allowing one to track what program is
+// executing for a given log.
+class ExecutionContext {
+    constructor() {
+        this.stack = [];
+    }
+    program() {
+        if (!this.stack.length) {
+            throw new Error('Expected the stack to have elements');
+        }
+        return this.stack[this.stack.length - 1];
+    }
+    push(newProgram) {
+        this.stack.push(newProgram);
+    }
+    pop() {
+        if (!this.stack.length) {
+            throw new Error('Expected the stack to have elements');
+        }
+        this.stack.pop();
+    }
+}

package/lib/node/events/pollingLogProvider.d.ts

@@ -0,0 +1,17 @@
+import { LogProvider, logProviderCallback } from './types';
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+export declare class PollingLogProvider implements LogProvider {
+    private connection;
+    private address;
+    private frequency;
+    private batchSize?;
+    private finality;
+    private intervalId;
+    private mostRecentSeenTx?;
+    private mutex;
+    private firstFetch;
+    constructor(connection: Connection, address: PublicKey, commitment: Commitment, frequency?: number, batchSize?: number);
+    subscribe(callback: logProviderCallback, skipHistory?: boolean): Promise<boolean>;
+    isSubscribed(): boolean;
+    unsubscribe(): Promise<boolean>;
+}

package/lib/node/events/pollingLogProvider.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingLogProvider = void 0;
+const fetchLogs_1 = require("./fetchLogs");
+class PollingLogProvider {
+    constructor(connection, address, commitment, frequency = 15 * 1000, batchSize) {
+        this.connection = connection;
+        this.address = address;
+        this.frequency = frequency;
+        this.batchSize = batchSize;
+        this.firstFetch = true;
+        this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
+    }
+    async subscribe(callback, skipHistory) {
+        if (this.intervalId) {
+            return true;
+        }
+        this.intervalId = setInterval(async () => {
+            if (this.mutex === 1) {
+                return;
+            }
+            this.mutex = 1;
+            try {
+                const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.address, this.finality, undefined, this.mostRecentSeenTx, 
+                // If skipping history, only fetch one log back, not the maximum amount available
+                skipHistory && this.firstFetch ? 1 : undefined, this.batchSize);
+                if (response === undefined) {
+                    return;
+                }
+                this.firstFetch = false;
+                const { mostRecentTx, transactionLogs } = response;
+                for (const { txSig, slot, logs } of transactionLogs) {
+                    callback(txSig, slot, logs, response.mostRecentBlockTime, undefined);
+                }
+                this.mostRecentSeenTx = mostRecentTx;
+            }
+            catch (e) {
+                console.error('PollingLogProvider threw an Error');
+                console.error(e);
+            }
+            finally {
+                this.mutex = 0;
+            }
+        }, this.frequency);
+        return true;
+    }
+    isSubscribed() {
+        return this.intervalId !== undefined;
+    }
+    async unsubscribe() {
+        if (this.intervalId !== undefined) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+        return true;
+    }
+}
+exports.PollingLogProvider = PollingLogProvider;

package/lib/node/events/sort.d.ts

@@ -0,0 +1,2 @@
+import { EventSubscriptionOrderBy, EventSubscriptionOrderDirection, SortFn } from './types';
+export declare function getSortFn(orderBy: EventSubscriptionOrderBy, orderDir: EventSubscriptionOrderDirection): SortFn;

package/lib/node/events/sort.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortFn = void 0;
+function clientSortAscFn() {
+    return 'less than';
+}
+function clientSortDescFn() {
+    return 'greater than';
+}
+function blockchainSortFn(currentEvent, newEvent) {
+    if (currentEvent.slot == newEvent.slot) {
+        return currentEvent.txSigIndex < newEvent.txSigIndex
+            ? 'less than'
+            : 'greater than';
+    }
+    return currentEvent.slot < newEvent.slot ? 'less than' : 'greater than';
+}
+function getSortFn(orderBy, orderDir) {
+    if (orderBy === 'client') {
+        return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
+    }
+    return blockchainSortFn;
+}
+exports.getSortFn = getSortFn;

package/lib/node/events/txEventCache.d.ts

@@ -0,0 +1,24 @@
+import { WrappedEvent, EventType } from './types';
+declare class Node {
+    key: string;
+    value: WrappedEvent<EventType>[];
+    next?: Node;
+    prev?: Node;
+    constructor(key: string, value: WrappedEvent<EventType>[], next?: Node, prev?: Node);
+}
+export declare class TxEventCache {
+    maxTx: number;
+    size: number;
+    head?: Node;
+    tail?: Node;
+    cacheMap: {
+        [key: string]: Node;
+    };
+    constructor(maxTx?: number);
+    add(key: string, events: WrappedEvent<EventType>[]): void;
+    has(key: string): boolean;
+    get(key: string): WrappedEvent<EventType>[] | undefined;
+    detach(node: Node): void;
+    clear(): void;
+}
+export {};

package/lib/node/events/txEventCache.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxEventCache = void 0;
+class Node {
+    constructor(key, value, next, prev) {
+        this.key = key;
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+// lru cache
+class TxEventCache {
+    constructor(maxTx = 1024) {
+        this.maxTx = maxTx;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+    add(key, events) {
+        const existingNode = this.cacheMap[key];
+        if (existingNode) {
+            this.detach(existingNode);
+            this.size--;
+        }
+        else if (this.size === this.maxTx) {
+            delete this.cacheMap[this.tail.key];
+            this.detach(this.tail);
+            this.size--;
+        }
+        // Write to head of LinkedList
+        if (!this.head) {
+            this.head = this.tail = new Node(key, events);
+        }
+        else {
+            const node = new Node(key, events, this.head);
+            this.head.prev = node;
+            this.head = node;
+        }
+        // update cacheMap with LinkedList key and Node reference
+        this.cacheMap[key] = this.head;
+        this.size++;
+    }
+    has(key) {
+        return this.cacheMap.hasOwnProperty(key);
+    }
+    get(key) {
+        var _a;
+        return (_a = this.cacheMap[key]) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    detach(node) {
+        if (node.prev !== undefined) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next !== undefined) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+    }
+    clear() {
+        this.head = undefined;
+        this.tail = undefined;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+}
+exports.TxEventCache = TxEventCache;

package/lib/node/events/types.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+import { Commitment, PublicKey, TransactionSignature } from '@solana/web3.js';
+import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord, InsuranceFundRecord, SpotInterestRecord, InsuranceFundStakeRecord, CurveRecord, SwapRecord, SpotMarketVaultDepositRecord } from '../index';
+import { EventEmitter } from 'events';
+export type EventSubscriptionOptions = {
+    address?: PublicKey;
+    eventTypes?: EventType[];
+    maxEventsPerType?: number;
+    orderBy?: EventSubscriptionOrderBy;
+    orderDir?: EventSubscriptionOrderDirection;
+    commitment?: Commitment;
+    maxTx?: number;
+    logProviderConfig?: LogProviderConfig;
+    untilTx?: TransactionSignature;
+};
+export declare const DefaultEventSubscriptionOptions: EventSubscriptionOptions;
+export type EventSubscriptionOrderBy = 'blockchain' | 'client';
+export type EventSubscriptionOrderDirection = 'asc' | 'desc';
+export type Event<T> = T & {
+    txSig: TransactionSignature;
+    slot: number;
+    txSigIndex: number;
+};
+export type WrappedEvent<Type extends EventType> = EventMap[Type] & {
+    eventType: Type;
+};
+export type WrappedEvents = WrappedEvent<EventType>[];
+export type EventMap = {
+    DepositRecord: Event<DepositRecord>;
+    FundingPaymentRecord: Event<FundingPaymentRecord>;
+    LiquidationRecord: Event<LiquidationRecord>;
+    FundingRateRecord: Event<FundingRateRecord>;
+    OrderRecord: Event<OrderRecord>;
+    OrderActionRecord: Event<OrderActionRecord>;
+    SettlePnlRecord: Event<SettlePnlRecord>;
+    NewUserRecord: Event<NewUserRecord>;
+    LPRecord: Event<LPRecord>;
+    InsuranceFundRecord: Event<InsuranceFundRecord>;
+    SpotInterestRecord: Event<SpotInterestRecord>;
+    InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
+    CurveRecord: Event<CurveRecord>;
+    SwapRecord: Event<SwapRecord>;
+    SpotMarketVaultDepositRecord: Event<SpotMarketVaultDepositRecord>;
+};
+export type EventType = keyof EventMap;
+export type DriftEvent = Event<DepositRecord> | Event<FundingPaymentRecord> | Event<LiquidationRecord> | Event<FundingRateRecord> | Event<OrderRecord> | Event<OrderActionRecord> | Event<SettlePnlRecord> | Event<NewUserRecord> | Event<LPRecord> | Event<InsuranceFundRecord> | Event<SpotInterestRecord> | Event<InsuranceFundStakeRecord> | Event<CurveRecord> | Event<SwapRecord> | Event<SpotMarketVaultDepositRecord>;
+export interface EventSubscriberEvents {
+    newEvent: (event: WrappedEvent<EventType>) => void;
+}
+export type SortFn = (currentRecord: EventMap[EventType], newRecord: EventMap[EventType]) => 'less than' | 'greater than';
+export type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[], mostRecentBlockTime: number | undefined, txSigIndex: number | undefined) => void;
+export interface LogProvider {
+    isSubscribed(): boolean;
+    subscribe(callback: logProviderCallback, skipHistory?: boolean): Promise<boolean>;
+    unsubscribe(external?: boolean): Promise<boolean>;
+    eventEmitter?: EventEmitter;
+}
+export type LogProviderType = 'websocket' | 'polling' | 'events-server';
+export type StreamingLogProviderConfig = {
+    maxReconnectAttempts?: number;
+    fallbackFrequency?: number;
+    fallbackBatchSize?: number;
+};
+export type WebSocketLogProviderConfig = StreamingLogProviderConfig & {
+    type: 'websocket';
+    resubTimeoutMs?: number;
+};
+export type PollingLogProviderConfig = {
+    type: 'polling';
+    frequency: number;
+    batchSize?: number;
+};
+export type EventsServerLogProviderConfig = StreamingLogProviderConfig & {
+    type: 'events-server';
+    url: string;
+};
+export type LogProviderConfig = WebSocketLogProviderConfig | PollingLogProviderConfig | EventsServerLogProviderConfig;

package/lib/node/events/types.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultEventSubscriptionOptions = void 0;
+exports.DefaultEventSubscriptionOptions = {
+    eventTypes: [
+        'DepositRecord',
+        'FundingPaymentRecord',
+        'LiquidationRecord',
+        'OrderRecord',
+        'OrderActionRecord',
+        'FundingRateRecord',
+        'NewUserRecord',
+        'SettlePnlRecord',
+        'LPRecord',
+        'InsuranceFundRecord',
+        'SpotInterestRecord',
+        'InsuranceFundStakeRecord',
+        'CurveRecord',
+        'SwapRecord',
+        'SpotMarketVaultDepositRecord',
+    ],
+    maxEventsPerType: 4096,
+    orderBy: 'blockchain',
+    orderDir: 'asc',
+    commitment: 'confirmed',
+    maxTx: 4096,
+    logProviderConfig: {
+        type: 'websocket',
+    },
+};

package/lib/node/events/webSocketLogProvider.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { LogProvider, logProviderCallback } from './types';
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+export declare class WebSocketLogProvider implements LogProvider {
+    private connection;
+    private address;
+    private commitment;
+    private resubTimeoutMs?;
+    private subscriptionId;
+    private isUnsubscribing;
+    private externalUnsubscribe;
+    private receivingData;
+    private timeoutId?;
+    private reconnectAttempts;
+    eventEmitter?: EventEmitter;
+    private callback?;
+    constructor(connection: Connection, address: PublicKey, commitment: Commitment, resubTimeoutMs?: number);
+    subscribe(callback: logProviderCallback): Promise<boolean>;
+    setSubscription(callback: logProviderCallback): void;
+    isSubscribed(): boolean;
+    unsubscribe(external?: boolean): Promise<boolean>;
+    private setTimeout;
+}

package/lib/node/events/webSocketLogProvider.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketLogProvider = void 0;
+const events_1 = require("events");
+class WebSocketLogProvider {
+    constructor(connection, address, commitment, resubTimeoutMs) {
+        this.connection = connection;
+        this.address = address;
+        this.commitment = commitment;
+        this.resubTimeoutMs = resubTimeoutMs;
+        this.isUnsubscribing = false;
+        this.externalUnsubscribe = false;
+        this.receivingData = false;
+        this.reconnectAttempts = 0;
+        if (this.resubTimeoutMs) {
+            this.eventEmitter = new events_1.EventEmitter();
+        }
+    }
+    async subscribe(callback) {
+        if (this.subscriptionId != null) {
+            return true;
+        }
+        this.callback = callback;
+        try {
+            this.setSubscription(callback);
+        }
+        catch (error) {
+            // Sometimes ws connection isn't ready, give it a few secs
+            setTimeout(() => this.setSubscription(callback), 2000);
+        }
+        if (this.resubTimeoutMs) {
+            this.setTimeout();
+        }
+        return true;
+    }
+    setSubscription(callback) {
+        this.subscriptionId = this.connection.onLogs(this.address, (logs, ctx) => {
+            if (this.resubTimeoutMs && !this.isUnsubscribing) {
+                this.receivingData = true;
+                clearTimeout(this.timeoutId);
+                this.setTimeout();
+                if (this.reconnectAttempts > 0) {
+                    console.log('Resetting reconnect attempts to 0');
+                }
+                this.reconnectAttempts = 0;
+            }
+            if (logs.err !== null) {
+                return;
+            }
+            callback(logs.signature, ctx.slot, logs.logs, undefined, undefined);
+        }, this.commitment);
+    }
+    isSubscribed() {
+        return this.subscriptionId != null;
+    }
+    async unsubscribe(external = false) {
+        this.isUnsubscribing = true;
+        this.externalUnsubscribe = external;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
+            try {
+                await this.connection.removeOnLogsListener(this.subscriptionId);
+                this.subscriptionId = undefined;
+                this.isUnsubscribing = false;
+                return true;
+            }
+            catch (err) {
+                console.log('Error unsubscribing from logs: ', err);
+                this.isUnsubscribing = false;
+                return false;
+            }
+        }
+        else {
+            this.isUnsubscribing = false;
+            return true;
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing || this.externalUnsubscribe) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`webSocketLogProvider: No log data in ${this.resubTimeoutMs}ms, resubscribing on attempt ${this.reconnectAttempts + 1}`);
+                await this.unsubscribe();
+                this.receivingData = false;
+                this.reconnectAttempts++;
+                this.eventEmitter.emit('reconnect', this.reconnectAttempts);
+                this.subscribe(this.callback);
+            }
+        }, this.resubTimeoutMs);
+    }
+}
+exports.WebSocketLogProvider = WebSocketLogProvider;