@atomiqlabs/chain-starknet 6.0.0-beta.0 → 6.0.0-beta.2

package/dist/starknet/btcrelay/StarknetBtcRelay.d.ts

@@ -61,7 +61,7 @@ export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContra
     }, requiredBlockheight?: number): Promise<{
         header: StarknetBtcStoredHeader;
         height: number;
-    } | null>;
+    }>;
     /**
      * Retrieves blockheader data by blockheader's commit hash,
      *

package/dist/starknet/events/StarknetChainEventsBrowser.js

@@ -49,7 +49,18 @@ class StarknetChainEventsBrowser {
      */
     getSwapDataGetter(event, claimHandler) {
         return async () => {
-            const trace = await this.provider.getTransactionTrace(event.txHash);
+            let trace;
+            try {
+                trace = await this.provider.getTransactionTrace(event.txHash);
+            }
+            catch (e) {
+                this.logger.warn("getSwapDataGetter(): getter: starknet_traceTransaction not supported by the RPC: ", e);
+                const blockTraces = await this.provider.getBlockTransactionsTraces(event.blockHash);
+                const foundTrace = blockTraces.find(val => (0, Utils_1.toHex)(val.transaction_hash) === (0, Utils_1.toHex)(event.txHash));
+                if (foundTrace == null)
+                    throw new Error(`Cannot find ${event.txHash} in the block traces, block: ${event.blockHash}`);
+                trace = foundTrace.trace_root;
+            }
             if (trace == null)
                 return null;
             if (trace.execute_invocation.revert_reason != null)

package/dist/starknet/provider/RpcProviderWithRetries.d.ts

@@ -1,5 +1,18 @@
-import { RpcChannel, RpcProvider, RpcProviderOptions } from "starknet";
-export declare class RpcChannelWithRetries extends RpcChannel {
+import { RPC08, RPC09, RpcProvider, RpcProviderOptions } from "starknet";
+export declare class Rpc08ChannelWithRetries extends RPC08.RpcChannel {
+    readonly retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    };
+    constructor(options?: RpcProviderOptions, retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    });
+    protected fetchEndpoint(method: any, params?: any): Promise<any>;
+}
+export declare class Rpc09ChannelWithRetries extends RPC09.RpcChannel {
     readonly retryPolicy?: {
         maxRetries?: number;
         delay?: number;
@@ -13,6 +26,13 @@ export declare class RpcChannelWithRetries extends RpcChannel {
     protected fetchEndpoint(method: any, params?: any): Promise<any>;
 }
 export declare class RpcProviderWithRetries extends RpcProvider {
+    /**
+     * Tries to do naive detection of the spec version based on the suffix of nodeUrl, better pass the `specVersion`
+     *  in the options!
+     *
+     * @param options
+     * @param retryPolicy
+     */
     constructor(options?: RpcProviderOptions, retryPolicy?: {
         maxRetries?: number;
         delay?: number;

package/dist/starknet/provider/RpcProviderWithRetries.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcProviderWithRetries = exports.RpcChannelWithRetries = void 0;
+exports.RpcProviderWithRetries = exports.Rpc09ChannelWithRetries = exports.Rpc08ChannelWithRetries = void 0;
 const starknet_1 = require("starknet");
 const Utils_1 = require("../../utils/Utils");
-class RpcChannelWithRetries extends starknet_1.RpcChannel {
+class Rpc08ChannelWithRetries extends starknet_1.RPC08.RpcChannel {
     constructor(options, retryPolicy) {
         super(options);
         this.retryPolicy = retryPolicy;
@@ -22,11 +22,45 @@ class RpcChannelWithRetries extends starknet_1.RpcChannel {
         });
     }
 }
-exports.RpcChannelWithRetries = RpcChannelWithRetries;
+exports.Rpc08ChannelWithRetries = Rpc08ChannelWithRetries;
+class Rpc09ChannelWithRetries extends starknet_1.RPC09.RpcChannel {
+    constructor(options, retryPolicy) {
+        super(options);
+        this.retryPolicy = retryPolicy;
+    }
+    fetchEndpoint(method, params) {
+        return (0, Utils_1.tryWithRetries)(() => super.fetchEndpoint(method, params), this.retryPolicy, e => {
+            if (!e.message.startsWith("RPC: "))
+                return false;
+            const arr = e.message.split("\n");
+            const errorCode = parseInt(arr[arr.length - 1]);
+            if (isNaN(errorCode))
+                return false;
+            if (errorCode < 0)
+                return false; //Not defined error, e.g. Rate limit (-32097)
+            return true;
+        });
+    }
+}
+exports.Rpc09ChannelWithRetries = Rpc09ChannelWithRetries;
 class RpcProviderWithRetries extends starknet_1.RpcProvider {
+    /**
+     * Tries to do naive detection of the spec version based on the suffix of nodeUrl, better pass the `specVersion`
+     *  in the options!
+     *
+     * @param options
+     * @param retryPolicy
+     */
     constructor(options, retryPolicy) {
+        if (options.specVersion == null)
+            options.specVersion = options.nodeUrl.endsWith("v0_8") ? "0.8.1" : "0.9.0";
         super(options);
-        this.channel = new RpcChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+        if (this.channel.id === "RPC081") {
+            this.channel = new Rpc08ChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+        }
+        else if (this.channel.id === "RPC090") {
+            this.channel = new Rpc09ChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+        }
     }
 }
 exports.RpcProviderWithRetries = RpcProviderWithRetries;

package/dist/starknet/swaps/StarknetSwapContract.d.ts

@@ -147,7 +147,7 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
         txid: string;
         hex: string;
         height: number;
-    }, requiredConfirmations: number, vout: number, commitedHeader?: StarknetBtcStoredHeader, synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, initAta?: boolean, feeRate?: string): Promise<StarknetTx[] | null>;
+    }, requiredConfirmations: number, vout: number, commitedHeader?: StarknetBtcStoredHeader, synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, initAta?: boolean, feeRate?: string): Promise<StarknetTx[]>;
     txsRefund(signer: string, swapData: StarknetSwapData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<StarknetTx[]>;
     txsRefundWithAuthorization(signer: string, swapData: StarknetSwapData, { timeout, prefix, signature }: {
         timeout: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "6.0.0-beta.0",
+  "version": "6.0.0-beta.2",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/starknet/btcrelay/StarknetBtcRelay.ts

@@ -222,7 +222,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
     public async retrieveLogAndBlockheight(blockData: {blockhash: string}, requiredBlockheight?: number): Promise<{
         header: StarknetBtcStoredHeader,
         height: number
-    } | null> {
+    }> {
         //TODO: we can fetch the blockheight and events in parallel
         const blockHeight = await this.getBlockHeight();
         if(requiredBlockheight!=null && blockHeight < requiredBlockheight) {

package/src/starknet/events/StarknetChainEventsBrowser.ts

@@ -100,7 +100,16 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
         claimHandler: IClaimHandler<any, any>
     ): () => Promise<StarknetSwapData> {
         return async () => {
-            const trace: any = await this.provider.getTransactionTrace(event.txHash);
+            let trace: any;
+            try {
+                trace = await this.provider.getTransactionTrace(event.txHash);
+            } catch (e) {
+                this.logger.warn("getSwapDataGetter(): getter: starknet_traceTransaction not supported by the RPC: ", e);
+                const blockTraces: any[] = await this.provider.getBlockTransactionsTraces(event.blockHash);
+                const foundTrace = blockTraces.find(val => toHex(val.transaction_hash)===toHex(event.txHash));
+                if(foundTrace==null) throw new Error(`Cannot find ${event.txHash} in the block traces, block: ${event.blockHash}`);
+                trace = foundTrace.trace_root;
+            }
             if(trace==null) return null;
             if(trace.execute_invocation.revert_reason!=null) return null;
             return this.findInitSwapData(trace.execute_invocation as any, event.params.escrow_hash, claimHandler);

package/src/starknet/provider/RpcProviderWithRetries.ts

@@ -1,11 +1,37 @@
 import {
-    RpcChannel,
+    RPC08, RPC09,
     RpcProvider,
     RpcProviderOptions
 } from "starknet";
 import {tryWithRetries} from "../../utils/Utils";
 
-export class RpcChannelWithRetries extends RpcChannel {
+export class Rpc08ChannelWithRetries extends RPC08.RpcChannel {
+
+    readonly retryPolicy?: {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    };
+
+    constructor(options?: RpcProviderOptions, retryPolicy?: {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    }) {
+        super(options);
+        this.retryPolicy = retryPolicy;
+    }
+
+    protected fetchEndpoint(method: any, params?: any): Promise<any> {
+        return tryWithRetries(() => super.fetchEndpoint(method, params), this.retryPolicy, e => {
+            if(!e.message.startsWith("RPC: ")) return false;
+            const arr = e.message.split("\n");
+            const errorCode = parseInt(arr[arr.length-1]);
+            if(isNaN(errorCode)) return false;
+            if(errorCode < 0) return false; //Not defined error, e.g. Rate limit (-32097)
+            return true;
+        });
+    }
+
+}
+
+export class Rpc09ChannelWithRetries extends RPC09.RpcChannel {
 
     readonly retryPolicy?: {
         maxRetries?: number, delay?: number, exponential?: boolean
@@ -33,11 +59,23 @@ export class RpcChannelWithRetries extends RpcChannel {
 
 export class RpcProviderWithRetries extends RpcProvider {
 
+    /**
+     * Tries to do naive detection of the spec version based on the suffix of nodeUrl, better pass the `specVersion`
+     *  in the options!
+     *
+     * @param options
+     * @param retryPolicy
+     */
     constructor(options?: RpcProviderOptions, retryPolicy?: {
         maxRetries?: number, delay?: number, exponential?: boolean
     }) {
+        if(options.specVersion==null) options.specVersion = options.nodeUrl.endsWith("v0_8") ? "0.8.1" : "0.9.0";
         super(options);
-        this.channel = new RpcChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+        if(this.channel.id==="RPC081") {
+            this.channel = new Rpc08ChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+        } else if(this.channel.id==="RPC090") {
+            this.channel = new Rpc09ChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+        }
     }
 
 }

package/src/starknet/swaps/StarknetSwapContract.ts

@@ -464,7 +464,7 @@ export class StarknetSwapContract
         synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>,
         initAta?: boolean,
         feeRate?: string
-    ): Promise<StarknetTx[] | null> {
+    ): Promise<StarknetTx[]> {
         return this.Claim.txsClaimWithTxData(
             typeof(signer)==="string" ? signer : signer.getAddress(),
             swapData,