@ravnexchange/sdk 0.1.8 → 0.1.10

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { ChainDTO, ExecuteParams, ExecutionDTO, GetQuoteParams, QuoteDTO, StatusDTO, SubmitSignatureParams, TokenDTO } from "./types";
+import type { ChainDTO, ExecuteParams, ExecutionDTO, GetQuoteParams, QuoteDTO, StatusDTO, SubmitSignatureParams, SubmitTransactionParams, TokenDTO } from "./types";
 export interface RavnClientConfig {
     /** Self-serve or enterprise key. Omit for the anonymous tier (works immediately, lower rate limit). */
     apiKey?: string;
@@ -21,6 +21,12 @@ export declare class RavnClient {
     submitSignature(params: SubmitSignatureParams): Promise<{
         statusRef: string;
     }>;
+    /** POST /v1/submit-transaction: only for a TRANSACTION execution carrying `submit`
+     * (broadcastViaRavn quotes). RAVN checks the signed transaction, then sends it; refused, nothing
+     * is sent. Returns the Solana signature; poll getStatus with the execution's statusRef. */
+    submitTransaction(params: SubmitTransactionParams): Promise<{
+        txHash: string;
+    }>;
     /** POST /v1/status: pass the quoteToken execute() returned (not the quote's own), and as `ref`
      * the execution's statusRef, submitSignature's statusRef, or the origin tx hash. POST, not GET:
      * a 2-hop quoteToken in a query string can exceed header limits and fail with 431. */

package/dist/client.js

@@ -51,6 +51,15 @@ class RavnClient {
             body: JSON.stringify(params),
         });
     }
+    /** POST /v1/submit-transaction: only for a TRANSACTION execution carrying `submit`
+     * (broadcastViaRavn quotes). RAVN checks the signed transaction, then sends it; refused, nothing
+     * is sent. Returns the Solana signature; poll getStatus with the execution's statusRef. */
+    submitTransaction(params) {
+        return this.request("/submit-transaction", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
     /** POST /v1/status: pass the quoteToken execute() returned (not the quote's own), and as `ref`
      * the execution's statusRef, submitSignature's statusRef, or the origin tx hash. POST, not GET:
      * a 2-hop quoteToken in a query string can exceed header limits and fail with 431. */

package/dist/execute-and-track.d.ts

@@ -18,6 +18,11 @@ export interface ExecuteAndTrackHandlers {
     waitForReceipt(hash: string, chainId?: number): Promise<void>;
     /** Sign an EIP-712 typed-data payload. Only called for SIGNATURE executions. */
     signTypedData?(typedData: Record<string, unknown>): Promise<`0x${string}`>;
+    /**
+     * Sign (don't send) a base64 Solana transaction and return it signed, base64. Only called for a
+     * TRANSACTION carrying `submit` (broadcastViaRavn quotes), which RAVN checks and sends itself.
+     */
+    signSolanaTransaction?(serialized: string): Promise<string>;
     /**
      * The API sends `approval` whenever the venue generically needs an allowance: it deliberately
      * never reads the chain to check whether the caller already has one (that's an RPC round-trip

package/dist/execute-and-track.js

@@ -33,6 +33,20 @@ async function executeAndTrack(client, params, handlers, options = {}) {
         await handlers.waitForReceipt(hash, approval.chainId);
         return hash;
     };
+    if (execution.executionType === "TRANSACTION" && execution.submit) {
+        // Never broadcast this one ourselves: a payment Layerswap can't match sits at Layerswap, and
+        // RAVN's check before sending is what catches it.
+        if (!handlers.signSolanaTransaction) {
+            throw new Error("executeAndTrack: this execution must be submitted through RAVN and requires signSolanaTransaction, none was provided");
+        }
+        if (!execution.transaction.serialized) {
+            throw new Error("executeAndTrack: TRANSACTION execution with submit is missing transaction.serialized");
+        }
+        const signedTransaction = await handlers.signSolanaTransaction(execution.transaction.serialized);
+        const { txHash } = await client.submitTransaction({ quoteToken, signedTransaction });
+        const statusRef = execution.statusRef ?? txHash;
+        return { execution, quoteToken, txHash, statusRef, finalStatus: await pollStatus(statusRef) };
+    }
     if (execution.executionType === "TRANSACTION") {
         const approvalTxHash = await maybeSendApproval(execution.approval);
         const txHash = await handlers.sendTransaction(execution.transaction);

package/dist/types.d.ts

@@ -52,6 +52,12 @@ export interface QuoteDTO {
     outputUsd: string | null;
     estimatedTimeSeconds: number;
     estimatedTimeIsGuess: boolean;
+    /** Epoch ms, always a real time: execute() on `quoteToken` before this, re-quote after. Never
+     * refused for age before it; past it most routes fail with QUOTE_EXPIRED. Already 5 s ahead of
+     * the venue's own deadline, so compare it to the clock as is. 2-hop routes
+     * (`venue.id === "compose"`) and venues with no deadline are never refused for age: it's 60 s
+     * from the response, when to re-quote. A 2-hop route re-prices at execute (BUILD_FAILED if the
+     * minimum shown can no longer be met). */
     expiresAt: number;
     /** Present on 2-hop (`venue.id === "compose"`) and Relay dest-call quotes. Sign hop 1; hop 2 is
      * a unique deposit, not a second wallet tx. */
@@ -82,6 +88,9 @@ export interface AlternativeQuoteDTO {
     executable: boolean;
     estimatedTimeSeconds: number;
     estimatedTimeIsGuess: boolean;
+    /** This route's own execute deadline, same meaning as QuoteDTO.expiresAt. Venues differ, so
+     * check it before executing an alternative. */
+    expiresAt: number;
     hops?: {
         id: string;
         name: string;
@@ -139,6 +148,12 @@ export type ExecutionDTO = {
         chainId?: number;
         serialized?: string;
     };
+    /** Only on quotes made with `broadcastViaRavn: true`. Don't broadcast this one: sign
+     * `transaction.serialized` and pass it to submitTransaction, which checks the signed
+     * transaction still pays Layerswap the way it matches deposits, then sends it. */
+    submit?: {
+        url: string;
+    };
 } | {
     executionType: "SIGNATURE";
     /** Pass this, not the quote's own token, to submitSignature and getStatus. */
@@ -205,6 +220,12 @@ export interface GetQuoteParams {
     /** Test quote -> execute -> status with no real funds and no live venue settlement. See
      * the API's own sandbox field description for per-venue/per-route exceptions. */
     sandbox?: boolean;
+    /** Set if you can post a signed Solana transaction back (submitTransaction) instead of
+     * broadcasting it yourself. Adds Layerswap's memo routes (Solana tokens into native BTC or
+     * Robinhood Chain stocks, no account rent), which only work when RAVN checks the signed
+     * transaction first: a TRANSACTION execution carrying `submit` must go through
+     * submitTransaction. executeAndTrack does this when given signSolanaTransaction. */
+    broadcastViaRavn?: boolean;
 }
 export interface ExecuteParams {
     quoteToken: string;
@@ -220,6 +241,12 @@ export interface SubmitSignatureParams {
     signature: `0x${string}`;
     approvalSignature?: `0x${string}`;
 }
+export interface SubmitTransactionParams {
+    /** The quoteToken execute() returned with that transaction, not the quote's own. */
+    quoteToken: string;
+    /** `transaction.serialized` after your user's wallet signed it, base64. */
+    signedTransaction: string;
+}
 export interface ErrorMeta {
     requestId: string;
     version: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ravnexchange/sdk",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Typed client for the RAVN integrator API (/api/v1): quote, execute, submit-signature, status.",
   "keywords": ["ravn", "cross-chain", "swap", "swap-api", "dex-aggregator", "bitcoin", "native-btc", "solana", "evm", "crypto", "defi", "typescript", "sdk", "api-client"],
   "main": "./dist/index.js",