@atomiqlabs/chain-starknet 8.3.0 → 8.4.1

package/dist/starknet/StarknetInitializer.js

@@ -69,7 +69,7 @@ function initializeStarknet(options, bitcoinRpc, network) {
     const Fees = options.fees ?? new StarknetFees_1.StarknetFees(provider);
     const chainId = options.chainId ??
         (network === base_1.BitcoinNetwork.MAINNET ? starknet_1.constants.StarknetChainId.SN_MAIN : starknet_1.constants.StarknetChainId.SN_SEPOLIA);
-    const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, wsChannel, Fees, options.starknetConfig);
+    const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, wsChannel, Fees, options.starknetConfig, network);
     const btcRelay = new StarknetBtcRelay_1.StarknetBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract, options.btcRelayContractDeploymentHeight);
     const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract, options.handlerContracts, options.swapContractDeploymentHeight);
     const spvVaultContract = new StarknetSpvVaultContract_1.StarknetSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract, options.spvVaultContractDeploymentHeight);

package/dist/starknet/chain/StarknetChainInterface.d.ts

@@ -6,7 +6,7 @@ import { StarknetEvents } from "./modules/StarknetEvents";
 import { StarknetSignatures } from "./modules/StarknetSignatures";
 import { StarknetAccounts } from "./modules/StarknetAccounts";
 import { StarknetBlocks } from "./modules/StarknetBlocks";
-import { ChainInterface, TransactionConfirmationOptions } from "@atomiqlabs/base";
+import { BitcoinNetwork, ChainInterface, TransactionConfirmationOptions } from "@atomiqlabs/base";
 import { StarknetSigner } from "../wallet/StarknetSigner";
 /**
  * Configuration options for Starknet chain interface
@@ -64,7 +64,8 @@ export declare class StarknetChainInterface implements ChainInterface<StarknetTx
     readonly Accounts: StarknetAccounts;
     readonly Blocks: StarknetBlocks;
     readonly config: StarknetConfig;
-    constructor(chainId: constants.StarknetChainId, provider: Provider, wsChannel?: WebSocketChannel, feeEstimator?: StarknetFees, options?: StarknetConfig);
+    private readonly bitcoinNetwork?;
+    constructor(chainId: constants.StarknetChainId, provider: Provider, wsChannel?: WebSocketChannel, feeEstimator?: StarknetFees, options?: StarknetConfig, bitcoinNetwork?: BitcoinNetwork);
     /**
      * @inheritDoc
      */
@@ -137,6 +138,10 @@ export declare class StarknetChainInterface implements ChainInterface<StarknetTx
      * @inheritDoc
      */
     deserializeSignedTx(txData: string): Promise<SignedStarknetTx>;
+    /**
+     * @inheritDoc
+     */
+    getTxId(signedTX: SignedStarknetTx): Promise<string>;
     /**
      * @inheritDoc
      */
@@ -164,4 +169,5 @@ export declare class StarknetChainInterface implements ChainInterface<StarknetTx
      * @inheritDoc
      */
     wrapSigner(signer: Account): Promise<StarknetSigner>;
+    verifyNetwork(bitcoinNetwork: BitcoinNetwork): Promise<void>;
 }

package/dist/starknet/chain/StarknetChainInterface.js

@@ -11,6 +11,7 @@ const StarknetEvents_1 = require("./modules/StarknetEvents");
 const StarknetSignatures_1 = require("./modules/StarknetSignatures");
 const StarknetAccounts_1 = require("./modules/StarknetAccounts");
 const StarknetBlocks_1 = require("./modules/StarknetBlocks");
+const base_1 = require("@atomiqlabs/base");
 const StarknetSigner_1 = require("../wallet/StarknetSigner");
 const buffer_1 = require("buffer");
 const StarknetKeypairWallet_1 = require("../wallet/accounts/StarknetKeypairWallet");
@@ -21,7 +22,7 @@ const StarknetBrowserSigner_1 = require("../wallet/StarknetBrowserSigner");
  * @category Chain Interface
  */
 class StarknetChainInterface {
-    constructor(chainId, provider, wsChannel, feeEstimator = new StarknetFees_1.StarknetFees(provider), options) {
+    constructor(chainId, provider, wsChannel, feeEstimator = new StarknetFees_1.StarknetFees(provider), options, bitcoinNetwork) {
         var _a, _b, _c, _d;
         this.chainId = "STARKNET";
         this.starknetChainId = chainId;
@@ -39,6 +40,7 @@ class StarknetChainInterface {
         this.Events = new StarknetEvents_1.StarknetEvents(this);
         this.Accounts = new StarknetAccounts_1.StarknetAccounts(this);
         this.Blocks = new StarknetBlocks_1.StarknetBlocks(this);
+        this.bitcoinNetwork = bitcoinNetwork;
     }
     /**
      * @inheritDoc
@@ -154,6 +156,12 @@ class StarknetChainInterface {
     deserializeSignedTx(txData) {
         return Promise.resolve(StarknetTransactions_1.StarknetTransactions.deserializeTx(txData));
     }
+    /**
+     * @inheritDoc
+     */
+    getTxId(signedTX) {
+        return Promise.resolve(signedTX.txId ?? (0, Utils_1.calculateHash)(signedTX));
+    }
     /**
      * @inheritDoc
      */
@@ -201,5 +209,16 @@ class StarknetChainInterface {
             return Promise.resolve(new StarknetSigner_1.StarknetSigner(signer));
         }
     }
+    async verifyNetwork(bitcoinNetwork) {
+        if (this.bitcoinNetwork != null && bitcoinNetwork !== this.bitcoinNetwork)
+            throw new Error(`Network mismatch, the chain interface was not setup for ${base_1.BitcoinNetwork[bitcoinNetwork]}, chain interface network: ${base_1.BitcoinNetwork[this.bitcoinNetwork]}`);
+        const chainId = await this.provider.getChainId();
+        if (chainId !== starknet_1.constants.StarknetChainId.SN_MAIN && chainId !== starknet_1.constants.StarknetChainId.SN_SEPOLIA) {
+            starknet_1.logger.warn(`verifyNetwork(): Using non-standard chainId ${chainId}, skipping network verfication!`);
+            return;
+        }
+        if (this.starknetChainId !== chainId)
+            throw new Error(`Network mismatch, the underlying RPC provider isn't using the correct chainId, expected: ${this.starknetChainId}, provider returned: ${chainId}`);
+    }
 }
 exports.StarknetChainInterface = StarknetChainInterface;

package/dist/starknet/chain/modules/StarknetTransactions.d.ts

@@ -52,7 +52,7 @@ export type StarknetTx = StarknetTxInvoke | StarknetTxDeployAccount;
  * Represents a signed Starknet transactions, which can either be an "INVOKE" or "DEPLOY_ACCOUNT" type, use the
  *  {@link isStarknetTxInvoke} & {@link isStarknetTxDeployAccount} to narrow down the type.
  *
- * @remark For Starknet this is just an alias for {@link StarknetTx}
+ * @remarks For Starknet this is just an alias for {@link StarknetTx}
  *
  * @category Chain Interface
  */

package/dist/starknet/swaps/StarknetSwapContract.js

@@ -299,15 +299,30 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
         const escrowHash = data.getEscrowHash();
         const stateData = await this.contract.get_hash_state("0x" + escrowHash);
         const state = Number(stateData.state);
+        const initBlockHeight = Number(stateData.init_blockheight);
         const blockHeight = Number(stateData.finish_blockheight);
+        const getInitTxId = async () => {
+            const events = await this._Events.getContractBlockEvents(["escrow_manager::events::Initialize"], [null, null, null, "0x" + escrowHash], initBlockHeight, initBlockHeight);
+            if (events.length === 0)
+                throw new Error("Initialize event not found!");
+            return events[0].txHash;
+        };
         switch (state) {
             case ESCROW_STATE_COMMITTED:
-                if (data.isOfferer(signer) && await this.isExpired(signer, data))
-                    return { type: base_1.SwapCommitStateType.REFUNDABLE };
-                return { type: base_1.SwapCommitStateType.COMMITED };
+                if (data.isOfferer(signer) && await this.isExpired(signer, data)) {
+                    return {
+                        type: base_1.SwapCommitStateType.REFUNDABLE,
+                        getInitTxId
+                    };
+                }
+                return {
+                    type: base_1.SwapCommitStateType.COMMITED,
+                    getInitTxId
+                };
             case ESCROW_STATE_CLAIMED:
                 return {
                     type: base_1.SwapCommitStateType.PAID,
+                    getInitTxId,
                     getTxBlock: async () => {
                         return {
                             blockTime: await this.Chain.Blocks.getBlockTime(blockHeight),
@@ -336,6 +351,7 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
             case ESCROW_STATE_REFUNDED:
                 return {
                     type: await this.isExpired(signer, data) ? base_1.SwapCommitStateType.EXPIRED : base_1.SwapCommitStateType.NOT_COMMITED,
+                    getInitTxId,
                     getTxBlock: async () => {
                         return {
                             blockTime: await this.Chain.Blocks.getBlockTime(blockHeight),
@@ -435,6 +451,7 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
                         },
                         state: {
                             type: base_1.SwapCommitStateType.PAID,
+                            getInitTxId: foundSwapData?.getInitTxId,
                             getClaimTxId: () => Promise.resolve(event.txHash),
                             getClaimResult: () => Promise.resolve(claimHandler.parseWitnessResult(event.params.witness_result)),
                             getTxBlock: async () => {
@@ -462,6 +479,7 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
                         },
                         state: {
                             type: isExpired ? base_1.SwapCommitStateType.EXPIRED : base_1.SwapCommitStateType.NOT_COMMITED,
+                            getInitTxId: foundSwapData?.getInitTxId,
                             getRefundTxId: () => Promise.resolve(event.txHash),
                             getTxBlock: async () => {
                                 return {
@@ -489,8 +507,8 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
                     getTxBlock: foundSwapData.getTxBlock
                 },
                 state: data.isOfferer(signer) && await this.isExpired(signer, data)
-                    ? { type: base_1.SwapCommitStateType.REFUNDABLE }
-                    : { type: base_1.SwapCommitStateType.COMMITED }
+                    ? { type: base_1.SwapCommitStateType.REFUNDABLE, getInitTxId: foundSwapData.getInitTxId }
+                    : { type: base_1.SwapCommitStateType.COMMITED, getInitTxId: foundSwapData.getInitTxId }
             };
         }
         await Promise.all(promises);

package/dist/utils/Utils.js

@@ -311,7 +311,7 @@ function replaceBigInts(obj) {
         if (Array.isArray(value)) {
             return value.map(replace);
         }
-        const mapped = Object.create(Object.getPrototypeOf(value));
+        const mapped = {};
         for (const key of Object.keys(value)) {
             mapped[key] = replace(value[key]);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "8.3.0",
+  "version": "8.4.1",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -31,7 +31,7 @@
     "url": "git+https://github.com/atomiqlabs/atomiq-chain-starknet.git"
   },
   "dependencies": {
-    "@atomiqlabs/base": "^13.3.0",
+    "@atomiqlabs/base": "^13.4.2",
     "@noble/hashes": "^1.7.1",
     "@scure/btc-signer": "^1.6.0",
     "abi-wan-kanabi": "2.2.4",

package/src/starknet/StarknetInitializer.ts

@@ -152,7 +152,7 @@ export function initializeStarknet(
     const chainId = options.chainId ??
         (network===BitcoinNetwork.MAINNET ? constants.StarknetChainId.SN_MAIN : constants.StarknetChainId.SN_SEPOLIA);
 
-    const chainInterface = new StarknetChainInterface(chainId, provider, wsChannel, Fees, options.starknetConfig);
+    const chainInterface = new StarknetChainInterface(chainId, provider, wsChannel, Fees, options.starknetConfig, network);
 
     const btcRelay = new StarknetBtcRelay(
         chainInterface, bitcoinRpc, network, options.btcRelayContract, options.btcRelayContractDeploymentHeight

package/src/starknet/chain/StarknetChainInterface.ts

@@ -1,5 +1,5 @@
-import {Provider, constants, stark, ec, Account, provider, wallet, WebSocketChannel} from "starknet";
-import {getLogger, toHex} from "../../utils/Utils";
+import {Provider, constants, stark, ec, Account, provider, wallet, WebSocketChannel, logger} from "starknet";
+import {calculateHash, getLogger, toHex} from "../../utils/Utils";
 import {SignedStarknetTx, StarknetTransactions, StarknetTx} from "./modules/StarknetTransactions";
 import {StarknetFees} from "./modules/StarknetFees";
 import {StarknetAddresses} from "./modules/StarknetAddresses";
@@ -8,7 +8,7 @@ import {StarknetEvents} from "./modules/StarknetEvents";
 import {StarknetSignatures} from "./modules/StarknetSignatures";
 import {StarknetAccounts} from "./modules/StarknetAccounts";
 import {StarknetBlocks} from "./modules/StarknetBlocks";
-import {ChainInterface, TransactionConfirmationOptions} from "@atomiqlabs/base";
+import {BitcoinNetwork, ChainInterface, TransactionConfirmationOptions} from "@atomiqlabs/base";
 import {StarknetSigner} from "../wallet/StarknetSigner";
 import {Buffer} from "buffer";
 import {StarknetKeypairWallet} from "../wallet/accounts/StarknetKeypairWallet";
@@ -76,12 +76,15 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Signed
 
     public readonly config: StarknetConfig;
 
+    private readonly bitcoinNetwork?: BitcoinNetwork;
+
     constructor(
         chainId: constants.StarknetChainId,
         provider: Provider,
         wsChannel?: WebSocketChannel,
         feeEstimator: StarknetFees = new StarknetFees(provider),
-        options?: StarknetConfig
+        options?: StarknetConfig,
+        bitcoinNetwork?: BitcoinNetwork
     ) {
         this.starknetChainId = chainId;
         this.provider = provider;
@@ -100,6 +103,8 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Signed
         this.Events = new StarknetEvents(this);
         this.Accounts = new StarknetAccounts(this);
         this.Blocks = new StarknetBlocks(this);
+
+        this.bitcoinNetwork = bitcoinNetwork;
     }
 
     /**
@@ -247,6 +252,13 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Signed
         return Promise.resolve(StarknetTransactions.deserializeTx(txData));
     }
 
+    /**
+     * @inheritDoc
+     */
+    getTxId(signedTX: SignedStarknetTx): Promise<string> {
+        return Promise.resolve(signedTX.txId ?? calculateHash(signedTX));
+    }
+
     /**
      * @inheritDoc
      */
@@ -305,4 +317,18 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Signed
         }
     }
 
+    async verifyNetwork(bitcoinNetwork: BitcoinNetwork): Promise<void> {
+        if(this.bitcoinNetwork!=null && bitcoinNetwork!==this.bitcoinNetwork)
+            throw new Error(`Network mismatch, the chain interface was not setup for ${BitcoinNetwork[bitcoinNetwork]}, chain interface network: ${BitcoinNetwork[this.bitcoinNetwork]}`);
+
+        const chainId = await this.provider.getChainId();
+        if(chainId!==constants.StarknetChainId.SN_MAIN && chainId!==constants.StarknetChainId.SN_SEPOLIA) {
+            logger.warn(`verifyNetwork(): Using non-standard chainId ${chainId}, skipping network verfication!`);
+            return;
+        }
+
+        if(this.starknetChainId!==chainId)
+            throw new Error(`Network mismatch, the underlying RPC provider isn't using the correct chainId, expected: ${this.starknetChainId}, provider returned: ${chainId}`);
+    }
+
 }

package/src/starknet/chain/modules/StarknetTransactions.ts

@@ -97,7 +97,7 @@ export type StarknetTx = StarknetTxInvoke | StarknetTxDeployAccount;
  * Represents a signed Starknet transactions, which can either be an "INVOKE" or "DEPLOY_ACCOUNT" type, use the
  *  {@link isStarknetTxInvoke} & {@link isStarknetTxDeployAccount} to narrow down the type.
  *
- * @remark For Starknet this is just an alias for {@link StarknetTx}
+ * @remarks For Starknet this is just an alias for {@link StarknetTx}
  *
  * @category Chain Interface
  */

package/src/starknet/swaps/StarknetSwapContract.ts

@@ -375,14 +375,35 @@ export class StarknetSwapContract
         const escrowHash = data.getEscrowHash();
         const stateData = await this.contract.get_hash_state("0x"+escrowHash);
         const state = Number(stateData.state);
+        const initBlockHeight = Number(stateData.init_blockheight);
         const blockHeight = Number(stateData.finish_blockheight);
+
+        const getInitTxId = async () => {
+            const events = await this._Events.getContractBlockEvents(
+                ["escrow_manager::events::Initialize"],
+                [null, null, null, "0x"+escrowHash],
+                initBlockHeight, initBlockHeight
+            );
+            if(events.length===0) throw new Error("Initialize event not found!");
+            return events[0].txHash;
+        }
+
         switch(state) {
             case ESCROW_STATE_COMMITTED:
-                if(data.isOfferer(signer) && await this.isExpired(signer,data)) return {type: SwapCommitStateType.REFUNDABLE};
-                return {type: SwapCommitStateType.COMMITED};
+                if(data.isOfferer(signer) && await this.isExpired(signer,data)) {
+                    return {
+                        type: SwapCommitStateType.REFUNDABLE,
+                        getInitTxId
+                    };
+                }
+                return {
+                    type: SwapCommitStateType.COMMITED,
+                    getInitTxId
+                };
             case ESCROW_STATE_CLAIMED:
                 return {
                     type: SwapCommitStateType.PAID,
+                    getInitTxId,
                     getTxBlock: async () => {
                         return {
                             blockTime: await this.Chain.Blocks.getBlockTime(blockHeight),
@@ -417,6 +438,7 @@ export class StarknetSwapContract
             case ESCROW_STATE_REFUNDED:
                 return {
                     type: await this.isExpired(signer, data) ? SwapCommitStateType.EXPIRED : SwapCommitStateType.NOT_COMMITED,
+                    getInitTxId,
                     getTxBlock: async () => {
                         return {
                             blockTime: await this.Chain.Blocks.getBlockTime(blockHeight),
@@ -563,6 +585,7 @@ export class StarknetSwapContract
                         },
                         state: {
                             type: SwapCommitStateType.PAID,
+                            getInitTxId: foundSwapData?.getInitTxId,
                             getClaimTxId: () => Promise.resolve(event.txHash),
                             getClaimResult: () => Promise.resolve(claimHandler.parseWitnessResult(event.params.witness_result)),
                             getTxBlock: async () => {
@@ -590,6 +613,7 @@ export class StarknetSwapContract
                         },
                         state: {
                             type: isExpired ? SwapCommitStateType.EXPIRED : SwapCommitStateType.NOT_COMMITED,
+                            getInitTxId: foundSwapData?.getInitTxId,
                             getRefundTxId: () => Promise.resolve(event.txHash),
                             getTxBlock: async () => {
                                 return {
@@ -628,8 +652,8 @@ export class StarknetSwapContract
                     getTxBlock: foundSwapData.getTxBlock
                 },
                 state: data.isOfferer(signer) && await this.isExpired(signer, data)
-                    ? {type: SwapCommitStateType.REFUNDABLE}
-                    : {type: SwapCommitStateType.COMMITED}
+                    ? {type: SwapCommitStateType.REFUNDABLE, getInitTxId: foundSwapData.getInitTxId}
+                    : {type: SwapCommitStateType.COMMITED, getInitTxId: foundSwapData.getInitTxId}
             }
         }