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

package/lib/node/dlob/DLOBApiClient.d.ts

@@ -0,0 +1,14 @@
+import { DLOBOrdersCoder } from './DLOBOrders';
+import { DLOB } from './DLOB';
+type DLOBApiClientConfig = {
+    url: string;
+};
+export declare class DLOBApiClient {
+    url: string;
+    dlobCoder: DLOBOrdersCoder;
+    lastSeenDLOB: DLOB;
+    lastSeenSlot: number;
+    constructor(config: DLOBApiClientConfig);
+    getDLOB(slot: number): Promise<DLOB>;
+}
+export {};

package/lib/node/dlob/DLOBApiClient.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLOBApiClient = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const DLOBOrders_1 = require("./DLOBOrders");
+const DLOB_1 = require("./DLOB");
+class DLOBApiClient {
+    constructor(config) {
+        this.dlobCoder = DLOBOrders_1.DLOBOrdersCoder.create();
+        this.lastSeenSlot = 0;
+        this.url = config.url;
+    }
+    async getDLOB(slot) {
+        const r = await (0, node_fetch_1.default)(this.url);
+        if (!r.ok) {
+            throw new Error(`Failed to fetch DLOB from ${this.url}. Status: ${r.status}, ${r.statusText}`);
+        }
+        const resp = await r.json();
+        const responseSlot = resp['slot'];
+        if (responseSlot > this.lastSeenSlot) {
+            const dlobOrdersBuffer = Buffer.from(resp['data'], 'base64');
+            const dlobOrders = this.dlobCoder.decode(Buffer.from(dlobOrdersBuffer));
+            const dlob = new DLOB_1.DLOB();
+            dlob.initFromOrders(dlobOrders, slot);
+            this.lastSeenDLOB = dlob;
+            this.lastSeenSlot = responseSlot;
+        }
+        return this.lastSeenDLOB;
+    }
+}
+exports.DLOBApiClient = DLOBApiClient;

package/lib/node/dlob/DLOBNode.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="bn.js" />
+import { BN, OraclePriceData, Order } from '..';
+export interface DLOBNode {
+    getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
+    isVammNode(): boolean;
+    order: Order | undefined;
+    isBaseFilled(): boolean;
+    haveFilled: boolean;
+    userAccount: string | undefined;
+}
+export declare abstract class OrderNode implements DLOBNode {
+    order: Order;
+    userAccount: string;
+    sortValue: BN;
+    haveFilled: boolean;
+    haveTrigger: boolean;
+    constructor(order: Order, userAccount: string);
+    abstract getSortValue(order: Order): BN;
+    getLabel(): string;
+    getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
+    isBaseFilled(): boolean;
+    isVammNode(): boolean;
+}
+export declare class TakingLimitOrderNode extends OrderNode {
+    next?: TakingLimitOrderNode;
+    previous?: TakingLimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class RestingLimitOrderNode extends OrderNode {
+    next?: RestingLimitOrderNode;
+    previous?: RestingLimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class FloatingLimitOrderNode extends OrderNode {
+    next?: FloatingLimitOrderNode;
+    previous?: FloatingLimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class MarketOrderNode extends OrderNode {
+    next?: MarketOrderNode;
+    previous?: MarketOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class TriggerOrderNode extends OrderNode {
+    next?: TriggerOrderNode;
+    previous?: TriggerOrderNode;
+    getSortValue(order: Order): BN;
+}
+export type DLOBNodeMap = {
+    restingLimit: RestingLimitOrderNode;
+    takingLimit: TakingLimitOrderNode;
+    floatingLimit: FloatingLimitOrderNode;
+    market: MarketOrderNode;
+    trigger: TriggerOrderNode;
+};
+export type DLOBNodeType = 'restingLimit' | 'takingLimit' | 'floatingLimit' | 'market' | ('trigger' & keyof DLOBNodeMap);
+export declare function createNode<T extends DLOBNodeType>(nodeType: T, order: Order, userAccount: string): DLOBNodeMap[T];

package/lib/node/dlob/DLOBNode.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNode = exports.TriggerOrderNode = exports.MarketOrderNode = exports.FloatingLimitOrderNode = exports.RestingLimitOrderNode = exports.TakingLimitOrderNode = exports.OrderNode = void 0;
+const __1 = require("..");
+// import { PublicKey } from '@solana/web3.js';
+const NodeList_1 = require("./NodeList");
+class OrderNode {
+    constructor(order, userAccount) {
+        this.haveFilled = false;
+        this.haveTrigger = false;
+        // Copy the order over to the node
+        this.order = { ...order };
+        this.userAccount = userAccount;
+        this.sortValue = this.getSortValue(order);
+    }
+    getLabel() {
+        let msg = `Order ${(0, NodeList_1.getOrderSignature)(this.order.orderId, this.userAccount)}`;
+        msg += ` ${(0, __1.isVariant)(this.order.direction, 'long') ? 'LONG' : 'SHORT'} `;
+        msg += `${(0, __1.convertToNumber)(this.order.baseAssetAmount, __1.AMM_RESERVE_PRECISION).toFixed(3)}`;
+        if (this.order.price.gt(__1.ZERO)) {
+            msg += ` @ ${(0, __1.convertToNumber)(this.order.price, __1.PRICE_PRECISION).toFixed(3)}`;
+        }
+        if (this.order.triggerPrice.gt(__1.ZERO)) {
+            msg += ` ${(0, __1.isVariant)(this.order.triggerCondition, 'below') ? 'BELOW' : 'ABOVE'}`;
+            msg += ` ${(0, __1.convertToNumber)(this.order.triggerPrice, __1.PRICE_PRECISION).toFixed(3)}`;
+        }
+        return msg;
+    }
+    getPrice(oraclePriceData, slot) {
+        return (0, __1.getLimitPrice)(this.order, oraclePriceData, slot);
+    }
+    isBaseFilled() {
+        return this.order.baseAssetAmountFilled.eq(this.order.baseAssetAmount);
+    }
+    isVammNode() {
+        return false;
+    }
+}
+exports.OrderNode = OrderNode;
+class TakingLimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.slot;
+    }
+}
+exports.TakingLimitOrderNode = TakingLimitOrderNode;
+class RestingLimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.price;
+    }
+}
+exports.RestingLimitOrderNode = RestingLimitOrderNode;
+class FloatingLimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return new __1.BN(order.oraclePriceOffset);
+    }
+}
+exports.FloatingLimitOrderNode = FloatingLimitOrderNode;
+class MarketOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.slot;
+    }
+}
+exports.MarketOrderNode = MarketOrderNode;
+class TriggerOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.triggerPrice;
+    }
+}
+exports.TriggerOrderNode = TriggerOrderNode;
+function createNode(nodeType, order, userAccount) {
+    switch (nodeType) {
+        case 'floatingLimit':
+            return new FloatingLimitOrderNode(order, userAccount);
+        case 'restingLimit':
+            return new RestingLimitOrderNode(order, userAccount);
+        case 'takingLimit':
+            return new TakingLimitOrderNode(order, userAccount);
+        case 'market':
+            return new MarketOrderNode(order, userAccount);
+        case 'trigger':
+            return new TriggerOrderNode(order, userAccount);
+        default:
+            throw Error(`Unknown DLOBNode type ${nodeType}`);
+    }
+}
+exports.createNode = createNode;

package/lib/node/dlob/DLOBOrders.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { PublicKey } from '@solana/web3.js';
+import { Idl } from '@coral-xyz/anchor';
+import { Order } from '../types';
+export type DLOBOrder = {
+    user: PublicKey;
+    order: Order;
+};
+export type DLOBOrders = DLOBOrder[];
+export declare class DLOBOrdersCoder {
+    private idl;
+    constructor(idl: Idl);
+    static create(): DLOBOrdersCoder;
+    encode(dlobOrders: DLOBOrders): Buffer;
+    decode(buffer: Buffer): DLOBOrders;
+}

package/lib/node/dlob/DLOBOrders.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLOBOrdersCoder = void 0;
+const idl_1 = require("@coral-xyz/anchor/dist/cjs/coder/borsh/idl");
+const dlobIdl_json_1 = __importDefault(require("./dlobIdl.json"));
+class DLOBOrdersCoder {
+    constructor(idl) {
+        this.idl = idl;
+    }
+    static create() {
+        return new DLOBOrdersCoder(dlobIdl_json_1.default);
+    }
+    encode(dlobOrders) {
+        const layout = idl_1.IdlCoder.fieldLayout({
+            type: {
+                vec: {
+                    defined: 'DLOBOrder',
+                },
+            },
+        }, this.idl.types);
+        const size = 150 * dlobOrders.length;
+        const buffer = Buffer.alloc(size);
+        const len = layout.encode(dlobOrders, buffer);
+        return buffer.slice(0, len);
+    }
+    decode(buffer) {
+        const layout = idl_1.IdlCoder.fieldLayout({
+            type: {
+                vec: {
+                    defined: 'DLOBOrder',
+                },
+            },
+        }, this.idl.types);
+        return layout.decode(buffer);
+    }
+}
+exports.DLOBOrdersCoder = DLOBOrdersCoder;

package/lib/node/dlob/DLOBSubscriber.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { DLOB } from './DLOB';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { DLOBSource, DLOBSubscriberEvents, DLOBSubscriptionConfig, SlotSource } from './types';
+import { DriftClient } from '../driftClient';
+import { MarketType } from '../types';
+import { L2OrderBook, L2OrderBookGenerator, L3OrderBook } from './orderBookLevels';
+export declare class DLOBSubscriber {
+    driftClient: DriftClient;
+    dlobSource: DLOBSource;
+    slotSource: SlotSource;
+    updateFrequency: number;
+    intervalId?: NodeJS.Timeout;
+    dlob: DLOB;
+    eventEmitter: StrictEventEmitter<EventEmitter, DLOBSubscriberEvents>;
+    constructor(config: DLOBSubscriptionConfig);
+    subscribe(): Promise<void>;
+    updateDLOB(): Promise<void>;
+    getDLOB(): DLOB;
+    /**
+     * Get the L2 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     * @param depth Number of orders to include in the order book. Defaults to 10.
+     * @param includeVamm Whether to include the VAMM orders in the order book. Defaults to false. If true, creates vAMM generator {@link getVammL2Generator} and adds it to fallbackL2Generators.
+     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+     */
+    getL2({ marketName, marketIndex, marketType, depth, includeVamm, numVammOrders, fallbackL2Generators, }: {
+        marketName?: string;
+        marketIndex?: number;
+        marketType?: MarketType;
+        depth?: number;
+        includeVamm?: boolean;
+        numVammOrders?: number;
+        fallbackL2Generators?: L2OrderBookGenerator[];
+    }): L2OrderBook;
+    /**
+     * Get the L3 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     */
+    getL3({ marketName, marketIndex, marketType, }: {
+        marketName?: string;
+        marketIndex?: number;
+        marketType?: MarketType;
+    }): L3OrderBook;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/dlob/DLOBSubscriber.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLOBSubscriber = void 0;
+const DLOB_1 = require("./DLOB");
+const events_1 = require("events");
+const types_1 = require("../types");
+const orderBookLevels_1 = require("./orderBookLevels");
+class DLOBSubscriber {
+    constructor(config) {
+        this.dlob = new DLOB_1.DLOB();
+        this.driftClient = config.driftClient;
+        this.dlobSource = config.dlobSource;
+        this.slotSource = config.slotSource;
+        this.updateFrequency = config.updateFrequency;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        if (this.intervalId) {
+            return;
+        }
+        await this.updateDLOB();
+        this.intervalId = setInterval(async () => {
+            try {
+                await this.updateDLOB();
+                this.eventEmitter.emit('update', this.dlob);
+            }
+            catch (e) {
+                this.eventEmitter.emit('error', e);
+            }
+        }, this.updateFrequency);
+    }
+    async updateDLOB() {
+        this.dlob = await this.dlobSource.getDLOB(this.slotSource.getSlot());
+    }
+    getDLOB() {
+        return this.dlob;
+    }
+    /**
+     * Get the L2 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     * @param depth Number of orders to include in the order book. Defaults to 10.
+     * @param includeVamm Whether to include the VAMM orders in the order book. Defaults to false. If true, creates vAMM generator {@link getVammL2Generator} and adds it to fallbackL2Generators.
+     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+     */
+    getL2({ marketName, marketIndex, marketType, depth = 10, includeVamm = false, numVammOrders, fallbackL2Generators = [], }) {
+        if (marketName) {
+            const derivedMarketInfo = this.driftClient.getMarketIndexAndType(marketName);
+            if (!derivedMarketInfo) {
+                throw new Error(`Market ${marketName} not found`);
+            }
+            marketIndex = derivedMarketInfo.marketIndex;
+            marketType = derivedMarketInfo.marketType;
+        }
+        else {
+            if (marketIndex === undefined || marketType === undefined) {
+                throw new Error('Either marketName or marketIndex and marketType must be provided');
+            }
+        }
+        let oraclePriceData;
+        const isPerp = (0, types_1.isVariant)(marketType, 'perp');
+        if (isPerp) {
+            const perpMarketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+            oraclePriceData = this.driftClient.getOracleDataForPerpMarket(perpMarketAccount.marketIndex);
+        }
+        else {
+            oraclePriceData =
+                this.driftClient.getOracleDataForSpotMarket(marketIndex);
+        }
+        if (isPerp && includeVamm) {
+            if (fallbackL2Generators.length > 0) {
+                throw new Error('includeVamm can only be used if fallbackL2Generators is empty');
+            }
+            fallbackL2Generators = [
+                (0, orderBookLevels_1.getVammL2Generator)({
+                    marketAccount: this.driftClient.getPerpMarketAccount(marketIndex),
+                    oraclePriceData,
+                    numOrders: numVammOrders !== null && numVammOrders !== void 0 ? numVammOrders : depth,
+                    topOfBookQuoteAmounts: orderBookLevels_1.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
+                }),
+            ];
+        }
+        return this.dlob.getL2({
+            marketIndex,
+            marketType,
+            depth,
+            oraclePriceData,
+            slot: this.slotSource.getSlot(),
+            fallbackL2Generators: fallbackL2Generators,
+        });
+    }
+    /**
+     * Get the L3 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     */
+    getL3({ marketName, marketIndex, marketType, }) {
+        if (marketName) {
+            const derivedMarketInfo = this.driftClient.getMarketIndexAndType(marketName);
+            if (!derivedMarketInfo) {
+                throw new Error(`Market ${marketName} not found`);
+            }
+            marketIndex = derivedMarketInfo.marketIndex;
+            marketType = derivedMarketInfo.marketType;
+        }
+        else {
+            if (marketIndex === undefined || marketType === undefined) {
+                throw new Error('Either marketName or marketIndex and marketType must be provided');
+            }
+        }
+        let oraclePriceData;
+        const isPerp = (0, types_1.isVariant)(marketType, 'perp');
+        if (isPerp) {
+            oraclePriceData =
+                this.driftClient.getOracleDataForPerpMarket(marketIndex);
+        }
+        else {
+            oraclePriceData =
+                this.driftClient.getOracleDataForSpotMarket(marketIndex);
+        }
+        return this.dlob.getL3({
+            marketIndex,
+            marketType,
+            oraclePriceData,
+            slot: this.slotSource.getSlot(),
+        });
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.DLOBSubscriber = DLOBSubscriber;

package/lib/node/dlob/NodeList.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="bn.js" />
+import { BN, MarketTypeStr, Order } from '..';
+import { DLOBNode, DLOBNodeMap } from './DLOBNode';
+export type SortDirection = 'asc' | 'desc';
+export declare function getOrderSignature(orderId: number, userAccount: string): string;
+export interface DLOBNodeGenerator {
+    getGenerator(): Generator<DLOBNode>;
+}
+export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLOBNodeGenerator {
+    private nodeType;
+    private sortDirection;
+    head?: DLOBNodeMap[NodeType];
+    length: number;
+    nodeMap: Map<string, DLOBNodeMap[NodeType]>;
+    constructor(nodeType: NodeType, sortDirection: SortDirection);
+    clear(): void;
+    insert(order: Order, marketType: MarketTypeStr, userAccount: string): void;
+    prependNode(currentNode: DLOBNodeMap[NodeType], newNode: DLOBNodeMap[NodeType]): boolean;
+    update(order: Order, userAccount: string): void;
+    remove(order: Order, userAccount: string): void;
+    getGenerator(): Generator<DLOBNode>;
+    has(order: Order, userAccount: string): boolean;
+    get(orderSignature: string): DLOBNodeMap[NodeType] | undefined;
+    print(): void;
+    printTop(): void;
+}
+export declare function getVammNodeGenerator(price: BN | undefined): Generator<DLOBNode>;

package/lib/node/dlob/NodeList.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVammNodeGenerator = exports.NodeList = exports.getOrderSignature = void 0;
+const __1 = require("..");
+// import { PublicKey } from '@solana/web3.js';
+const DLOBNode_1 = require("./DLOBNode");
+function getOrderSignature(orderId, userAccount) {
+    return `${userAccount.toString()}-${orderId.toString()}`;
+}
+exports.getOrderSignature = getOrderSignature;
+class NodeList {
+    constructor(nodeType, sortDirection) {
+        this.nodeType = nodeType;
+        this.sortDirection = sortDirection;
+        this.length = 0;
+        this.nodeMap = new Map();
+    }
+    clear() {
+        this.head = undefined;
+        this.length = 0;
+        this.nodeMap.clear();
+    }
+    insert(order, marketType, userAccount) {
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        const newNode = (0, DLOBNode_1.createNode)(this.nodeType, order, userAccount);
+        const orderSignature = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderSignature)) {
+            return;
+        }
+        this.nodeMap.set(orderSignature, newNode);
+        this.length += 1;
+        if (this.head === undefined) {
+            this.head = newNode;
+            return;
+        }
+        if (this.prependNode(this.head, newNode)) {
+            this.head.previous = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+            return;
+        }
+        let currentNode = this.head;
+        while (currentNode.next !== undefined &&
+            !this.prependNode(currentNode.next, newNode)) {
+            currentNode = currentNode.next;
+        }
+        newNode.next = currentNode.next;
+        if (currentNode.next !== undefined) {
+            newNode.next.previous = newNode;
+        }
+        currentNode.next = newNode;
+        newNode.previous = currentNode;
+    }
+    prependNode(currentNode, newNode) {
+        const currentOrder = currentNode.order;
+        const newOrder = newNode.order;
+        const currentOrderSortPrice = currentNode.sortValue;
+        const newOrderSortPrice = newNode.sortValue;
+        if (newOrderSortPrice.eq(currentOrderSortPrice)) {
+            return newOrder.slot.lt(currentOrder.slot);
+        }
+        if (this.sortDirection === 'asc') {
+            return newOrderSortPrice.lt(currentOrderSortPrice);
+        }
+        else {
+            return newOrderSortPrice.gt(currentOrderSortPrice);
+        }
+    }
+    update(order, userAccount) {
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            const node = this.nodeMap.get(orderId);
+            Object.assign(node.order, order);
+            node.haveFilled = false;
+        }
+    }
+    remove(order, userAccount) {
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            const node = this.nodeMap.get(orderId);
+            if (node.next) {
+                node.next.previous = node.previous;
+            }
+            if (node.previous) {
+                node.previous.next = node.next;
+            }
+            if (this.head && node.order.orderId === this.head.order.orderId) {
+                this.head = node.next;
+            }
+            node.previous = undefined;
+            node.next = undefined;
+            this.nodeMap.delete(orderId);
+            this.length--;
+        }
+    }
+    *getGenerator() {
+        let node = this.head;
+        while (node !== undefined) {
+            yield node;
+            node = node.next;
+        }
+    }
+    has(order, userAccount) {
+        return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
+    }
+    get(orderSignature) {
+        return this.nodeMap.get(orderSignature);
+    }
+    print() {
+        let currentNode = this.head;
+        while (currentNode !== undefined) {
+            console.log(currentNode.getLabel());
+            currentNode = currentNode.next;
+        }
+    }
+    printTop() {
+        if (this.head) {
+            console.log(this.sortDirection.toUpperCase(), this.head.getLabel());
+        }
+        else {
+            console.log('---');
+        }
+    }
+}
+exports.NodeList = NodeList;
+function* getVammNodeGenerator(price) {
+    if (!price) {
+        return;
+    }
+    yield {
+        getPrice: () => price,
+        isVammNode: () => true,
+        order: undefined,
+        userAccount: undefined,
+        isBaseFilled: () => false,
+        haveFilled: false,
+    };
+}
+exports.getVammNodeGenerator = getVammNodeGenerator;