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

package/lib/types.d.ts

@@ -9,6 +9,14 @@ export declare class SwapDirection {
         remove: {};
     };
 }
+export declare class BankBalanceType {
+    static readonly DEPOSIT: {
+        deposit: {};
+    };
+    static readonly BORROW: {
+        borrow: {};
+    };
+}
 export declare class PositionDirection {
     static readonly LONG: {
         long: {};
@@ -17,6 +25,14 @@ export declare class PositionDirection {
         short: {};
     };
 }
+export declare class DepositDirection {
+    static readonly DEPOSIT: {
+        deposit: {};
+    };
+    static readonly WITHDRAW: {
+        withdraw: {};
+    };
+}
 export declare class OracleSource {
     static readonly PYTH: {
         pyth: {};
@@ -24,6 +40,9 @@ export declare class OracleSource {
     static readonly SWITCHBOARD: {
         switchboard: {};
     };
+    static readonly QUOTE_ASSET: {
+        quoteAsset: {};
+    };
 }
 export declare class OrderType {
     static readonly LIMIT: {
@@ -77,6 +96,23 @@ export declare class OrderAction {
     static readonly FILL: {
         fill: {};
     };
+    static readonly TRIGGER: {
+        trigger: {};
+    };
+}
+export declare class OrderActionExplanation {
+    static readonly NONE: {
+        none: {};
+    };
+    static readonly BREACHED_MARGIN_REQUIREMENT: {
+        breachedMarginRequirement: {};
+    };
+    static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE: {
+        oraclePriceBreachedLimitPrice: {};
+    };
+    static readonly MARKET_ORDER_FILLED_TO_LIMIT_PRICE: {
+        marketOrderFilledToLimitPrice: {};
+    };
 }
 export declare class OrderTriggerCondition {
     static readonly ABOVE: {
@@ -87,55 +123,28 @@ export declare class OrderTriggerCondition {
     };
 }
 export declare function isVariant(object: unknown, type: string): boolean;
+export declare function isOneOfVariant(object: unknown, types: string[]): boolean;
 export declare enum TradeSide {
     None = 0,
     Buy = 1,
     Sell = 2
 }
 export declare type CandleResolution = '1' | '5' | '15' | '60' | '240' | 'D' | 'W' | 'M';
-export declare type TradeHistoryAccount = {
-    head: BN;
-    tradeRecords: TradeRecord[];
-};
-export declare type DepositHistoryAccount = {
-    head: BN;
-    depositRecords: DepositRecord[];
-};
-export declare type ExtendedCurveHistoryAccount = {
-    head: BN;
-    curveRecords: ExtendedCurveRecord[];
-};
-export declare type FundingRateHistoryAccount = {
-    head: BN;
-    fundingRateRecords: FundingRateRecord[];
-};
-export declare type FundingPaymentHistoryAccount = {
-    head: BN;
-    fundingPaymentRecords: FundingPaymentRecord[];
-};
-export declare type LiquidationHistoryAccount = {
-    head: BN;
-    liquidationRecords: LiquidationRecord[];
-};
-export declare type OrderHistoryAccount = {
-    head: BN;
-    lastOrderId: BN;
-    orderRecords: OrderRecord[];
-};
 export declare type DepositRecord = {
     ts: BN;
-    recordId: BN;
     userAuthority: PublicKey;
     user: PublicKey;
     direction: {
         deposit?: any;
         withdraw?: any;
     };
-    collateralBefore: BN;
-    cumulativeDepositsBefore: BN;
+    bankIndex: BN;
     amount: BN;
+    oraclePrice: BN;
+    from?: PublicKey;
+    to?: PublicKey;
 };
-export declare type ExtendedCurveRecord = {
+export declare type CurveRecord = {
     ts: BN;
     recordId: BN;
     marketIndex: BN;
@@ -154,27 +163,6 @@ export declare type ExtendedCurveRecord = {
     oraclePrice: BN;
     tradeId: BN;
 };
-export declare type TradeRecord = {
-    ts: BN;
-    recordId: BN;
-    userAuthority: PublicKey;
-    user: PublicKey;
-    direction: {
-        long?: any;
-        short?: any;
-    };
-    baseAssetAmount: BN;
-    quoteAssetAmount: BN;
-    markPriceBefore: BN;
-    markPriceAfter: BN;
-    fee: BN;
-    quoteAssetAmountSurplus: BN;
-    refereeDiscount: BN;
-    tokenDiscount: BN;
-    marketIndex: BN;
-    liquidation: boolean;
-    oraclePrice: BN;
-};
 export declare type FundingRateRecord = {
     ts: BN;
     recordId: BN;
@@ -187,7 +175,6 @@ export declare type FundingRateRecord = {
 };
 export declare type FundingPaymentRecord = {
     ts: BN;
-    recordId: BN;
     userAuthority: PublicKey;
     user: PublicKey;
     marketIndex: BN;
@@ -217,41 +204,36 @@ export declare type LiquidationRecord = {
 };
 export declare type OrderRecord = {
     ts: BN;
-    recordId: BN;
-    order: Order;
-    user: PublicKey;
-    authority: PublicKey;
+    taker: PublicKey;
+    maker: PublicKey;
+    takerOrder: Order;
+    makerOrder: Order;
+    takerUnsettledPnl: BN;
+    makerUnsettledPnl: BN;
     action: OrderAction;
+    actionExplanation: OrderActionExplanation;
     filler: PublicKey;
+    fillRecordId: BN;
+    marketIndex: BN;
     baseAssetAmountFilled: BN;
     quoteAssetAmountFilled: BN;
-    fee: BN;
+    makerRebate: BN;
+    takerFee: BN;
     fillerReward: BN;
-    tradeRecordId: BN;
     quoteAssetAmountSurplus: BN;
+    oraclePrice: BN;
 };
 export declare type StateAccount = {
     admin: PublicKey;
     fundingPaused: boolean;
     exchangePaused: boolean;
     adminControlsPrices: boolean;
-    collateralMint: PublicKey;
-    collateralVault: PublicKey;
-    collateralVaultAuthority: PublicKey;
-    collateralVaultNonce: number;
     insuranceVault: PublicKey;
     insuranceVaultAuthority: PublicKey;
     insuranceVaultNonce: number;
     marginRatioInitial: BN;
     marginRatioMaintenance: BN;
     marginRatioPartial: BN;
-    markets: PublicKey;
-    curveHistory: PublicKey;
-    depositHistory: PublicKey;
-    fundingRateHistory: PublicKey;
-    fundingPaymentHistory: PublicKey;
-    tradeHistory: PublicKey;
-    liquidationHistory: PublicKey;
     partialLiquidationClosePercentageNumerator: BN;
     partialLiquidationClosePercentageDenominator: BN;
     partialLiquidationPenaltyPercentageNumerator: BN;
@@ -267,33 +249,49 @@ export declare type StateAccount = {
     discountMint: PublicKey;
     oracleGuardRails: OracleGuardRails;
     maxDeposit: BN;
-    orderState: PublicKey;
-    extendedCurveHistory: PublicKey;
-};
-export declare type OrderStateAccount = {
-    orderHistory: PublicKey;
-    orderFillerRewardStructure: OrderFillerRewardStructure;
+    numberOfMarkets: BN;
+    numberOfBanks: BN;
     minOrderQuoteAssetAmount: BN;
 };
-export declare type SettlementStateAccount = {
-    totalSettlementValue: BN;
-    collateralAvailableToClaim: BN;
-    collateralClaimed: BN;
-    enabled: boolean;
-};
-export declare type MarketsAccount = {
-    markets: Market[];
-};
-export declare type Market = {
+export declare type MarketAccount = {
+    initialized: boolean;
+    marketIndex: BN;
+    pubkey: PublicKey;
     amm: AMM;
     baseAssetAmount: BN;
     baseAssetAmountLong: BN;
     baseAssetAmountShort: BN;
-    initialized: boolean;
     openInterest: BN;
     marginRatioInitial: number;
     marginRatioMaintenance: number;
     marginRatioPartial: number;
+    nextFillRecordId: BN;
+    pnlPool: PoolBalance;
+};
+export declare type BankAccount = {
+    bankIndex: BN;
+    pubkey: PublicKey;
+    mint: PublicKey;
+    vault: PublicKey;
+    vaultAuthority: PublicKey;
+    vaultAuthorityNonce: number;
+    decimals: number;
+    optimalUtilization: BN;
+    optimalBorrowRate: BN;
+    maxBorrowRate: BN;
+    cumulativeDepositInterest: BN;
+    cumulativeBorrowInterest: BN;
+    depositBalance: BN;
+    borrowBalance: BN;
+    lastUpdated: BN;
+    oracle: PublicKey;
+    initialAssetWeight: BN;
+    maintenanceAssetWeight: BN;
+    initialLiabilityWeight: BN;
+    maintenanceLiabilityWeight: BN;
+};
+export declare type PoolBalance = {
+    balance: BN;
 };
 export declare type AMM = {
     baseAssetReserve: BN;
@@ -305,6 +303,8 @@ export declare type AMM = {
     lastMarkPriceTwapTs: BN;
     lastOraclePriceTwap: BN;
     lastOraclePriceTwapTs: BN;
+    lastOracleMarkSpreadPct: BN;
+    lastOracleConfPct: BN;
     oracle: PublicKey;
     oracleSource: OracleSource;
     fundingPeriod: BN;
@@ -318,50 +318,69 @@ export declare type AMM = {
     totalFeeWithdrawn: BN;
     totalFee: BN;
     minimumQuoteAssetTradeSize: BN;
-    minimumBaseAssetTradeSize: BN;
+    baseAssetAmountStepSize: BN;
+    maxBaseAssetAmountRatio: number;
+    maxSlippageRatio: number;
     lastOraclePrice: BN;
     baseSpread: number;
+    curveUpdateIntensity: number;
+    netBaseAssetAmount: BN;
+    quoteAssetAmountLong: BN;
+    quoteAssetAmountShort: BN;
+    terminalQuoteAssetReserve: BN;
+    feePool: PoolBalance;
+    totalExchangeFee: BN;
+    totalMmFee: BN;
+    netRevenueSinceLastFunding: BN;
+    lastUpdateSlot: BN;
+    lastBidPriceTwap: BN;
+    lastAskPriceTwap: BN;
+    longSpread: BN;
+    shortSpread: BN;
+    maxSpread: number;
 };
 export declare type UserPosition = {
     baseAssetAmount: BN;
     lastCumulativeFundingRate: BN;
     marketIndex: BN;
     quoteAssetAmount: BN;
+    quoteEntryAmount: BN;
     openOrders: BN;
-};
-export declare type UserPositionsAccount = {
-    positions: UserPosition[];
-    user: PublicKey;
+    unsettledPnl: BN;
+    openBids: BN;
+    openAsks: BN;
 };
 export declare type UserAccount = {
     authority: PublicKey;
+    name: number[];
+    userId: number;
+    bankBalances: UserBankBalance[];
     collateral: BN;
     cumulativeDeposits: BN;
-    positions: PublicKey;
-    totalFeePaid: BN;
-    totalFeeRebate: BN;
-    totalTokenDiscount: BN;
-    totalReferralReward: BN;
-    totalRefereeDiscount: BN;
-    settledPositionValue: BN;
-    collateralClaimed: BN;
-    lastCollateralAvailableToClaim: BN;
-    forgoPositionSettlement: number;
-    hasSettledPosition: number;
-};
-export declare type UserOrdersAccount = {
+    fees: {
+        totalFeePaid: BN;
+        totalFeeRebate: BN;
+        totalTokenDiscount: BN;
+        totalReferralReward: BN;
+        totalRefereeDiscount: BN;
+    };
+    positions: UserPosition[];
     orders: Order[];
-    user: PublicKey;
+};
+export declare type UserBankBalance = {
+    bankIndex: BN;
+    balanceType: BankBalanceType;
+    balance: BN;
 };
 export declare type Order = {
     status: OrderStatus;
     orderType: OrderType;
     ts: BN;
+    slot: BN;
     orderId: BN;
     userOrderId: number;
     marketIndex: BN;
     price: BN;
-    userBaseAssetAmount: BN;
     baseAssetAmount: BN;
     baseAssetAmountFilled: BN;
     quoteAssetAmount: BN;
@@ -371,17 +390,21 @@ export declare type Order = {
     reduceOnly: boolean;
     triggerPrice: BN;
     triggerCondition: OrderTriggerCondition;
+    triggered: boolean;
     discountTier: OrderDiscountTier;
+    existingPositionDirection: PositionDirection;
     referrer: PublicKey;
     postOnly: boolean;
     immediateOrCancel: boolean;
     oraclePriceOffset: BN;
+    auctionDuration: number;
+    auctionStartPrice: BN;
+    auctionEndPrice: BN;
 };
 export declare type OrderParams = {
     orderType: OrderType;
     userOrderId: number;
     direction: PositionDirection;
-    quoteAssetAmount: BN;
     baseAssetAmount: BN;
     price: BN;
     marketIndex: BN;
@@ -399,6 +422,50 @@ export declare type OrderParams = {
         referrer: boolean;
     };
 };
+export declare type NecessaryOrderParams = {
+    orderType: OrderType;
+    marketIndex: BN;
+    baseAssetAmount: BN;
+    direction: PositionDirection;
+};
+export declare type OptionalOrderParams = {
+    [Property in keyof OrderParams]?: OrderParams[Property];
+} & NecessaryOrderParams;
+export declare const DefaultOrderParams: {
+    orderType: {
+        market: {};
+    };
+    userOrderId: number;
+    direction: {
+        long: {};
+    };
+    baseAssetAmount: BN;
+    price: BN;
+    marketIndex: BN;
+    reduceOnly: boolean;
+    postOnly: boolean;
+    immediateOrCancel: boolean;
+    triggerPrice: BN;
+    triggerCondition: {
+        above: {};
+    };
+    positionLimit: BN;
+    oraclePriceOffset: BN;
+    padding0: BN;
+    padding1: BN;
+    optionalAccounts: {
+        discountToken: boolean;
+        referrer: boolean;
+    };
+};
+export declare type MakerInfo = {
+    maker: PublicKey;
+    order: Order;
+};
+export declare type TakerInfo = {
+    taker: PublicKey;
+    order: Order;
+};
 export interface IWallet {
     signTransaction(tx: Transaction): Promise<Transaction>;
     signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
@@ -435,6 +502,9 @@ export declare type FeeStructure = {
         refereeDiscountNumerator: BN;
         refereeDiscountDenominator: BN;
     };
+    makerRebateNumerator: BN;
+    makerRebateDenominator: BN;
+    fillerRewardStructure: OrderFillerRewardStructure;
 };
 export declare type OracleGuardRails = {
     priceDivergence: {

package/lib/types.js

@@ -1,22 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradeSide = exports.isVariant = exports.OrderTriggerCondition = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.PositionDirection = exports.SwapDirection = void 0;
+exports.DefaultOrderParams = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+const _1 = require(".");
 // # Utility Types / Enums / Constants
 class SwapDirection {
 }
 exports.SwapDirection = SwapDirection;
 SwapDirection.ADD = { add: {} };
 SwapDirection.REMOVE = { remove: {} };
+class BankBalanceType {
+}
+exports.BankBalanceType = BankBalanceType;
+BankBalanceType.DEPOSIT = { deposit: {} };
+BankBalanceType.BORROW = { borrow: {} };
 class PositionDirection {
 }
 exports.PositionDirection = PositionDirection;
 PositionDirection.LONG = { long: {} };
 PositionDirection.SHORT = { short: {} };
+class DepositDirection {
+}
+exports.DepositDirection = DepositDirection;
+DepositDirection.DEPOSIT = { deposit: {} };
+DepositDirection.WITHDRAW = { withdraw: {} };
 class OracleSource {
 }
 exports.OracleSource = OracleSource;
 OracleSource.PYTH = { pyth: {} };
 OracleSource.SWITCHBOARD = { switchboard: {} };
+OracleSource.QUOTE_ASSET = { quoteAsset: {} };
 class OrderType {
 }
 exports.OrderType = OrderType;
@@ -44,6 +56,20 @@ OrderAction.PLACE = { place: {} };
 OrderAction.CANCEL = { cancel: {} };
 OrderAction.EXPIRE = { expire: {} };
 OrderAction.FILL = { fill: {} };
+OrderAction.TRIGGER = { trigger: {} };
+class OrderActionExplanation {
+}
+exports.OrderActionExplanation = OrderActionExplanation;
+OrderActionExplanation.NONE = { none: {} };
+OrderActionExplanation.BREACHED_MARGIN_REQUIREMENT = {
+    breachedMarginRequirement: {},
+};
+OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+    oraclePriceBreachedLimitPrice: {},
+};
+OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+    marketOrderFilledToLimitPrice: {},
+};
 class OrderTriggerCondition {
 }
 exports.OrderTriggerCondition = OrderTriggerCondition;
@@ -53,9 +79,36 @@ function isVariant(object, type) {
     return object.hasOwnProperty(type);
 }
 exports.isVariant = isVariant;
+function isOneOfVariant(object, types) {
+    return types.reduce((result, type) => {
+        return result || object.hasOwnProperty(type);
+    }, false);
+}
+exports.isOneOfVariant = isOneOfVariant;
 var TradeSide;
 (function (TradeSide) {
     TradeSide[TradeSide["None"] = 0] = "None";
     TradeSide[TradeSide["Buy"] = 1] = "Buy";
     TradeSide[TradeSide["Sell"] = 2] = "Sell";
 })(TradeSide = exports.TradeSide || (exports.TradeSide = {}));
+exports.DefaultOrderParams = {
+    orderType: OrderType.MARKET,
+    userOrderId: 0,
+    direction: PositionDirection.LONG,
+    baseAssetAmount: _1.ZERO,
+    price: _1.ZERO,
+    marketIndex: _1.ZERO,
+    reduceOnly: false,
+    postOnly: false,
+    immediateOrCancel: false,
+    triggerPrice: _1.ZERO,
+    triggerCondition: OrderTriggerCondition.ABOVE,
+    positionLimit: _1.ZERO,
+    oraclePriceOffset: _1.ZERO,
+    padding0: _1.ZERO,
+    padding1: _1.ZERO,
+    optionalAccounts: {
+        discountToken: false,
+        referrer: false,
+    },
+};

package/lib/userName.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_NAME_LENGTH = 32;
+export declare const DEFAULT_USER_NAME = "Main Account";
+export declare function encodeName(name: string): number[];
+export declare function decodeName(bytes: number[]): string;

package/lib/userName.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeName = exports.encodeName = exports.DEFAULT_USER_NAME = exports.MAX_NAME_LENGTH = void 0;
+exports.MAX_NAME_LENGTH = 32;
+exports.DEFAULT_USER_NAME = 'Main Account';
+function encodeName(name) {
+    if (name.length > exports.MAX_NAME_LENGTH) {
+        throw Error(`User name (${name}) longer than 32 characters`);
+    }
+    const buffer = Buffer.alloc(32);
+    buffer.fill(name);
+    buffer.fill(' ', name.length);
+    return Array(...buffer);
+}
+exports.encodeName = encodeName;
+function decodeName(bytes) {
+    const buffer = Buffer.from(bytes);
+    return buffer.toString('utf8').trim();
+}
+exports.decodeName = decodeName;

package/lib/util/computeUnits.js

@@ -1,27 +1,16 @@
 "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.findComputeUnitConsumption = void 0;
-function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
-    return __awaiter(this, void 0, void 0, function* () {
-        const tx = yield connection.getTransaction(txSignature, { commitment });
-        const computeUnits = [];
-        const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of 200000 compute units`);
-        tx.meta.logMessages.forEach((logMessage) => {
-            const match = logMessage.match(regex);
-            if (match && match[1]) {
-                computeUnits.push(match[1]);
-            }
-        });
-        return computeUnits;
+async function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    const tx = await connection.getTransaction(txSignature, { commitment });
+    const computeUnits = [];
+    const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of 200000 compute units`);
+    tx.meta.logMessages.forEach((logMessage) => {
+        const match = logMessage.match(regex);
+        if (match && match[1]) {
+            computeUnits.push(match[1]);
+        }
     });
+    return computeUnits;
 }
 exports.findComputeUnitConsumption = findComputeUnitConsumption;

package/lib/util/tps.js

@@ -1,27 +1,16 @@
 "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.estimateTps = void 0;
-function estimateTps(programId, connection, failed) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let signatures = yield connection.getSignaturesForAddress(programId, undefined, 'finalized');
-        if (failed) {
-            signatures = signatures.filter((signature) => signature.err);
-        }
-        const numberOfSignatures = signatures.length;
-        if (numberOfSignatures === 0) {
-            return 0;
-        }
-        return (numberOfSignatures /
-            (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
-    });
+async function estimateTps(programId, connection, failed) {
+    let signatures = await connection.getSignaturesForAddress(programId, undefined, 'finalized');
+    if (failed) {
+        signatures = signatures.filter((signature) => signature.err);
+    }
+    const numberOfSignatures = signatures.length;
+    if (numberOfSignatures === 0) {
+        return 0;
+    }
+    return (numberOfSignatures /
+        (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
 }
 exports.estimateTps = estimateTps;

package/lib/wallet.js

@@ -1,31 +1,18 @@
 "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.Wallet = void 0;
 class Wallet {
     constructor(payer) {
         this.payer = payer;
     }
-    signTransaction(tx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            tx.partialSign(this.payer);
-            return tx;
-        });
+    async signTransaction(tx) {
+        tx.partialSign(this.payer);
+        return tx;
     }
-    signAllTransactions(txs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return txs.map((t) => {
-                t.partialSign(this.payer);
-                return t;
-            });
+    async signAllTransactions(txs) {
+        return txs.map((t) => {
+            t.partialSign(this.payer);
+            return t;
         });
     }
     get publicKey() {