@drift-labs/sdk 2.48.0-beta.8 → 2.49.0-beta.0

package/lib/user.js

@@ -22,7 +22,7 @@ class User {
         this._isSubscribed = val;
     }
     constructor(config) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         this._isSubscribed = false;
         this.driftClient = config.driftClient;
         this.userAccountPublicKey = config.userAccountPublicKey;
@@ -33,7 +33,7 @@ class User {
             this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
         }
         else {
-            this.accountSubscriber = new webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber(config.driftClient.program, config.userAccountPublicKey, config.accountSubscription.resubTimeoutMs, config.accountSubscription.commitment);
+            this.accountSubscriber = new webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber(config.driftClient.program, config.userAccountPublicKey, (_c = config.accountSubscription) === null || _c === void 0 ? void 0 : _c.resubTimeoutMs, (_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.commitment);
         }
         this.eventEmitter = this.accountSubscriber.eventEmitter;
     }
@@ -1670,6 +1670,7 @@ class User {
         // eslint-disable-next-line prefer-const
         let { borrowLimit, withdrawLimit } = (0, spotBalance_1.calculateWithdrawLimit)(spotMarket, nowTs);
         const freeCollateral = this.getFreeCollateral();
+        const initialMarginRequirement = this.getInitialMarginRequirement();
         const oracleData = this.getOracleDataForSpotMarket(marketIndex);
         const precisionIncrease = numericConstants_1.TEN.pow(new _1.BN(spotMarket.decimals - 6));
         const { canBypass, depositAmount: userDepositAmount } = this.canBypassWithdrawLimits(marketIndex);
@@ -1681,6 +1682,9 @@ class User {
         if (assetWeight.eq(numericConstants_1.ZERO)) {
             amountWithdrawable = userDepositAmount;
         }
+        else if (initialMarginRequirement.eq(numericConstants_1.ZERO)) {
+            amountWithdrawable = userDepositAmount;
+        }
         else {
             amountWithdrawable = (0, _1.divCeil)((0, _1.divCeil)(freeCollateral.mul(numericConstants_1.MARGIN_PRECISION), assetWeight).mul(numericConstants_1.PRICE_PRECISION), oracleData.price).mul(precisionIncrease);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.48.0-beta.8",
+	"version": "2.49.0-beta.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkAccountLoader.ts

@@ -193,7 +193,7 @@ export class BulkAccountLoader {
 				const key = accountToLoad.publicKey.toBase58();
 				const oldRPCResponse = this.bufferAndSlotMap.get(key);
 
-				if (oldRPCResponse && newSlot <= oldRPCResponse.slot) {
+				if (oldRPCResponse && newSlot < oldRPCResponse.slot) {
 					return;
 				}
 

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -93,15 +93,21 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	}
 
 	async fetch(): Promise<void> {
-		const dataAndContext = await this.program.account.user.fetchAndContext(
-			this.userAccountPublicKey,
-			this.accountLoader.commitment
-		);
-		if (dataAndContext.context.slot > (this.user?.slot ?? 0)) {
-			this.user = {
-				data: dataAndContext.data as UserAccount,
-				slot: dataAndContext.context.slot,
-			};
+		try {
+			const dataAndContext = await this.program.account.user.fetchAndContext(
+				this.userAccountPublicKey,
+				this.accountLoader.commitment
+			);
+			if (dataAndContext.context.slot > (this.user?.slot ?? 0)) {
+				this.user = {
+					data: dataAndContext.data as UserAccount,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingUserAccountSubscriber.fetch() UserAccount does not exist: ${e.message}`
+			);
 		}
 	}
 

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -97,15 +97,22 @@ export class PollingUserStatsAccountSubscriber
 	}
 
 	async fetch(): Promise<void> {
-		const dataAndContext = await this.program.account.userStats.fetchAndContext(
-			this.userStatsAccountPublicKey,
-			this.accountLoader.commitment
-		);
-		if (dataAndContext.context.slot > (this.userStats?.slot ?? 0)) {
-			this.userStats = {
-				data: dataAndContext.data as UserStatsAccount,
-				slot: dataAndContext.context.slot,
-			};
+		try {
+			const dataAndContext =
+				await this.program.account.userStats.fetchAndContext(
+					this.userStatsAccountPublicKey,
+					this.accountLoader.commitment
+				);
+			if (dataAndContext.context.slot > (this.userStats?.slot ?? 0)) {
+				this.userStats = {
+					data: dataAndContext.data as UserStatsAccount,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingUserStatsAccountSubscriber.fetch() UserStatsAccount does not exist: ${e.message}`
+			);
 		}
 	}
 

package/src/accounts/webSocketAccountSubscriber.ts

@@ -134,7 +134,7 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 			return;
 		}
 
-		if (newSlot <= this.bufferAndSlot.slot) {
+		if (newSlot < this.bufferAndSlot.slot) {
 			return;
 		}
 

package/src/accounts/webSocketDriftClientAccountSubscriber.ts

@@ -14,7 +14,7 @@ import {
 	getPerpMarketPublicKey,
 } from '../addresses/pda';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-import { PublicKey } from '@solana/web3.js';
+import { Commitment, PublicKey } from '@solana/web3.js';
 import { OracleInfo, OraclePriceData } from '../oracles/types';
 import { OracleClientCache } from '../oracles/oracleClientCache';
 import * as Buffer from 'buffer';
@@ -26,6 +26,7 @@ export class WebSocketDriftClientAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
+	commitment?: Commitment;
 	perpMarketIndexes: number[];
 	spotMarketIndexes: number[];
 	oracleInfos: OracleInfo[];
@@ -56,7 +57,8 @@ export class WebSocketDriftClientAccountSubscriber
 		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[],
 		shouldFindAllMarketsAndOracles: boolean,
-		resubTimeoutMs?: number
+		resubTimeoutMs?: number,
+		commitment?: Commitment
 	) {
 		this.isSubscribed = false;
 		this.program = program;
@@ -66,6 +68,7 @@ export class WebSocketDriftClientAccountSubscriber
 		this.oracleInfos = oracleInfos;
 		this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
 		this.resubTimeoutMs = resubTimeoutMs;
+		this.commitment = commitment;
 	}
 
 	public async subscribe(): Promise<boolean> {
@@ -101,7 +104,8 @@ export class WebSocketDriftClientAccountSubscriber
 			this.program,
 			statePublicKey,
 			undefined,
-			this.resubTimeoutMs
+			this.resubTimeoutMs,
+			this.commitment
 		);
 		await this.stateAccountSubscriber.subscribe((data: StateAccount) => {
 			this.eventEmitter.emit('stateAccountUpdate', data);
@@ -143,7 +147,8 @@ export class WebSocketDriftClientAccountSubscriber
 			this.program,
 			perpMarketPublicKey,
 			undefined,
-			this.resubTimeoutMs
+			this.resubTimeoutMs,
+			this.commitment
 		);
 		await accountSubscriber.subscribe((data: PerpMarketAccount) => {
 			this.eventEmitter.emit('perpMarketAccountUpdate', data);
@@ -170,7 +175,8 @@ export class WebSocketDriftClientAccountSubscriber
 			this.program,
 			marketPublicKey,
 			undefined,
-			this.resubTimeoutMs
+			this.resubTimeoutMs,
+			this.commitment
 		);
 		await accountSubscriber.subscribe((data: SpotMarketAccount) => {
 			this.eventEmitter.emit('spotMarketAccountUpdate', data);
@@ -202,7 +208,8 @@ export class WebSocketDriftClientAccountSubscriber
 			(buffer: Buffer) => {
 				return client.getOraclePriceDataFromBuffer(buffer);
 			},
-			this.resubTimeoutMs
+			this.resubTimeoutMs,
+			this.commitment
 		);
 
 		await accountSubscriber.subscribe((data: OraclePriceData) => {

package/src/accounts/webSocketProgramAccountSubscriber.ts

@@ -125,7 +125,7 @@ export class WebSocketProgramAccountSubscriber<T>
 			return;
 		}
 
-		if (newSlot <= this.bufferAndSlot.slot) {
+		if (newSlot < this.bufferAndSlot.slot) {
 			return;
 		}
 

package/src/accounts/webSocketUserAccountSubscriber.ts

@@ -94,7 +94,7 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 	public updateData(userAccount: UserAccount, slot: number) {
 		const currentDataSlot =
 			this.userDataAccountSubscriber.dataAndSlot?.slot || 0;
-		if (currentDataSlot < slot) {
+		if (currentDataSlot <= slot) {
 			this.userDataAccountSubscriber.setData(userAccount, slot);
 			this.eventEmitter.emit('userAccountUpdate', userAccount);
 			this.eventEmitter.emit('update');

package/src/constants/spotMarkets.ts

@@ -150,6 +150,16 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 			'2sTMN9A1D1qeZLF95XQgJCUPiKe5DiV52jLfZGqMP46m'
 		),
 	},
+	{
+		symbol: 'bSOL',
+		marketIndex: 8,
+		oracle: new PublicKey('AFrYBhb5wKQtxRS9UA9YRS4V3dwFm7SqmS6DHKq6YVgo'),
+		oracleSource: OracleSource.PYTH,
+		mint: new PublicKey('bSo13r4TkiE4KumL71LsHTPpL2euBYLFx6h9HP3piy1'),
+		precision: new BN(10).pow(NINE),
+		precisionExp: NINE,
+		serumMarket: new PublicKey('ARjaHVxGCQfTvvKjLd7U7srvk6orthZSE6uqWchCczZc'),
+	},
 ];
 
 export const SpotMarkets: { [key in DriftEnv]: SpotMarketConfig[] } = {

package/src/dlob/orderBookLevels.ts

@@ -173,7 +173,7 @@ export function getVammL2Generator({
 		updatedAmm.orderStepSize
 	);
 
-	const minOrderSize = marketAccount.amm.orderStepSize;
+	const minOrderSize = marketAccount.amm.minOrderSize;
 	if (openBids.lt(minOrderSize.muln(2))) {
 		openBids = ZERO;
 	}

package/src/driftClient.ts

@@ -283,7 +283,8 @@ export class DriftClient {
 				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? [],
 				noMarketsAndOraclesSpecified,
-				config.accountSubscription?.resubTimeoutMs
+				config.accountSubscription?.resubTimeoutMs,
+				config.accountSubscription?.commitment
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;

package/src/events/eventSubscriber.ts

@@ -8,6 +8,7 @@ import {
 	EventMap,
 	LogProvider,
 	EventSubscriberEvents,
+	WebSocketLogProviderConfig,
 } from './types';
 import { TxEventCache } from './txEventCache';
 import { EventList } from './eventList';
@@ -56,7 +57,8 @@ export class EventSubscriber {
 			this.logProvider = new WebSocketLogProvider(
 				this.connection,
 				this.address,
-				this.options.commitment
+				this.options.commitment,
+				this.options.logProviderConfig.resubTimeoutMs
 			);
 		} else {
 			this.logProvider = new PollingLogProvider(
@@ -75,6 +77,48 @@ export class EventSubscriber {
 				return true;
 			}
 
+			if (this.options.logProviderConfig.type === 'websocket') {
+				if (this.options.logProviderConfig.resubTimeoutMs) {
+					if (
+						this.options.logProviderConfig.maxReconnectAttempts &&
+						this.options.logProviderConfig.maxReconnectAttempts > 0
+					) {
+						const logProviderConfig = this.options
+							.logProviderConfig as WebSocketLogProviderConfig;
+						this.logProvider.eventEmitter.on(
+							'reconnect',
+							(reconnectAttempts) => {
+								if (
+									reconnectAttempts > logProviderConfig.maxReconnectAttempts
+								) {
+									console.log('Failing over to polling');
+									this.logProvider.eventEmitter.removeAllListeners('reconnect');
+									this.unsubscribe().then(() => {
+										this.logProvider = new PollingLogProvider(
+											this.connection,
+											this.address,
+											this.options.commitment,
+											logProviderConfig.fallbackFrequency,
+											logProviderConfig.fallbackBatchSize
+										);
+										this.logProvider.subscribe(
+											(txSig, slot, logs, mostRecentBlockTime) => {
+												this.handleTxLogs(
+													txSig,
+													slot,
+													logs,
+													mostRecentBlockTime
+												);
+											},
+											true
+										);
+									});
+								}
+							}
+						);
+					}
+				}
+			}
 			this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
 				this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
 			}, true);
@@ -158,7 +202,7 @@ export class EventSubscriber {
 	}
 
 	public async unsubscribe(): Promise<boolean> {
-		return await this.logProvider.unsubscribe();
+		return await this.logProvider.unsubscribe(true);
 	}
 
 	private parseEventsFromLogs(

package/src/events/pollingLogProvider.ts

@@ -25,10 +25,10 @@ export class PollingLogProvider implements LogProvider {
 		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
 	}
 
-	public subscribe(
+	public async subscribe(
 		callback: logProviderCallback,
 		skipHistory?: boolean
-	): boolean {
+	): Promise<boolean> {
 		if (this.intervalId) {
 			return true;
 		}

package/src/events/types.ts

@@ -15,6 +15,7 @@ import {
 	CurveRecord,
 	SwapRecord,
 } from '../index';
+import { EventEmitter } from 'events';
 
 export type EventSubscriptionOptions = {
 	address?: PublicKey;
@@ -126,12 +127,20 @@ export type logProviderCallback = (
 
 export interface LogProvider {
 	isSubscribed(): boolean;
-	subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
-	unsubscribe(): Promise<boolean>;
+	subscribe(
+		callback: logProviderCallback,
+		skipHistory?: boolean
+	): Promise<boolean>;
+	unsubscribe(external?: boolean): Promise<boolean>;
+	eventEmitter?: EventEmitter;
 }
 
 export type WebSocketLogProviderConfig = {
 	type: 'websocket';
+	resubTimeoutMs?: number;
+	maxReconnectAttempts?: number;
+	fallbackFrequency?: number;
+	fallbackBatchSize?: number;
 };
 
 export type PollingLogProviderConfig = {

package/src/events/webSocketLogProvider.ts

@@ -1,38 +1,112 @@
 import { LogProvider, logProviderCallback } from './types';
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import { EventEmitter } from 'events';
 
 export class WebSocketLogProvider implements LogProvider {
 	private subscriptionId: number;
+	private isUnsubscribing = false;
+	private externalUnsubscribe = false;
+	private receivingData = false;
+	private timeoutId?: NodeJS.Timeout;
+	private reconnectAttempts = 0;
+	eventEmitter?: EventEmitter;
+	private callback?: logProviderCallback;
 	public constructor(
 		private connection: Connection,
 		private address: PublicKey,
-		private commitment: Commitment
-	) {}
+		private commitment: Commitment,
+		private resubTimeoutMs?: number
+	) {
+		if (this.resubTimeoutMs) {
+			this.eventEmitter = new EventEmitter();
+		}
+	}
 
-	public subscribe(callback: logProviderCallback): boolean {
+	public async subscribe(callback: logProviderCallback): Promise<boolean> {
 		if (this.subscriptionId) {
 			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;
+	}
+
+	public setSubscription(callback: logProviderCallback): void {
 		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;
+				}
 				callback(logs.signature, ctx.slot, logs.logs, undefined);
 			},
 			this.commitment
 		);
-		return true;
 	}
 
 	public isSubscribed(): boolean {
 		return this.subscriptionId !== undefined;
 	}
 
-	public async unsubscribe(): Promise<boolean> {
+	public async unsubscribe(external = false): Promise<boolean> {
+		this.isUnsubscribing = true;
+		this.externalUnsubscribe = external;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
 		if (this.subscriptionId !== undefined) {
-			await this.connection.removeOnLogsListener(this.subscriptionId);
-			this.subscriptionId = undefined;
+			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;
 		}
-		return true;
+	}
+
+	private setTimeout(): void {
+		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(
+					`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);
 	}
 }

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.47.0",
+  "version": "2.48.0",
   "name": "drift",
   "instructions": [
     {

package/src/orderSubscriber/OrderSubscriber.ts

@@ -1,7 +1,7 @@
 import { DriftClient } from '../driftClient';
 import { UserAccount } from '../types';
 import { getUserFilter, getUserWithOrderFilter } from '../memcmp';
-import { PublicKey, RpcResponseAndContext } from '@solana/web3.js';
+import { Commitment, PublicKey, RpcResponseAndContext } from '@solana/web3.js';
 import { Buffer } from 'buffer';
 import { DLOB } from '../dlob/DLOB';
 import { OrderSubscriberConfig, OrderSubscriberEvents } from './types';
@@ -9,18 +9,23 @@ import { PollingSubscription } from './PollingSubscription';
 import { WebsocketSubscription } from './WebsocketSubscription';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
+import { BN } from '../index';
 
 export class OrderSubscriber {
 	driftClient: DriftClient;
 	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
 	subscription: PollingSubscription | WebsocketSubscription;
+	commitment: Commitment;
 	eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
 
 	fetchPromise?: Promise<void>;
 	fetchPromiseResolver: () => void;
 
+	mostRecentSlot: number;
+
 	constructor(config: OrderSubscriberConfig) {
 		this.driftClient = config.driftClient;
+		this.commitment = config.subscriptionConfig.commitment || 'processed';
 		if (config.subscriptionConfig.type === 'polling') {
 			this.subscription = new PollingSubscription({
 				orderSubscriber: this,
@@ -29,6 +34,7 @@ export class OrderSubscriber {
 		} else {
 			this.subscription = new WebsocketSubscription({
 				orderSubscriber: this,
+				commitment: this.commitment,
 				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
 				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
 			});
@@ -53,7 +59,7 @@ export class OrderSubscriber {
 			const rpcRequestArgs = [
 				this.driftClient.program.programId.toBase58(),
 				{
-					commitment: this.driftClient.opts.commitment,
+					commitment: this.commitment,
 					filters: [getUserFilter(), getUserWithOrderFilter()],
 					encoding: 'base64',
 					withContext: true,
@@ -81,18 +87,13 @@ export class OrderSubscriber {
 			const programAccountSet = new Set<string>();
 			for (const programAccount of rpcResponseAndContext.value) {
 				const key = programAccount.pubkey.toString();
-				// @ts-ignore
-				const buffer = Buffer.from(
-					programAccount.account.data[0],
-					programAccount.account.data[1]
-				);
 				programAccountSet.add(key);
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						buffer
-					) as UserAccount;
-				this.tryUpdateUserAccount(key, userAccount, slot);
+				this.tryUpdateUserAccount(
+					key,
+					'raw',
+					programAccount.account.data,
+					slot
+				);
 			}
 
 			for (const key of this.usersAccounts.keys()) {
@@ -110,11 +111,43 @@ export class OrderSubscriber {
 
 	tryUpdateUserAccount(
 		key: string,
-		userAccount: UserAccount,
+		dataType: 'raw' | 'decoded',
+		data: string[] | UserAccount,
 		slot: number
 	): void {
+		if (!this.mostRecentSlot || slot > this.mostRecentSlot) {
+			this.mostRecentSlot = slot;
+		}
+
 		const slotAndUserAccount = this.usersAccounts.get(key);
-		if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
+		if (!slotAndUserAccount || slotAndUserAccount.slot <= slot) {
+			let userAccount: UserAccount;
+			// Polling leads to a lot of redundant decoding, so we only decode if data is from a fresh slot
+			if (dataType === 'raw') {
+				// @ts-ignore
+				const buffer = Buffer.from(data[0], data[1]);
+
+				const newLastActiveSlot = new BN(
+					buffer.subarray(4328, 4328 + 8),
+					undefined,
+					'le'
+				);
+				if (
+					slotAndUserAccount &&
+					slotAndUserAccount.userAccount.lastActiveSlot.gt(newLastActiveSlot)
+				) {
+					return;
+				}
+
+				userAccount =
+					this.driftClient.program.account.user.coder.accounts.decodeUnchecked(
+						'User',
+						buffer
+					) as UserAccount;
+			} else {
+				userAccount = data as UserAccount;
+			}
+
 			const newOrders = userAccount.orders.filter(
 				(order) =>
 					order.slot.toNumber() > (slotAndUserAccount?.slot ?? 0) &&
@@ -148,6 +181,10 @@ export class OrderSubscriber {
 		return dlob;
 	}
 
+	public getSlot(): number {
+		return this.mostRecentSlot ?? 0;
+	}
+
 	public async unsubscribe(): Promise<void> {
 		await this.subscription.unsubscribe();
 	}