@riftresearch/sdk 0.16.0 → 0.19.0

package/README.md

@@ -42,14 +42,14 @@ const ethereumPepe = createCurrency({
 
 // Get a quote
 const { quote, executeSwap } = await sdk.getQuote({
-  from: Currencies.Ethereum.USDC,
-  to: Currencies.Bitcoin.BTC,
+  fromAsset: Currencies.Ethereum.USDC,
+  toAsset: Currencies.Bitcoin.BTC,
   amount: '100000000', // 100 USDC (6 decimals)
   mode: 'exact_input',
   slippageBps: 100, // 1%
 })
 
-console.log(`Swapping ${quote.from.expected} USDC for ${quote.to.expected} sats`)
+console.log(`Swapping ${quote.fromAsset.expected} USDC for ${quote.toAsset.expected} sats`)
 console.log(`Fees: $${quote.fees.totalUsd.toFixed(2)}`)
 
 // Execute the swap
@@ -64,8 +64,19 @@ const swap = await executeSwap({
 console.log(`Order ID: ${swap.orderId}`)
 
 // Check status
-const status = await sdk.getSwapStatus(swap.orderId)
+const status = await sdk.getOrderStatus(swap.orderId)
 console.log(`Status: ${status.status}`)
+
+// List orders with filters and cursor pagination
+const page = await sdk.getOrders({
+  sender: '0x1234...',
+  status: 'unfilled',
+  orderType: 'limit',
+  limit: 20,
+})
+
+console.log(`Fetched ${page.items.length} orders`)
+console.log(`Next cursor: ${page.nextCursor}`)
 ```
 
 ## Limit Orders
@@ -85,8 +96,8 @@ const walletClient = createWalletClient({ account, chain: base, transport: http(
 const sdk = new RiftSdk({ integratorName: 'my-app' })
 
 const result = await sdk.createLimitOrder({
-  from: Currencies.Base.USDC,
-  to: Currencies.Bitcoin.BTC,
+  fromAsset: Currencies.Base.USDC,
+  toAsset: Currencies.Bitcoin.BTC,
   pricing: {
     sellAmount: '1000000',   // 1 USDC (6 decimals)
     buyAmount: '2500',       // 2500 sats

package/dist/index.d.ts

@@ -108,9 +108,13 @@ interface QuoteResponseBase {
 interface ExactInputQuoteResponse extends QuoteResponseBase {
 	mode: "exact_input";
 	/** The exact input amount specified by the user */
-	from: SpecifiedAmount;
+	fromAsset: SpecifiedAmount;
+	/** @deprecated Temporary legacy alias for fromAsset */
+	from?: SpecifiedAmount;
 	/** The calculated output amount with slippage bound */
-	to: CalculatedOutputAmount;
+	toAsset: CalculatedOutputAmount;
+	/** @deprecated Temporary legacy alias for toAsset */
+	to?: CalculatedOutputAmount;
 }
 /**
 * Quote response for exact_output mode.
@@ -119,9 +123,13 @@ interface ExactInputQuoteResponse extends QuoteResponseBase {
 interface ExactOutputQuoteResponse extends QuoteResponseBase {
 	mode: "exact_output";
 	/** The calculated input amount with slippage bound */
-	from: CalculatedInputAmount;
+	fromAsset: CalculatedInputAmount;
+	/** @deprecated Temporary legacy alias for fromAsset */
+	from?: CalculatedInputAmount;
 	/** The exact output amount specified by the user */
-	to: SpecifiedAmount;
+	toAsset: SpecifiedAmount;
+	/** @deprecated Temporary legacy alias for toAsset */
+	to?: SpecifiedAmount;
 }
 /**
 * Discriminated union of quote responses.
@@ -184,6 +192,10 @@ interface AnalyticsOrderResponse {
 	lastSourceUpdateAt: string | null;
 	terminalAt: string | null;
 }
+interface AnalyticsOrdersResponse {
+	items: AnalyticsOrderResponse[];
+	nextCursor: string | null;
+}
 interface ErrorResponse {
 	error: string;
 }
@@ -366,11 +378,13 @@ import { Chain as Chain3 } from "viem";
 import { Account, PublicClient, Transport, WalletClient } from "viem";
 import { Chain as Chain2 } from "viem/chains";
 type RiftSwap = AnalyticsOrderResponse;
+type RiftOrdersPage = AnalyticsOrdersResponse;
+type OrderTypeFilter = "market" | "limit";
 interface QuoteParameters {
 	/** The currency to swap from */
-	from: Currency;
+	fromAsset: Currency;
 	/** The currency to swap to */
-	to: Currency;
+	toAsset: Currency;
 	/** Amount in smallest unit (sats for BTC, wei for ETH, etc.) */
 	amount: string;
 	/** Whether amount refers to input or output */
@@ -405,9 +419,13 @@ interface QuoteResultBase {
 interface ExactInputQuoteResult extends QuoteResultBase {
 	mode: "exact_input";
 	/** The exact input amount specified by the user */
-	from: SpecifiedAmount;
+	fromAsset: SpecifiedAmount;
+	/** @deprecated Temporary legacy alias for fromAsset */
+	from?: SpecifiedAmount;
 	/** The calculated output amount with slippage bound */
-	to: CalculatedOutputAmount;
+	toAsset: CalculatedOutputAmount;
+	/** @deprecated Temporary legacy alias for toAsset */
+	to?: CalculatedOutputAmount;
 }
 /**
 * Quote result for exact_output mode.
@@ -416,9 +434,13 @@ interface ExactInputQuoteResult extends QuoteResultBase {
 interface ExactOutputQuoteResult extends QuoteResultBase {
 	mode: "exact_output";
 	/** The calculated input amount with slippage bound */
-	from: CalculatedInputAmount;
+	fromAsset: CalculatedInputAmount;
+	/** @deprecated Temporary legacy alias for fromAsset */
+	from?: CalculatedInputAmount;
 	/** The exact output amount specified by the user */
-	to: SpecifiedAmount;
+	toAsset: SpecifiedAmount;
+	/** @deprecated Temporary legacy alias for toAsset */
+	to?: SpecifiedAmount;
 }
 /**
 * Discriminated union of quote results.
@@ -429,11 +451,35 @@ interface GetQuoteResult {
 	quote: QuoteResult;
 	executeSwap: <chain extends Chain2 | undefined = Chain2 | undefined>(context: ExecuteSwapOptions<chain>) => Promise<SwapResult>;
 }
+type LiquidityLimit = {
+	from: Currency;
+	to: Currency;
+	maxInput: string;
+};
+type LiquidityResponse = {
+	limits: LiquidityLimit[];
+};
 interface SwapResult {
 	orderId: string;
 	status: AnalyticsOrderStatus;
 	rift: RiftSwap;
 }
+interface GetOrdersOptions {
+	/** Filter by exact sender address */
+	sender?: string;
+	/** Filter by exact destination address */
+	destination?: string;
+	/** Filter by exact refund address */
+	refund?: string;
+	/** Filter by execution type */
+	orderType?: OrderTypeFilter;
+	/** Filter by coarse public order status */
+	status?: AnalyticsOrderStatus;
+	/** Page size. The API clamps this between 1 and 100, defaulting to 50. */
+	limit?: number;
+	/** Opaque cursor returned by a previous getOrders() response */
+	cursor?: string;
+}
 type CancelOrderResult = CancelOrderResponse;
 /**
 * Function type for sending Bitcoin.
@@ -463,8 +509,8 @@ type SendBitcoinFn = (params: {
 }) => Promise<void>;
 type ExecuteSwapStepType = "approval" | "transaction" | "signature";
 type CreateLimitOrderOptions<chain extends Chain2 | undefined = Chain2 | undefined> = ExecuteSwapContext<chain> & {
-	from: Currency;
-	to: Currency;
+	fromAsset: Currency;
+	toAsset: Currency;
 	pricing: LimitPricing;
 	destinationAddress: string;
 	refundAddress?: string;
@@ -524,19 +570,21 @@ declare class RiftSdk {
 	constructor(options: RiftSdkOptions);
 	private logDebug;
 	private unwrapEdenResult;
+	private normalizeQuoteParameters;
+	private normalizeLimitOrderOptions;
 	/**
 	* Get a quote for a swap and return a function to execute it.
 	*
 	* @example
 	* const { quote, executeSwap } = await sdk.getQuote({
-	*   from: Currencies.Base.CBBTC,
-	*   to: Currencies.Bitcoin.BTC,
+	*   fromAsset: Currencies.Base.CBBTC,
+	*   toAsset: Currencies.Bitcoin.BTC,
 	*   amount: '100000000', // 1 cbBTC
 	*   mode: 'exact_input',
 	*   slippageBps: 100, // 1%
 	* })
 	*
-	* console.log(`You'll receive: ${quote.to.expected} sats`)
+	* console.log(`You'll receive: ${quote.toAsset.expected} sats`)
 	* const swap = await executeSwap({
 	*   destinationAddress: 'bc1q...',
 	*   publicClient,
@@ -585,8 +633,21 @@ declare class RiftSdk {
 	/**
 	* Get the current status of an order by its ID.
 	*/
+	getOrderStatus(orderId: string): Promise<AnalyticsOrderResponse>;
+	/**
+	* @deprecated Use getOrderStatus() instead.
+	*/
 	getSwapStatus(orderId: string): Promise<AnalyticsOrderResponse>;
 	/**
+	* List orders through the public `/orders` endpoint with the same filters
+	* exposed by the swap-router OpenAPI documentation.
+	*/
+	getOrders(options?: GetOrdersOptions): Promise<RiftOrdersPage>;
+	/**
+	* Get the current exact-input liquidity limits exposed by the swap router.
+	*/
+	getLiquidity(): Promise<LiquidityResponse>;
+	/**
 	* Cancel a supported limit order through the swap router.
 	*
 	* The SDK first requests the backend-specific typed-data payload from the
@@ -596,4 +657,4 @@ declare class RiftSdk {
 	cancelOrder<chain extends Chain3 | undefined = Chain3 | undefined>(options: CancelOrderOptions<chain>): Promise<CancelOrderResult>;
 }
 declare function createRiftSdk(options: RiftSdkOptions): RiftSdk;
-export { getSupportedModes, detectRoute, createRiftSdk, createCurrency, TokenIdentifier, AnalyticsOrderStatus as SwapStatus, SwapRouterApiError, SwapRoute, SwapResult, SwapResponse, SupportedModes, SendBitcoinFn, RiftSwap, RiftSdkOptions, RiftSdk, QuoteResult, QuoteParameters, NativeToken, LimitPricing, GetQuoteResult, ExecutionStep, ExecutionAction, ExecuteSwapStepType, ExecuteSwapOptions, ExecuteSwapOnExecuteStepCallback, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, CreateLimitOrderOptions, Chain, CancelOrderResult, CancelOrderOptions, BtcTransferStep, BtcTransferKind, BitcoinChain };
+export { getSupportedModes, detectRoute, createRiftSdk, createCurrency, TokenIdentifier, AnalyticsOrderStatus as SwapStatus, SwapRouterApiError, SwapRoute, SwapResult, SwapResponse, SupportedModes, SendBitcoinFn, RiftSwap, RiftSdkOptions, RiftSdk, RiftOrdersPage, QuoteResult, QuoteParameters, OrderTypeFilter, NativeToken, LiquidityResponse, LiquidityLimit, LimitPricing, GetQuoteResult, GetOrdersOptions, ExecutionStep, ExecutionAction, ExecuteSwapStepType, ExecuteSwapOptions, ExecuteSwapOnExecuteStepCallback, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, CreateLimitOrderOptions, Chain, CancelOrderResult, CancelOrderOptions, BtcTransferStep, BtcTransferKind, BitcoinChain };

package/dist/index.js

@@ -183,6 +183,20 @@ import {
 } from "viem";
 
 // src/client.ts
+function buildQueryString(query) {
+  if (!query) {
+    return "";
+  }
+  const searchParams = new URLSearchParams;
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined) {
+      continue;
+    }
+    searchParams.set(key, String(value));
+  }
+  const search = searchParams.toString();
+  return search.length > 0 ? `?${search}` : "";
+}
 async function request(baseUrl, path, init) {
   try {
     const response = await fetch(`${baseUrl}${path}`, init);
@@ -249,6 +263,19 @@ function postJson(baseUrl, path, body) {
 }
 function createClient(baseUrl) {
   const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  const toCreateMarketOrderRequest = (body) => ({
+    orderType: "market",
+    quoteId: body.id,
+    ...body.senderAddress !== undefined ? { senderAddress: body.senderAddress } : {},
+    destinationAddress: body.destinationAddress,
+    refundAddress: body.refundAddress,
+    ...body.integratorName !== undefined ? { integratorName: body.integratorName } : {},
+    ...body.approvalMode !== undefined ? { approvalMode: body.approvalMode } : {}
+  });
+  const toCreateLimitOrderRequest = (body) => ({
+    orderType: "limit",
+    ...body
+  });
   const swap = (params) => {
     const orderId = encodeURIComponent(params.orderId);
     return {
@@ -267,19 +294,27 @@ function createClient(baseUrl) {
       }
     };
   };
-  swap.post = (body) => postJson(normalizedBaseUrl, "/order/market", body);
+  swap.post = (body) => postJson(normalizedBaseUrl, "/order", toCreateMarketOrderRequest(body));
   const market = {
-    post: (body) => postJson(normalizedBaseUrl, "/order/market", body)
+    post: (body) => postJson(normalizedBaseUrl, "/order", toCreateMarketOrderRequest(body))
   };
   const limit = {
-    post: (body) => postJson(normalizedBaseUrl, "/order/limit", body)
+    post: (body) => postJson(normalizedBaseUrl, "/order", toCreateLimitOrderRequest(body))
+  };
+  const liquidity = {
+    get: () => get(normalizedBaseUrl, "/liquidity")
+  };
+  const orders = {
+    get: (query) => get(normalizedBaseUrl, `/orders${buildQueryString(query)}`)
   };
   return {
+    liquidity,
     quote: {
       post: (body) => postJson(normalizedBaseUrl, "/quote", body)
     },
     market,
     limit,
+    orders,
     swap
   };
 }
@@ -358,45 +393,72 @@ class RiftSdk {
     }
     throw new SwapRouterApiError(message, status, value);
   }
+  normalizeQuoteParameters(params) {
+    const legacy = params;
+    const fromAsset = params.fromAsset ?? legacy.from;
+    const toAsset = params.toAsset ?? legacy.to;
+    if (!fromAsset || !toAsset) {
+      throw new Error("Quote parameters must include fromAsset/toAsset or legacy from/to.");
+    }
+    return {
+      ...params,
+      fromAsset,
+      toAsset
+    };
+  }
+  normalizeLimitOrderOptions(options) {
+    const legacy = options;
+    const fromAsset = options.fromAsset ?? legacy.from;
+    const toAsset = options.toAsset ?? legacy.to;
+    if (!fromAsset || !toAsset) {
+      throw new Error("Limit order options must include fromAsset/toAsset or legacy from/to.");
+    }
+    return {
+      ...options,
+      fromAsset,
+      toAsset
+    };
+  }
   async getQuote(params) {
+    params = this.normalizeQuoteParameters(params);
     if (!Number.isFinite(params.slippageBps) || !Number.isInteger(params.slippageBps)) {
       throw new Error("slippageBps must be an integer number of basis points");
     }
     if (params.slippageBps < 0 || params.slippageBps > 1e4) {
       throw new Error("slippageBps must be between 0 and 10000");
     }
-    const route = detectRoute(params.from, params.to);
+    const route = detectRoute(params.fromAsset, params.toAsset);
     const quoteRequest = {
       type: params.mode === "exact_input" ? "EXACT_INPUT" : "EXACT_OUTPUT",
-      from: params.from,
-      to: params.to,
+      fromAsset: params.fromAsset,
+      toAsset: params.toAsset,
       amount: params.amount,
       slippageBps: params.slippageBps
     };
     const riftQuote = this.unwrapEdenResult(await this.riftClient.quote.post(quoteRequest));
     const quote = this.buildQuoteResult(riftQuote, params);
-    const isChained = route.type === "direct_rift" && route.direction === "from_btc" && !isCbBtc(params.to);
+    const isChained = route.type === "direct_rift" && route.direction === "from_btc" && !isCbBtc(params.toAsset);
     return {
       quote,
       executeSwap: async (context) => {
         if (!context?.destinationAddress) {
           throw new Error("destinationAddress is required to execute swap");
         }
-        if (params.from.chain.kind === "BITCOIN" && !context.refundAddress) {
+        if (params.fromAsset.chain.kind === "BITCOIN" && !context.refundAddress) {
           throw new Error("refundAddress is required for BTC swaps (Bitcoin refund address)");
         }
         this.logDebug("executeSwap called", {
           route: route.type,
           mode: params.mode,
-          from: params.from,
-          to: params.to,
+          fromAsset: params.fromAsset,
+          toAsset: params.toAsset,
           amount: params.amount
         });
         const refundAddress = context.refundAddress ?? this.getRefundAddress(params, context);
         this.logDebug("resolved refund address", { refundAddress });
         if (this.preflightCheckBalances) {
           this.logDebug("running preflight balance check");
-          await this.assertSufficientBalance(params.from, quote.from.expected, context);
+          await this.assertSufficientBalance(params.fromAsset, quote.fromAsset.expected, context);
         }
         return this.executeOrderFlow({
           context,
@@ -404,7 +466,7 @@ class RiftSdk {
           chained: isChained,
           createOrder: async () => {
             this.logDebug("creating market order", { quoteId: riftQuote.id });
-            const senderAddress = params.from.chain.kind === "EVM" ? this.getAddress(context) : undefined;
+            const senderAddress = params.fromAsset.chain.kind === "EVM" ? this.getAddress(context) : undefined;
             return this.unwrapEdenResult(await this.riftClient.market.post({
               id: riftQuote.id,
               ...senderAddress ? { senderAddress } : {},
@@ -419,15 +481,16 @@ class RiftSdk {
     };
   }
   async createLimitOrder(options) {
+    options = this.normalizeLimitOrderOptions(options);
     if (!options?.destinationAddress) {
       throw new Error("destinationAddress is required to create a limit order");
     }
-    if (options.from.token.kind === "TOKEN") {
-      if (!isAddress(options.from.token.address)) {
+    if (options.fromAsset.token.kind === "TOKEN") {
+      if (!isAddress(options.fromAsset.token.address)) {
         throw new Error("from.token.address must be a valid EVM token address");
       }
     }
-    if (options.to.token.kind === "TOKEN" && !isAddress(options.to.token.address)) {
+    if (options.toAsset.token.kind === "TOKEN" && !isAddress(options.toAsset.token.address)) {
       throw new Error("to.token.address must be a valid EVM token address");
     }
     this.assertPositiveIntegerString(options.pricing.buyAmount, "pricing.buyAmount");
@@ -437,14 +500,14 @@ class RiftSdk {
     }
     let refundAddress;
     let senderAddress;
-    if (options.from.chain.kind === "BITCOIN") {
-      if (options.from.token.kind !== "NATIVE") {
+    if (options.fromAsset.chain.kind === "BITCOIN") {
+      if (options.fromAsset.token.kind !== "NATIVE") {
         throw new Error("BTC-start limit orders must use native BTC as the input");
       }
       if (!options.refundAddress) {
         throw new Error("refundAddress is required for BTC-start limit orders (Bitcoin refund address).");
       }
-      if (isCbBtc(options.to)) {
+      if (isCbBtc(options.toAsset)) {
         throw new Error("BTC -> cbBTC limit orders are not supported");
       }
       refundAddress = options.refundAddress;
@@ -455,31 +518,31 @@ class RiftSdk {
         throw new Error("refundAddress must be a valid EVM address for EVM-start limit orders");
       }
     }
-    if (options.to.chain.kind === "BITCOIN") {
-      if (options.from.chain.kind !== "EVM") {
+    if (options.toAsset.chain.kind === "BITCOIN") {
+      if (options.fromAsset.chain.kind !== "EVM") {
         throw new Error("Bitcoin-payout limit orders require an EVM source currency.");
       }
-      if (isCbBtc(options.from)) {
+      if (isCbBtc(options.fromAsset)) {
         throw new Error("cbBTC -> BTC limit orders are not supported");
       }
     } else {
       if (!isAddress(options.destinationAddress)) {
         throw new Error("destinationAddress must be a valid EVM address for EVM-destination limit orders");
       }
-      if (options.to.chain.chainId !== 1 && options.to.chain.chainId !== 8453) {
-        throw new Error(`Unsupported limit order chainId: ${options.to.chain.chainId}. Expected 1 or 8453.`);
+      if (options.toAsset.chain.chainId !== 1 && options.toAsset.chain.chainId !== 8453) {
+        throw new Error(`Unsupported limit order chainId: ${options.toAsset.chain.chainId}. Expected 1 or 8453.`);
       }
-      if (options.from.chain.kind === "EVM") {
-        if (options.from.chain.chainId !== options.to.chain.chainId) {
+      if (options.fromAsset.chain.kind === "EVM") {
+        if (options.fromAsset.chain.chainId !== options.toAsset.chain.chainId) {
           throw new Error("EVM-start limit orders currently require from/to on the same EVM chain.");
         }
       }
     }
     this.logDebug("resolved limit order refund address", { refundAddress });
-    const route = detectRoute(options.from, options.to);
-    if (this.preflightCheckBalances && options.from.chain.kind === "EVM") {
+    const route = detectRoute(options.fromAsset, options.toAsset);
+    if (this.preflightCheckBalances && options.fromAsset.chain.kind === "EVM") {
       this.logDebug("running limit-order preflight balance check");
-      await this.assertSufficientBalance(options.from, options.pricing.sellAmount, options);
+      await this.assertSufficientBalance(options.fromAsset, options.pricing.sellAmount, options);
     }
     return this.executeOrderFlow({
       context: options,
@@ -487,8 +550,8 @@ class RiftSdk {
       chained: false,
       createOrder: async () => {
         const request2 = {
-          from: options.from,
-          to: options.to,
+          fromAsset: options.fromAsset,
+          toAsset: options.toAsset,
           ...senderAddress ? { senderAddress } : {},
           pricing: options.pricing,
           destinationAddress: options.destinationAddress,
@@ -498,7 +561,7 @@ class RiftSdk {
           integratorName: this.integratorName
         };
         this.logDebug("creating limit order", {
-          to: request2.to,
+          toAsset: request2.toAsset,
           pricing: request2.pricing
         });
         return this.unwrapEdenResult(await this.riftClient.limit.post(request2));
@@ -815,8 +878,10 @@ class RiftSdk {
       return {
         mode: "exact_input",
         quoteId: riftQuote.id,
-        from: riftQuote.from,
-        to: riftQuote.to,
+        fromAsset: riftQuote.fromAsset,
+        from: riftQuote.fromAsset,
+        toAsset: riftQuote.toAsset,
+        to: riftQuote.toAsset,
         fees: riftQuote.fees,
         expiresAt: new Date(riftQuote.expiresAt)
       };
@@ -824,8 +889,10 @@ class RiftSdk {
       return {
         mode: "exact_output",
         quoteId: riftQuote.id,
-        from: riftQuote.from,
-        to: riftQuote.to,
+        fromAsset: riftQuote.fromAsset,
+        from: riftQuote.fromAsset,
+        toAsset: riftQuote.toAsset,
+        to: riftQuote.toAsset,
         fees: riftQuote.fees,
         expiresAt: new Date(riftQuote.expiresAt)
       };
@@ -941,7 +1008,7 @@ class RiftSdk {
     return account.address;
   }
   getRefundAddress(params, context) {
-    if (params.from.chain.kind === "BITCOIN") {
+    if (params.fromAsset.chain.kind === "BITCOIN") {
       throw new Error("refundAddress is required for BTC swaps (Bitcoin refund address)");
     }
     return this.getAddress(context);
@@ -995,9 +1062,18 @@ class RiftSdk {
     }
     return context.sendBitcoin;
   }
-  async getSwapStatus(orderId) {
+  async getOrderStatus(orderId) {
     return this.unwrapEdenResult(await this.riftClient.swap({ orderId }).get());
   }
+  async getSwapStatus(orderId) {
+    return this.getOrderStatus(orderId);
+  }
+  async getOrders(options) {
+    return this.unwrapEdenResult(await this.riftClient.orders.get(options));
+  }
+  async getLiquidity() {
+    return this.unwrapEdenResult(await this.riftClient.liquidity.get());
+  }
   async cancelOrder(options) {
     const walletClient = options.walletClient;
     const account = walletClient.account;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@riftresearch/sdk",
-	"version": "0.16.0",
+	"version": "0.19.0",
 	"description": "SDK for swapping between bitcoin and evm chains",
 	"license": "MIT",
 	"files": [