@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.2

package/lib/oracles/oracleClientCache.d.ts

@@ -0,0 +1,8 @@
+import { OracleClient } from './types';
+import { OracleSource } from '../types';
+import { Connection } from '@solana/web3.js';
+export declare class OracleClientCache {
+    cache: Map<string, OracleClient>;
+    constructor();
+    get(oracleSource: OracleSource, connection: Connection): OracleClient;
+}

package/lib/oracles/oracleClientCache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleClientCache = void 0;
+const oracleClient_1 = require("../factory/oracleClient");
+class OracleClientCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(oracleSource, connection) {
+        const key = Object.keys(oracleSource)[0];
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const client = (0, oracleClient_1.getOracleClient)(oracleSource, connection);
+        this.cache.set(key, client);
+        return client;
+    }
+}
+exports.OracleClientCache = OracleClientCache;

package/lib/oracles/pythClient.d.ts

@@ -1,14 +1,12 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
-import { PriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
-import { OraclePriceData } from './types';
+import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
-export declare class PythClient {
+export declare class PythClient implements OracleClient {
     private connection;
     constructor(connection: Connection);
-    getPriceData(pricePublicKey: PublicKey): Promise<PriceData>;
     getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
-    getOraclePriceDataFromBuffer(buffer: Buffer): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
 }
 export declare function convertPythPrice(price: number, exponent: number): BN;

package/lib/oracles/pythClient.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertPythPrice = exports.PythClient = void 0;
 const client_1 = require("@pythnetwork/client");
@@ -17,30 +8,20 @@ class PythClient {
     constructor(connection) {
         this.connection = connection;
     }
-    getPriceData(pricePublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const account = yield this.connection.getAccountInfo(pricePublicKey);
-            return (0, client_1.parsePriceData)(account.data);
-        });
-    }
-    getOraclePriceData(pricePublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accountInfo = yield this.connection.getAccountInfo(pricePublicKey);
-            return this.getOraclePriceDataFromBuffer(accountInfo.data);
-        });
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
     }
     getOraclePriceDataFromBuffer(buffer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const priceData = (0, client_1.parsePriceData)(buffer);
-            return {
-                price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
-                slot: new anchor_1.BN(priceData.lastSlot.toString()),
-                confidence: convertPythPrice(priceData.confidence, priceData.exponent),
-                twap: convertPythPrice(priceData.twap.value, priceData.exponent),
-                twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent),
-                hasSufficientNumberOfDataPoints: true,
-            };
-        });
+        const priceData = (0, client_1.parsePriceData)(buffer);
+        return {
+            price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
+            slot: new anchor_1.BN(priceData.lastSlot.toString()),
+            confidence: convertPythPrice(priceData.confidence, priceData.exponent),
+            twap: convertPythPrice(priceData.twap.value, priceData.exponent),
+            twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent),
+            hasSufficientNumberOfDataPoints: true,
+        };
     }
 }
 exports.PythClient = PythClient;

package/lib/oracles/quoteAssetOracleClient.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+export declare const QUOTE_ORACLE_PRICE_DATA: OraclePriceData;
+export declare class QuoteAssetOracleClient implements OracleClient {
+    constructor();
+    getOraclePriceData(_pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(_buffer: Buffer): OraclePriceData;
+}

package/lib/oracles/quoteAssetOracleClient.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteAssetOracleClient = exports.QUOTE_ORACLE_PRICE_DATA = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+exports.QUOTE_ORACLE_PRICE_DATA = {
+    price: numericConstants_1.MARK_PRICE_PRECISION,
+    slot: new anchor_1.BN(0),
+    confidence: new anchor_1.BN(1),
+    hasSufficientNumberOfDataPoints: true,
+};
+class QuoteAssetOracleClient {
+    constructor() { }
+    async getOraclePriceData(_pricePublicKey) {
+        return Promise.resolve(exports.QUOTE_ORACLE_PRICE_DATA);
+    }
+    getOraclePriceDataFromBuffer(_buffer) {
+        return exports.QUOTE_ORACLE_PRICE_DATA;
+    }
+}
+exports.QuoteAssetOracleClient = QuoteAssetOracleClient;

package/lib/oracles/switchboardClient.d.ts

@@ -1,13 +1,11 @@
 /// <reference types="node" />
 import { Connection, PublicKey } from '@solana/web3.js';
-import { DriftEnv } from '../config';
 import { Program } from '@project-serum/anchor';
 import { OracleClient, OraclePriceData } from './types';
 export declare class SwitchboardClient implements OracleClient {
     connection: Connection;
-    env: DriftEnv;
-    constructor(connection: Connection, env: DriftEnv);
+    constructor(connection: Connection);
     getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
-    getOraclePriceDataFromBuffer(buffer: Buffer): Promise<OraclePriceData>;
-    getProgram(): Promise<Program>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+    getProgram(): Program;
 }

package/lib/oracles/switchboardClient.js

@@ -1,75 +1,54 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwitchboardClient = void 0;
-const switchboard_v2_1 = require("@switchboard-xyz/switchboard-v2");
 const web3_js_1 = require("@solana/web3.js");
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const wallet_1 = require("../wallet");
 const switchboard_v2_json_1 = __importDefault(require("../idl/switchboard_v2.json"));
-// cache switchboard program for every client object since itll always be the same
-const programMap = new Map();
+let program;
 class SwitchboardClient {
-    constructor(connection, env) {
+    constructor(connection) {
         this.connection = connection;
-        this.env = env;
     }
-    getOraclePriceData(pricePublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accountInfo = yield this.connection.getAccountInfo(pricePublicKey);
-            return this.getOraclePriceDataFromBuffer(accountInfo.data);
-        });
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
     }
     getOraclePriceDataFromBuffer(buffer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const program = yield this.getProgram();
-            const aggregatorAccountData = program.account.aggregatorAccountData.coder.accounts.decode('AggregatorAccountData', buffer);
-            const price = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound.result);
-            const confidence = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound
-                .stdDeviation);
-            const hasSufficientNumberOfDataPoints = aggregatorAccountData.latestConfirmedRound.numSuccess >=
-                aggregatorAccountData.minOracleResults;
-            const slot = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
-            return {
-                price,
-                slot,
-                confidence,
-                hasSufficientNumberOfDataPoints,
-            };
-        });
+        const program = this.getProgram();
+        const aggregatorAccountData = program.account.aggregatorAccountData.coder.accounts.decode('AggregatorAccountData', buffer);
+        const price = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound.result);
+        const confidence = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound
+            .stdDeviation);
+        const hasSufficientNumberOfDataPoints = aggregatorAccountData.latestConfirmedRound.numSuccess >=
+            aggregatorAccountData.minOracleResults;
+        const slot = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
+        return {
+            price,
+            slot,
+            confidence,
+            hasSufficientNumberOfDataPoints,
+        };
     }
     getProgram() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (programMap.has(this.env)) {
-                return programMap.get(this.env);
-            }
-            const program = yield getSwitchboardProgram(this.env, this.connection);
-            programMap.set(this.env, program);
+        if (program) {
             return program;
-        });
+        }
+        program = getSwitchboardProgram(this.connection);
+        return program;
     }
 }
 exports.SwitchboardClient = SwitchboardClient;
-function getSwitchboardProgram(env, connection) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const DEFAULT_KEYPAIR = web3_js_1.Keypair.fromSeed(new Uint8Array(32).fill(1));
-        const programId = (0, switchboard_v2_1.getSwitchboardPid)(env);
-        const wallet = new wallet_1.Wallet(DEFAULT_KEYPAIR);
-        const provider = new anchor_1.AnchorProvider(connection, wallet, {});
-        return new anchor_1.Program(switchboard_v2_json_1.default, programId, provider);
-    });
+function getSwitchboardProgram(connection) {
+    const DEFAULT_KEYPAIR = web3_js_1.Keypair.fromSeed(new Uint8Array(32).fill(1));
+    const programId = web3_js_1.PublicKey.default;
+    const wallet = new wallet_1.Wallet(DEFAULT_KEYPAIR);
+    const provider = new anchor_1.AnchorProvider(connection, wallet, {});
+    return new anchor_1.Program(switchboard_v2_json_1.default, programId, provider);
 }
 function convertSwitchboardDecimal(switchboardDecimal) {
     const switchboardPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(switchboardDecimal.scale));

package/lib/oracles/types.d.ts

@@ -2,6 +2,7 @@
 /// <reference types="node" />
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
+import { OracleSource } from '../types';
 export declare type OraclePriceData = {
     price: BN;
     slot: BN;
@@ -10,7 +11,11 @@ export declare type OraclePriceData = {
     twap?: BN;
     twapConfidence?: BN;
 };
+export declare type OracleInfo = {
+    publicKey: PublicKey;
+    source: OracleSource;
+};
 export interface OracleClient {
-    getOraclePriceDataFromBuffer(buffer: Buffer): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
     getOraclePriceData(publicKey: PublicKey): Promise<OraclePriceData>;
 }

package/lib/orders.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="bn.js" />
-import { Market, Order, UserAccount, UserPosition } from './types';
-import { BN, ClearingHouseUser } from '.';
+import { MarketAccount, Order, UserAccount, UserPosition } from './types';
+import { BN } from '.';
 import { OraclePriceData } from '.';
-export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: Market, order: Order): [UserAccount, UserPosition, Market] | null;
-export declare function calculateBaseAssetAmountMarketCanExecute(market: Market, order: Order, oraclePriceData?: OraclePriceData): BN;
-export declare function calculateAmountToTradeForLimit(market: Market, order: Order, oraclePriceData?: OraclePriceData): BN;
-export declare function calculateAmountToTradeForTriggerLimit(market: Market, order: Order): BN;
-export declare function calculateBaseAssetAmountUserCanExecute(market: Market, order: Order, user: ClearingHouseUser): BN;
+export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: MarketAccount, order: Order): [UserAccount, UserPosition, MarketAccount] | null;
+export declare function calculateBaseAssetAmountMarketCanExecute(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
+export declare function calculateAmountToTradeForLimit(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
+export declare function calculateAmountToTradeForTriggerLimit(market: MarketAccount, order: Order): BN;

package/lib/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBaseAssetAmountUserCanExecute = exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
 const types_1 = require("./types");
 const _1 = require(".");
 const market_1 = require("./math/market");
@@ -12,7 +12,7 @@ function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
         return null;
     }
     const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
-    if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
+    if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
         return null;
     }
     const userAccountAfter = Object.assign({}, userAccount);
@@ -88,7 +88,6 @@ function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData
         return calculateAmountToTradeForTriggerLimit(market, order);
     }
     else if ((0, types_1.isVariant)(order.orderType, 'market')) {
-        // should never be a market order queued
         return numericConstants_1.ZERO;
     }
     else {
@@ -112,23 +111,21 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
             limitPrice = floatingPrice;
         }
     }
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, !order.postOnly);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction);
+    const baseAssetAmount = (0, _1.standardizeBaseAssetAmount)(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
     if (!sameDirection) {
         return numericConstants_1.ZERO;
     }
-    return maxAmountToTrade.gt(order.baseAssetAmount)
+    return baseAssetAmount.gt(order.baseAssetAmount)
         ? order.baseAssetAmount
-        : maxAmountToTrade;
+        : baseAssetAmount;
 }
 exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
 function calculateAmountToTradeForTriggerLimit(market, order) {
-    if (order.baseAssetAmountFilled.eq(numericConstants_1.ZERO)) {
-        const baseAssetAmount = calculateAmountToTradeForTriggerMarket(market, order);
-        if (baseAssetAmount.eq(numericConstants_1.ZERO)) {
-            return numericConstants_1.ZERO;
-        }
+    if (!order.triggered) {
+        return numericConstants_1.ZERO;
     }
     return calculateAmountToTradeForLimit(market, order);
 }
@@ -138,75 +135,8 @@ function isSameDirection(firstDirection, secondDirection) {
         ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
 function calculateAmountToTradeForTriggerMarket(market, order) {
-    return isTriggerConditionSatisfied(market, order)
-        ? order.baseAssetAmount
-        : numericConstants_1.ZERO;
-}
-function isTriggerConditionSatisfied(market, order) {
-    const markPrice = (0, market_1.calculateMarkPrice)(market);
-    if ((0, types_1.isVariant)(order.triggerCondition, 'above')) {
-        return markPrice.gt(order.triggerPrice);
-    }
-    else {
-        return markPrice.lt(order.triggerPrice);
-    }
-}
-function calculateBaseAssetAmountUserCanExecute(market, order, user) {
-    const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-    const freeCollateral = user.getFreeCollateral();
-    let quoteAssetAmount;
-    if ((0, _1.isOrderRiskIncreasingInSameDirection)(user, order)) {
-        quoteAssetAmount = freeCollateral.mul(maxLeverage).div(_1.TEN_THOUSAND);
-    }
-    else {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        const positionValue = (0, _1.calculateBaseAssetValue)(market, position);
-        quoteAssetAmount = freeCollateral
-            .mul(maxLeverage)
-            .div(_1.TEN_THOUSAND)
-            .add(positionValue.mul(numericConstants_1.TWO));
-    }
-    if (quoteAssetAmount.lte(numericConstants_1.ZERO)) {
+    if (!order.triggered) {
         return numericConstants_1.ZERO;
     }
-    const swapDirection = (0, types_1.isVariant)(order.direction, 'long')
-        ? types_1.SwapDirection.ADD
-        : types_1.SwapDirection.REMOVE;
-    const useSpread = !order.postOnly;
-    let amm;
-    if (useSpread) {
-        const { baseAssetReserve, quoteAssetReserve } = (0, _1.calculateSpreadReserves)(market.amm, order.direction);
-        amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: market.amm.sqrtK,
-            pegMultiplier: market.amm.pegMultiplier,
-        };
-    }
-    else {
-        amm = market.amm;
-    }
-    const baseAssetReservesBefore = amm.baseAssetReserve;
-    const [_, baseAssetReservesAfter] = (0, _1.calculateAmmReservesAfterSwap)(amm, 'quote', quoteAssetAmount, swapDirection);
-    let baseAssetAmount = baseAssetReservesBefore
-        .sub(baseAssetReservesAfter)
-        .abs();
-    if (order.reduceOnly) {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        if ((0, types_1.isVariant)(order.direction, 'long') &&
-            position.baseAssetAmount.gte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else if ((0, types_1.isVariant)(order.direction, 'short') &&
-            position.baseAssetAmount.lte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else {
-            _1.BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-        }
-    }
-    return baseAssetAmount;
+    return order.baseAssetAmount;
 }
-exports.calculateBaseAssetAmountUserCanExecute = calculateBaseAssetAmountUserCanExecute;

package/lib/slot/SlotSubscriber.d.ts

@@ -0,0 +1,12 @@
+import { Connection } from '@solana/web3.js';
+declare type SlotSubscriberConfig = {};
+export declare class SlotSubscriber {
+    private connection;
+    currentSlot: number;
+    subscriptionId: number;
+    constructor(connection: Connection, _config?: SlotSubscriberConfig);
+    subscribe(): Promise<void>;
+    getSlot(): number;
+    unsubscribe(): Promise<void>;
+}
+export {};

package/lib/slot/SlotSubscriber.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotSubscriber = void 0;
+class SlotSubscriber {
+    constructor(connection, _config) {
+        this.connection = connection;
+    }
+    async subscribe() {
+        this.currentSlot = await this.connection.getSlot('confirmed');
+        this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+            this.currentSlot = slotInfo.slot;
+        });
+    }
+    getSlot() {
+        return this.currentSlot;
+    }
+    async unsubscribe() {
+        if (this.subscriptionId) {
+            await this.connection.removeSlotChangeListener(this.subscriptionId);
+        }
+    }
+}
+exports.SlotSubscriber = SlotSubscriber;

package/lib/tx/retryTxSender.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { TxSender } from './types';
+import { TxSender, TxSigAndSlot } from './types';
 import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection } from '@solana/web3.js';
 import { AnchorProvider } from '@project-serum/anchor';
 declare type ResolveReference = {
@@ -11,7 +11,7 @@ export declare class RetryTxSender implements TxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     constructor(provider: AnchorProvider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
     getTimestamp(): number;