@atomiqlabs/chain-starknet 1.0.2 → 1.0.4

package/dist/starknet/StarknetInitializer.d.ts

@@ -3,7 +3,7 @@ import { StarknetFees } from "./base/modules/StarknetFees";
 import { StarknetRetryPolicy } from "./base/StarknetBase";
 import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer } from "@atomiqlabs/base";
 import { StarknetChainType } from "./StarknetChainType";
-export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK">;
+export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC">;
 export declare const StarknetAssets: StarknetAssetsType;
 export type StarknetOptions = {
     rpcUrl: string | Provider;

package/dist/starknet/StarknetInitializer.js

@@ -18,6 +18,10 @@ exports.StarknetAssets = {
         address: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
         decimals: 18,
         displayDecimals: 9
+    },
+    WBTC: {
+        address: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
+        decimals: 8
     }
 };
 function initializeStarknet(options, bitcoinRpc, network) {

package/dist/starknet/base/modules/StarknetSignatures.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Buffer } from "buffer";
 import { StarknetModule } from "../StarknetModule";
 import { StarknetSigner } from "../../wallet/StarknetSigner";

package/dist/starknet/base/modules/StarknetSignatures.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetSignatures = void 0;
-const createHash = require("create-hash");
+const buffer_1 = require("buffer");
 const StarknetModule_1 = require("../StarknetModule");
 const starknet_1 = require("starknet");
 const Utils_1 = require("../../../utils/Utils");
+const sha2_1 = require("@noble/hashes/sha2");
 const StarknetDomain = [
     { name: 'name', type: 'shortstring' },
     { name: 'version', type: 'shortstring' },
@@ -52,7 +53,7 @@ class StarknetSignatures extends StarknetModule_1.StarknetModule {
      * @param data data to sign
      */
     getDataSignature(signer, data) {
-        const buff = createHash("sha256").update(data).digest();
+        const buff = buffer_1.Buffer.from((0, sha2_1.sha256)(data));
         return this.signTypedMessage(signer, DataHash, 'DataHash', { "Data hash": starknet_1.cairo.uint256((0, Utils_1.toHex)(buff)) });
     }
     /**
@@ -64,7 +65,7 @@ class StarknetSignatures extends StarknetModule_1.StarknetModule {
      * @param address public key of the signer
      */
     isValidDataSignature(data, signature, address) {
-        const buff = createHash("sha256").update(data).digest();
+        const buff = buffer_1.Buffer.from((0, sha2_1.sha256)(data));
         return this.isValidSignature(signature, address, DataHash, 'DataHash', { "Data hash": starknet_1.cairo.uint256((0, Utils_1.toHex)(buff)) });
     }
 }

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Buffer } from "buffer";
 import { StarknetBtcHeader } from "./headers/StarknetBtcHeader";
 import { BitcoinRpc, BtcBlock, BtcRelay } from "@atomiqlabs/base";

package/dist/starknet/btcrelay/headers/StarknetBtcHeader.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { BtcHeader } from "@atomiqlabs/base";
 import { Buffer } from "buffer";
 import { BigNumberish } from "starknet";

package/dist/starknet/btcrelay/headers/StarknetBtcHeader.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetBtcHeader = void 0;
 const buffer_1 = require("buffer");
 const Utils_1 = require("../../../utils/Utils");
-const createHash = require("create-hash");
+const sha2_1 = require("@noble/hashes/sha2");
 class StarknetBtcHeader {
     constructor(obj) {
         this.reversed_version = Number(obj.reversed_version);
@@ -36,13 +36,13 @@ class StarknetBtcHeader {
         if (this.hash != null)
             return this.hash;
         const buffer = buffer_1.Buffer.alloc(80);
-        buffer.writeUInt32BE(this.reversed_version);
+        buffer.writeUInt32BE(this.reversed_version, 0);
         (0, Utils_1.u32ArrayToBuffer)(this.previous_blockhash).copy(buffer, 4);
         (0, Utils_1.u32ArrayToBuffer)(this.merkle_root).copy(buffer, 36);
         buffer.writeUInt32BE(this.reversed_timestamp, 68);
         buffer.writeUInt32BE(this.nbits, 72);
         buffer.writeUInt32BE(this.nonce, 76);
-        return createHash("sha256").update(createHash("sha256").update(buffer).digest()).digest();
+        return buffer_1.Buffer.from((0, sha2_1.sha256)((0, sha2_1.sha256)(buffer)));
     }
     serialize() {
         return [

package/dist/starknet/btcrelay/headers/StarknetBtcStoredHeader.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { BtcStoredHeader } from "@atomiqlabs/base";
 import { StarknetBtcHeader, StarknetBtcHeaderType } from "./StarknetBtcHeader";
 import { Buffer } from "buffer";

package/dist/starknet/events/StarknetChainEvents.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetChainEvents = void 0;
 const StarknetChainEventsBrowser_1 = require("./StarknetChainEventsBrowser");
+//@ts-ignore
 const fs = require("fs/promises");
 const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
 class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEventsBrowser {

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { ChainSwapType, IntermediaryReputationType, RelaySynchronizer, SignatureData, SwapCommitStatus, SwapContract, TransactionConfirmationOptions } from "@atomiqlabs/base";
 import { Buffer } from "buffer";
 import { EscrowManagerAbi } from "./EscrowManagerAbi";

package/dist/starknet/swaps/StarknetSwapContract.js

@@ -17,7 +17,7 @@ const StarknetSwapInit_1 = require("./modules/StarknetSwapInit");
 const StarknetSwapRefund_1 = require("./modules/StarknetSwapRefund");
 const ClaimHandlers_1 = require("./handlers/claim/ClaimHandlers");
 const StarknetSwapClaim_1 = require("./modules/StarknetSwapClaim");
-const createHash = require("create-hash");
+const sha2_1 = require("@noble/hashes/sha2");
 const ESCROW_STATE_COMMITTED = 1;
 const ESCROW_STATE_CLAIMED = 2;
 const ESCROW_STATE_REFUNDED = 3;
@@ -216,10 +216,10 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
     getExtraData(outputScript, amount, confirmations, nonce) {
         if (nonce == null)
             nonce = 0n;
-        const txoHash = createHash("sha256").update(buffer_1.Buffer.concat([
+        const txoHash = buffer_1.Buffer.from((0, sha2_1.sha256)(buffer_1.Buffer.concat([
             base_1.BigIntBufferUtils.toBuffer(amount, "le", 8),
             outputScript
-        ])).digest();
+        ])));
         return buffer_1.Buffer.concat([
             txoHash,
             base_1.BigIntBufferUtils.toBuffer(nonce, "be", 8),

package/dist/starknet/swaps/handlers/claim/HashlockClaimHandler.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { StarknetSwapData } from "../../StarknetSwapData";
 import { BigNumberish } from "starknet";
 import { ChainSwapType } from "@atomiqlabs/base";

package/dist/starknet/swaps/handlers/claim/HashlockClaimHandler.js

@@ -5,7 +5,7 @@ const Utils_1 = require("../../../../utils/Utils");
 const starknet_1 = require("starknet");
 const base_1 = require("@atomiqlabs/base");
 const buffer_1 = require("buffer");
-const createHash = require("create-hash");
+const sha2_1 = require("@noble/hashes/sha2");
 class HashlockClaimHandler {
     constructor(address) {
         this.address = address;
@@ -23,7 +23,7 @@ class HashlockClaimHandler {
         const buffer = buffer_1.Buffer.from(witnessData, "hex");
         if (buffer.length !== 32)
             throw new Error("Invalid hash secret: buff length");
-        const witnessSha256 = createHash("sha256").update(buffer).digest();
+        const witnessSha256 = buffer_1.Buffer.from((0, sha2_1.sha256)(buffer));
         if (!data.isClaimData((0, Utils_1.toHex)(this.getCommitment(witnessSha256))))
             throw new Error("Invalid hash secret: poseidon hash doesn't match");
         const witnessArray = (0, Utils_1.bufferToU32Array)(buffer);

package/dist/starknet/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { StarknetSwapData } from "../../../StarknetSwapData";
 import { StarknetGas } from "../../../../base/StarknetAction";
 import { ChainSwapType } from "@atomiqlabs/base";

package/dist/starknet/swaps/handlers/claim/btc/BitcoinOutputClaimHandler.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { StarknetSwapData } from "../../../StarknetSwapData";
 import { StarknetGas } from "../../../../base/StarknetAction";
 import { ChainSwapType } from "@atomiqlabs/base";

package/dist/starknet/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler.js

@@ -4,11 +4,12 @@ exports.BitcoinTxIdClaimHandler = void 0;
 const base_1 = require("@atomiqlabs/base");
 const Utils_1 = require("../../../../../utils/Utils");
 const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
+const buffer_1 = require("buffer");
 const logger = (0, Utils_1.getLogger)("BitcoinTxIdClaimHandler: ");
 class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler_1.IBitcoinClaimHandler {
     serializeCommitment(data) {
         return [
-            ...(0, Utils_1.bufferToU32Array)(Buffer.from(data.txId, "hex").reverse()),
+            ...(0, Utils_1.bufferToU32Array)(buffer_1.Buffer.from(data.txId, "hex").reverse()),
             ...super.serializeCommitment(data)
         ];
     }

package/dist/starknet/swaps/handlers/refund/TimelockRefundHandler.js

@@ -20,7 +20,7 @@ class TimelockRefundHandler {
         return TimelockRefundHandler.gas;
     }
     static getExpiry(data) {
-        return (0, Utils_1.bigNumberishToBuffer)(data.refundData, 32).readBigUInt64BE(24);
+        return (0, Utils_1.bigNumberishToBuffer)(data.refundData, 32).readBigUInt64BE(24).valueOf();
     }
 }
 exports.TimelockRefundHandler = TimelockRefundHandler;

package/dist/utils/Utils.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { BigNumberish, Uint256 } from "starknet";
 import { StarknetTx } from "../starknet/base/modules/StarknetTransactions";
 import { Buffer } from "buffer";

package/dist/utils/Utils.js

@@ -164,7 +164,7 @@ function bigNumberishToBuffer(value, length) {
     }
     const buff = buffer_1.Buffer.from(value.padStart(length * 2, "0"), "hex");
     if (buff.length > length)
-        return buff.subarray(buff.length - length);
+        return buff.slice(buff.length - length);
     return buff;
 }
 exports.bigNumberishToBuffer = bigNumberishToBuffer;
@@ -204,22 +204,22 @@ exports.bytes31SpanToBuffer = bytes31SpanToBuffer;
 function bufferToBytes31Span(buffer, startIndex = 0, endIndex = buffer.length) {
     const values = [];
     for (let i = startIndex + 31; i < endIndex; i += 31) {
-        values.push(BigInt("0x" + buffer.subarray(i - 31, i).toString("hex")));
+        values.push(BigInt("0x" + buffer.slice(i - 31, i).toString("hex")));
     }
     if (endIndex > startIndex + (values.length * 31))
-        values.push(BigInt("0x" + buffer.subarray(startIndex + (values.length * 31), endIndex).toString("hex")));
+        values.push(BigInt("0x" + buffer.slice(startIndex + (values.length * 31), endIndex).toString("hex")));
     return values;
 }
 exports.bufferToBytes31Span = bufferToBytes31Span;
 function bufferToByteArray(buffer, startIndex = 0, endIndex = buffer.length) {
     const values = [];
     for (let i = startIndex + 31; i < endIndex; i += 31) {
-        values.push(BigInt("0x" + buffer.subarray(i - 31, i).toString("hex")));
+        values.push(BigInt("0x" + buffer.slice(i - 31, i).toString("hex")));
     }
     let pendingWord = BigInt(0);
     let pendingWordLen = BigInt(endIndex - (startIndex + (values.length * 31)));
     if (pendingWordLen !== BigInt(0)) {
-        pendingWord = BigInt("0x" + buffer.subarray(startIndex + (values.length * 31), endIndex).toString("hex"));
+        pendingWord = BigInt("0x" + buffer.slice(startIndex + (values.length * 31), endIndex).toString("hex"));
     }
     return [
         BigInt(values.length),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -23,17 +23,15 @@
   "license": "ISC",
   "dependencies": {
     "@atomiqlabs/base": "^8.0.0",
+    "@noble/hashes": "^1.7.1",
     "@scure/btc-signer": "1.6.0",
     "abi-wan-kanabi": "2.2.4",
-    "buffer": "6.0.3",
-    "create-hash": "1.2.0",
-    "randombytes": "2.1.0"
+    "buffer": "6.0.3"
   },
   "peerDependencies": {
     "starknet": "^6.11.0"
   },
   "devDependencies": {
-    "@types/create-hash": "1.2.6",
     "typescript": "4.9.5"
   }
 }

package/src/starknet/StarknetInitializer.ts

@@ -8,7 +8,7 @@ import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer}
 import {StarknetChainType} from "./StarknetChainType";
 import {StarknetSwapData} from "./swaps/StarknetSwapData";
 
-export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK">;
+export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC">;
 export const StarknetAssets: StarknetAssetsType = {
     ETH: {
         address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
@@ -19,6 +19,10 @@ export const StarknetAssets: StarknetAssetsType = {
         address: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
         decimals: 18,
         displayDecimals: 9
+    },
+    WBTC: {
+        address: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
+        decimals: 8
     }
 } as const;
 

package/src/starknet/base/modules/StarknetSignatures.ts

@@ -1,4 +1,3 @@
-import * as createHash from "create-hash";
 import {Buffer} from "buffer";
 import {StarknetModule} from "../StarknetModule";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
@@ -11,6 +10,7 @@ import {
 } from "starknet";
 import {StarknetBase} from "../StarknetBase";
 import {toHex} from "../../../utils/Utils";
+import {sha256} from "@noble/hashes/sha2";
 
 const StarknetDomain = [
     { name: 'name', type: 'shortstring' },
@@ -71,7 +71,7 @@ export class StarknetSignatures extends StarknetModule {
      * @param data data to sign
      */
     public getDataSignature(signer: StarknetSigner, data: Buffer): Promise<string> {
-        const buff = createHash("sha256").update(data).digest();
+        const buff = Buffer.from(sha256(data));
         return this.signTypedMessage(signer, DataHash, 'DataHash', {"Data hash": cairo.uint256(toHex(buff))});
     }
 
@@ -84,7 +84,7 @@ export class StarknetSignatures extends StarknetModule {
      * @param address public key of the signer
      */
     public isValidDataSignature(data: Buffer, signature: string, address: string): Promise<boolean> {
-        const buff = createHash("sha256").update(data).digest();
+        const buff = Buffer.from(sha256(data));
         return this.isValidSignature(signature, address, DataHash, 'DataHash', {"Data hash": cairo.uint256(toHex(buff))});
     }
 

package/src/starknet/btcrelay/headers/StarknetBtcHeader.ts

@@ -2,7 +2,7 @@ import {BtcHeader} from "@atomiqlabs/base";
 import {Buffer} from "buffer";
 import {BigNumberish} from "starknet";
 import {toHex, u32ArrayToBuffer, u32ReverseEndianness} from "../../../utils/Utils";
-import * as createHash from "create-hash";
+import {sha256} from "@noble/hashes/sha2";
 
 export type StarknetBtcHeaderType = {
     reversed_version: BigNumberish;
@@ -61,13 +61,13 @@ export class StarknetBtcHeader implements BtcHeader {
     getHash(): Buffer {
         if(this.hash!=null) return this.hash;
         const buffer = Buffer.alloc(80);
-        buffer.writeUInt32BE(this.reversed_version);
+        buffer.writeUInt32BE(this.reversed_version, 0);
         u32ArrayToBuffer(this.previous_blockhash).copy(buffer, 4);
         u32ArrayToBuffer(this.merkle_root).copy(buffer, 36);
         buffer.writeUInt32BE(this.reversed_timestamp, 68);
         buffer.writeUInt32BE(this.nbits, 72);
         buffer.writeUInt32BE(this.nonce, 76);
-        return createHash("sha256").update(createHash("sha256").update(buffer).digest()).digest();
+        return Buffer.from(sha256(sha256(buffer)));
     }
 
     serialize(): BigNumberish[] {

package/src/starknet/events/StarknetChainEvents.ts

@@ -1,4 +1,5 @@
 import {StarknetChainEventsBrowser} from "./StarknetChainEventsBrowser";
+//@ts-ignore
 import * as fs from "fs/promises";
 import {StarknetSwapContract} from "../swaps/StarknetSwapContract";
 

package/src/starknet/events/StarknetChainEventsBrowser.ts

@@ -50,7 +50,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
     protected stopped: boolean;
     protected pollIntervalSeconds: number;
 
-    private timeout: NodeJS.Timeout;
+    private timeout: number;
 
     constructor(starknetSwapContract: StarknetSwapContract, pollIntervalSeconds: number = 5) {
         this.provider = starknetSwapContract.provider;

package/src/starknet/swaps/StarknetSwapContract.ts

@@ -28,7 +28,7 @@ import {claimHandlersList, IClaimHandler} from "./handlers/claim/ClaimHandlers";
 import {StarknetSwapClaim} from "./modules/StarknetSwapClaim";
 import {IHandler} from "./handlers/IHandler";
 import {StarknetBtcStoredHeader} from "../btcrelay/headers/StarknetBtcStoredHeader";
-import * as createHash from "create-hash";
+import {sha256} from "@noble/hashes/sha2";
 
 const ESCROW_STATE_COMMITTED = 1;
 const ESCROW_STATE_CLAIMED = 2;
@@ -285,10 +285,10 @@ export class StarknetSwapContract
 
     getExtraData(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer {
         if(nonce==null) nonce = 0n;
-        const txoHash = createHash("sha256").update(Buffer.concat([
+        const txoHash = Buffer.from(sha256(Buffer.concat([
             BigIntBufferUtils.toBuffer(amount, "le", 8),
             outputScript
-        ])).digest();
+        ])));
         return Buffer.concat([
             txoHash,
             BigIntBufferUtils.toBuffer(nonce, "be", 8),

package/src/starknet/swaps/handlers/claim/HashlockClaimHandler.ts

@@ -4,7 +4,7 @@ import {BigNumberish, hash} from "starknet";
 import {ChainSwapType} from "@atomiqlabs/base";
 import {StarknetGas} from "../../../base/StarknetAction";
 import {Buffer} from "buffer";
-import * as createHash from "create-hash";
+import {sha256} from "@noble/hashes/sha2";
 import {StarknetTx} from "../../../base/modules/StarknetTransactions";
 import {IClaimHandler} from "./ClaimHandlers";
 
@@ -32,7 +32,7 @@ export class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
         const buffer = Buffer.from(witnessData, "hex");
         if(buffer.length!==32) throw new Error("Invalid hash secret: buff length");
 
-        const witnessSha256 = createHash("sha256").update(buffer).digest()
+        const witnessSha256 = Buffer.from(sha256(buffer));
         if(!data.isClaimData(toHex(this.getCommitment(witnessSha256)))) throw new Error("Invalid hash secret: poseidon hash doesn't match");
 
         const witnessArray = bufferToU32Array(buffer);

package/src/starknet/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler.ts

@@ -5,6 +5,7 @@ import {BigNumberish} from "starknet";
 import {StarknetTx} from "../../../../base/modules/StarknetTransactions";
 import {bufferToU32Array, getLogger} from "../../../../../utils/Utils";
 import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
+import {Buffer} from "buffer";
 
 export type BitcoinTxIdCommitmentData = {
     txId: string

package/src/starknet/swaps/handlers/refund/TimelockRefundHandler.ts

@@ -33,7 +33,7 @@ export class TimelockRefundHandler implements IHandler<bigint, never> {
     }
 
     public static getExpiry(data: StarknetSwapData): bigint {
-        return bigNumberishToBuffer(data.refundData, 32).readBigUInt64BE(24);
+        return bigNumberishToBuffer(data.refundData, 32).readBigUInt64BE(24).valueOf();
     }
 
 }

package/src/utils/Utils.ts

@@ -164,7 +164,7 @@ export function bigNumberishToBuffer(value: BigNumberish | Uint256, length: numb
         value = value.toString(16);
     }
     const buff = Buffer.from(value.padStart(length*2, "0"), "hex");
-    if(buff.length > length) return buff.subarray(buff.length-length);
+    if(buff.length > length) return buff.slice(buff.length-length);
     return buff;
 }
 
@@ -200,21 +200,21 @@ export function bytes31SpanToBuffer(span: BigNumberish[], length: number): Buffe
 export function bufferToBytes31Span(buffer: Buffer, startIndex: number = 0, endIndex: number = buffer.length): BigNumberish[] {
     const values: BigNumberish[] = [];
     for(let i=startIndex+31;i<endIndex;i+=31) {
-        values.push(BigInt("0x"+buffer.subarray(i-31, i).toString("hex")));
+        values.push(BigInt("0x"+buffer.slice(i-31, i).toString("hex")));
     }
-    if(endIndex > startIndex + (values.length*31)) values.push(BigInt("0x"+buffer.subarray(startIndex + (values.length*31), endIndex).toString("hex")));
+    if(endIndex > startIndex + (values.length*31)) values.push(BigInt("0x"+buffer.slice(startIndex + (values.length*31), endIndex).toString("hex")));
     return values;
 }
 
 export function bufferToByteArray(buffer: Buffer, startIndex: number = 0, endIndex: number = buffer.length): BigNumberish[] {
     const values: BigNumberish[] = [];
     for(let i=startIndex+31;i<endIndex;i+=31) {
-        values.push(BigInt("0x"+buffer.subarray(i-31, i).toString("hex")));
+        values.push(BigInt("0x"+buffer.slice(i-31, i).toString("hex")));
     }
     let pendingWord: BigNumberish = BigInt(0);
     let pendingWordLen: BigNumberish = BigInt(endIndex - (startIndex + (values.length*31)));
     if(pendingWordLen !== BigInt(0)) {
-        pendingWord = BigInt("0x"+buffer.subarray(startIndex + (values.length*31), endIndex).toString("hex"));
+        pendingWord = BigInt("0x"+buffer.slice(startIndex + (values.length*31), endIndex).toString("hex"));
     }
     return [
         BigInt(values.length),

package/dist/get_serialized_block.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/get_serialized_block.js

@@ -1,28 +0,0 @@
-"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 });
-const Utils_1 = require("./utils/Utils");
-const buffer_1 = require("buffer");
-const StarknetBtcHeader_1 = require("./starknet/btcrelay/headers/StarknetBtcHeader");
-function main() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const blockheader = new StarknetBtcHeader_1.StarknetBtcHeader({
-            reversed_version: (0, Utils_1.u32ReverseEndianness)(e.getVersion()),
-            previous_blockhash: (0, Utils_1.bufferToU32Array)(buffer_1.Buffer.from(e.getPrevBlockhash(), "hex").reverse()),
-            merkle_root: (0, Utils_1.bufferToU32Array)(buffer_1.Buffer.from(e.getMerkleRoot(), "hex").reverse()),
-            reversed_timestamp: (0, Utils_1.u32ReverseEndianness)(e.getTimestamp()),
-            nbits: (0, Utils_1.u32ReverseEndianness)(e.getNbits()),
-            nonce: (0, Utils_1.u32ReverseEndianness)(e.getNonce()),
-            hash: buffer_1.Buffer.from(e.getHash(), "hex").reverse()
-        });
-    });
-}
-main();

package/dist/starknet/swaps/modules/SwapClaim.d.ts

@@ -1,54 +0,0 @@
-import { RelaySynchronizer } from "@atomiqlabs/base";
-import * as BN from "bn.js";
-import { StarknetSwapModule } from "../StarknetSwapModule";
-import { StarknetSwapData } from "../StarknetSwapData";
-import { StarknetTx } from "../../base/modules/StarknetTransactions";
-import { StarknetBtcStoredHeader } from "../../btcrelay/headers/StarknetBtcStoredHeader";
-export declare class SwapClaim extends StarknetSwapModule {
-    private static readonly GasCosts;
-    /**
-     * Claim action which uses the provided witness for claiming the swap
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param claimHandlerGas
-     * @constructor
-     * @private
-     */
-    private Claim;
-    /**
-     * Creates transactions claiming the swap using a secret (for HTLC swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param secret hex encoded secret pre-image to the HTLC hash
-     * @param checkExpiry whether to check if the swap is already expired (trying to claim an expired swap with a secret
-     *  is dangerous because we might end up revealing the secret to the counterparty without being able to claim the swap)
-     * @param feeRate fee rate to use for the transaction
-     */
-    txsClaimWithSecret(signer: string, swapData: StarknetSwapData, secret: string, checkExpiry?: boolean, feeRate?: string): Promise<StarknetTx[]>;
-    /**
-     * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param tx bitcoin transaction that satisfies the swap condition
-     * @param requiredConfirmations
-     * @param vout vout of the bitcoin transaction that satisfies the swap condition
-     * @param commitedHeader commited header data from btc relay (fetched internally if null)
-     * @param synchronizer optional synchronizer to use in case we need to sync up the btc relay ourselves
-     * @param feeRate fee rate to be used for the transactions
-     */
-    txsClaimWithTxData(signer: string, swapData: StarknetSwapData, tx: {
-        blockhash: string;
-        confirmations: number;
-        txid: string;
-        hex: string;
-        height: number;
-    }, requiredConfirmations: number, vout: number, commitedHeader?: StarknetBtcStoredHeader, synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, feeRate?: string): Promise<StarknetTx[] | null>;
-    /**
-     * Get the estimated starknet transaction fee of the claim transaction
-     */
-    getClaimFee(swapData: StarknetSwapData, feeRate?: string): Promise<BN>;
-}

package/dist/starknet/swaps/modules/SwapClaim.js

@@ -1,115 +0,0 @@
-"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.SwapClaim = void 0;
-const base_1 = require("@atomiqlabs/base");
-const Utils_1 = require("../../../utils/Utils");
-const StarknetSwapModule_1 = require("../StarknetSwapModule");
-const StarknetAction_1 = require("../../base/StarknetAction");
-const StarknetFees_1 = require("../../base/modules/StarknetFees");
-class SwapClaim extends StarknetSwapModule_1.StarknetSwapModule {
-    /**
-     * Claim action which uses the provided witness for claiming the swap
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param claimHandlerGas
-     * @constructor
-     * @private
-     */
-    Claim(signer, swapData, witness, claimHandlerGas) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.contract.populateTransaction.claim(swapData.toEscrowStruct(), witness), (0, StarknetAction_1.sumStarknetGas)(swapData.payOut ? SwapClaim.GasCosts.CLAIM_PAY_OUT : SwapClaim.GasCosts.CLAIM, claimHandlerGas));
-    }
-    /**
-     * Creates transactions claiming the swap using a secret (for HTLC swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param secret hex encoded secret pre-image to the HTLC hash
-     * @param checkExpiry whether to check if the swap is already expired (trying to claim an expired swap with a secret
-     *  is dangerous because we might end up revealing the secret to the counterparty without being able to claim the swap)
-     * @param feeRate fee rate to use for the transaction
-     */
-    txsClaimWithSecret(signer, swapData, secret, checkExpiry, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //We need to be sure that this transaction confirms in time, otherwise we reveal the secret to the counterparty
-            // and won't claim the funds
-            if (checkExpiry && (yield this.root.isExpired(swapData.claimer.toString(), swapData))) {
-                throw new base_1.SwapDataVerificationError("Not enough time to reliably pay the invoice");
-            }
-            const claimHandler = this.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
-            if (claimHandler == null)
-                throw new base_1.SwapDataVerificationError("Unknown claim handler!");
-            if (claimHandler.getType() !== base_1.ChainSwapType.HTLC)
-                throw new base_1.SwapDataVerificationError("Invalid claim handler!");
-            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
-            const { initialTxns, witness } = yield claimHandler.getWitness(signer, swapData, secret, feeRate);
-            const action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
-            yield action.addToTxs(initialTxns, feeRate);
-            this.logger.debug("txsClaimWithSecret(): creating claim transaction, swap: " + swapData.getClaimHash() + " witness: ", witness.map(Utils_1.toHex));
-            return initialTxns;
-        });
-    }
-    /**
-     * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param tx bitcoin transaction that satisfies the swap condition
-     * @param requiredConfirmations
-     * @param vout vout of the bitcoin transaction that satisfies the swap condition
-     * @param commitedHeader commited header data from btc relay (fetched internally if null)
-     * @param synchronizer optional synchronizer to use in case we need to sync up the btc relay ourselves
-     * @param feeRate fee rate to be used for the transactions
-     */
-    txsClaimWithTxData(signer, swapData, tx, requiredConfirmations, vout, commitedHeader, synchronizer, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const claimHandler = this.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
-            if (claimHandler == null)
-                throw new base_1.SwapDataVerificationError("Unknown claim handler!");
-            if (claimHandler.getType() !== base_1.ChainSwapType.CHAIN_NONCED &&
-                claimHandler.getType() !== base_1.ChainSwapType.CHAIN_TXID &&
-                claimHandler.getType() !== base_1.ChainSwapType.CHAIN)
-                throw new base_1.SwapDataVerificationError("Invalid claim handler!");
-            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
-            const { initialTxns, witness } = yield claimHandler.getWitness(signer, swapData, {
-                tx,
-                vout,
-                requiredConfirmations,
-                commitedHeader,
-                btcRelay: this.root.btcRelay,
-                synchronizer,
-            }, feeRate);
-            const action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
-            yield action.addToTxs(initialTxns, feeRate);
-            return initialTxns;
-        });
-    }
-    /**
-     * Get the estimated starknet transaction fee of the claim transaction
-     */
-    getClaimFee(swapData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
-            let gasRequired = swapData.payOut ? SwapClaim.GasCosts.CLAIM_PAY_OUT : SwapClaim.GasCosts.CLAIM;
-            const claimHandler = this.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
-            if (claimHandler != null)
-                gasRequired = (0, StarknetAction_1.sumStarknetGas)(gasRequired, claimHandler.getGas(swapData));
-            return StarknetFees_1.StarknetFees.getGasFee(gasRequired.l1, feeRate);
-        });
-    }
-}
-exports.SwapClaim = SwapClaim;
-SwapClaim.GasCosts = {
-    CLAIM: { l1: 500, l2: 0 },
-    CLAIM_PAY_OUT: { l1: 1000, l2: 0 }
-};

package/dist/starknet/swaps/modules/SwapInit.d.ts

@@ -1,79 +0,0 @@
-import * as BN from "bn.js";
-import { StarknetSwapData } from "../StarknetSwapData";
-import { StarknetSwapModule } from "../StarknetSwapModule";
-import { StarknetSigner } from "../../wallet/StarknetSigner";
-import { StarknetTx } from "../../base/modules/StarknetTransactions";
-export declare class SwapInit extends StarknetSwapModule {
-    private static readonly GasCosts;
-    /**
-     * bare Init action based on the data passed in swapData
-     *
-     * @param swapData
-     * @param timeout
-     * @param signature
-     * @private
-     */
-    private Init;
-    /**
-     * Returns auth prefix to be used with a specific swap, payIn=true & payIn=false use different prefixes (these
-     *  actually have no meaning for the smart contract/solana program in the Solana case)
-     *
-     * @param swapData
-     * @private
-     */
-    private getAuthPrefix;
-    /**
-     * Signs swap initialization authorization, using data from preFetchedBlockData if provided & still valid (subject
-     *  to SIGNATURE_PREFETCH_DATA_VALIDITY)
-     *
-     * @param signer
-     * @param swapData
-     * @param authorizationTimeout
-     * @public
-     */
-    signSwapInitialization(signer: StarknetSigner, swapData: StarknetSwapData, authorizationTimeout: number): Promise<{
-        prefix: string;
-        timeout: string;
-        signature: string;
-    }>;
-    /**
-     * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
-     *
-     * @param swapData
-     * @param timeout
-     * @param prefix
-     * @param signature
-     * @public
-     */
-    isSignatureValid(swapData: StarknetSwapData, timeout: string, prefix: string, signature: string): Promise<null>;
-    /**
-     * Gets expiry of the provided signature data, this is a minimum of slot expiry & swap signature expiry
-     *
-     * @param timeout
-     * @public
-     */
-    getSignatureExpiry(timeout: string): Promise<number>;
-    /**
-     * Checks whether signature is expired for good, uses expiry + grace period
-     *
-     * @param timeout
-     * @public
-     */
-    isSignatureExpired(timeout: string): Promise<boolean>;
-    /**
-     * Creates init transaction with a valid signature from an LP
-     *
-     * @param swapData swap to initialize
-     * @param timeout init signature timeout
-     * @param prefix init signature prefix
-     * @param signature init signature
-     * @param skipChecks whether to skip signature validity checks
-     * @param feeRate fee rate to use for the transaction
-     */
-    txsInit(swapData: StarknetSwapData, timeout: string, prefix: string, signature: string, skipChecks?: boolean, feeRate?: string): Promise<StarknetTx[]>;
-    /**
-     * Get the estimated solana fee of the init transaction, this includes the required deposit for creating swap PDA
-     *  and also deposit for ATAs
-     */
-    getInitFee(swapData?: StarknetSwapData, feeRate?: string): Promise<BN>;
-}

package/dist/starknet/swaps/modules/SwapInit.js

@@ -1,174 +0,0 @@
-"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.SwapInit = void 0;
-const base_1 = require("@atomiqlabs/base");
-const BN = require("bn.js");
-const Utils_1 = require("../../../utils/Utils");
-const buffer_1 = require("buffer");
-const StarknetAction_1 = require("../../base/StarknetAction");
-const StarknetSwapModule_1 = require("../StarknetSwapModule");
-const StarknetFees_1 = require("../../base/modules/StarknetFees");
-const Initialize = [
-    { name: 'Swap hash', type: 'felt' },
-    { name: 'Timeout', type: 'timestamp' }
-];
-class SwapInit extends StarknetSwapModule_1.StarknetSwapModule {
-    /**
-     * bare Init action based on the data passed in swapData
-     *
-     * @param swapData
-     * @param timeout
-     * @param signature
-     * @private
-     */
-    Init(swapData, timeout, signature) {
-        return new StarknetAction_1.StarknetAction(swapData.payIn ? swapData.offerer : swapData.claimer, this.root, this.contract.populateTransaction.initialize(swapData.toEscrowStruct(), signature, (0, Utils_1.toBigInt)(timeout), swapData.extraData == null || swapData.extraData === "" ? [] : (0, Utils_1.bufferToBytes31Span)(buffer_1.Buffer.from(swapData.extraData, "hex")).map(Utils_1.toHex)), swapData.payIn ? SwapInit.GasCosts.INIT_PAY_IN : SwapInit.GasCosts.INIT);
-    }
-    /**
-     * Returns auth prefix to be used with a specific swap, payIn=true & payIn=false use different prefixes (these
-     *  actually have no meaning for the smart contract/solana program in the Solana case)
-     *
-     * @param swapData
-     * @private
-     */
-    getAuthPrefix(swapData) {
-        return swapData.isPayIn() ? "claim_initialize" : "initialize";
-    }
-    /**
-     * Signs swap initialization authorization, using data from preFetchedBlockData if provided & still valid (subject
-     *  to SIGNATURE_PREFETCH_DATA_VALIDITY)
-     *
-     * @param signer
-     * @param swapData
-     * @param authorizationTimeout
-     * @public
-     */
-    signSwapInitialization(signer, swapData, authorizationTimeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
-            const signature = yield this.root.Signatures.signTypedMessage(signer, Initialize, "Initialize", {
-                "Swap hash": (0, Utils_1.toHex)(swapData.getEscrowHash()),
-                "Timeout": (0, Utils_1.toHex)(authTimeout)
-            });
-            return {
-                prefix: this.getAuthPrefix(swapData),
-                timeout: authorizationTimeout.toString(10),
-                signature
-            };
-        });
-    }
-    /**
-     * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
-     *
-     * @param swapData
-     * @param timeout
-     * @param prefix
-     * @param signature
-     * @public
-     */
-    isSignatureValid(swapData, timeout, prefix, signature) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
-            const signer = swapData.isPayIn() ? swapData.claimer : swapData.offerer;
-            if (!swapData.isPayIn() && (yield this.root.isExpired(sender.toString(), swapData))) {
-                throw new base_1.SignatureVerificationError("Swap will expire too soon!");
-            }
-            if (prefix !== this.getAuthPrefix(swapData))
-                throw new base_1.SignatureVerificationError("Invalid prefix");
-            const currentTimestamp = new BN(Math.floor(Date.now() / 1000));
-            const timeoutBN = new BN(timeout);
-            const isExpired = timeoutBN.sub(currentTimestamp).lt(new BN(this.root.authGracePeriod));
-            if (isExpired)
-                throw new base_1.SignatureVerificationError("Authorization expired!");
-            const valid = yield this.root.Signatures.isValidSignature(signature, signer, Initialize, "Initialize", {
-                "Swap hash": (0, Utils_1.toHex)(swapData.getEscrowHash()),
-                "Timeout": (0, Utils_1.toHex)(timeoutBN)
-            });
-            if (!valid)
-                throw new base_1.SignatureVerificationError("Invalid signature!");
-            return null;
-        });
-    }
-    /**
-     * Gets expiry of the provided signature data, this is a minimum of slot expiry & swap signature expiry
-     *
-     * @param timeout
-     * @public
-     */
-    getSignatureExpiry(timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const now = Date.now();
-            const timeoutExpiryTime = (parseInt(timeout) - this.root.authGracePeriod) * 1000;
-            if (timeoutExpiryTime < now)
-                return 0;
-            return timeoutExpiryTime;
-        });
-    }
-    /**
-     * Checks whether signature is expired for good, uses expiry + grace period
-     *
-     * @param timeout
-     * @public
-     */
-    isSignatureExpired(timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (parseInt(timeout) + this.root.authGracePeriod) * 1000 < Date.now();
-        });
-    }
-    /**
-     * Creates init transaction with a valid signature from an LP
-     *
-     * @param swapData swap to initialize
-     * @param timeout init signature timeout
-     * @param prefix init signature prefix
-     * @param signature init signature
-     * @param skipChecks whether to skip signature validity checks
-     * @param feeRate fee rate to use for the transaction
-     */
-    txsInit(swapData, timeout, prefix, signature, skipChecks, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
-            if (!skipChecks) {
-                const [_, payStatus] = yield Promise.all([
-                    (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError),
-                    (0, Utils_1.tryWithRetries)(() => this.root.getCommitStatus(sender, swapData), this.retryPolicy)
-                ]);
-                if (payStatus !== base_1.SwapCommitStatus.NOT_COMMITED)
-                    throw new base_1.SwapDataVerificationError("Invoice already being paid for or paid");
-            }
-            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
-            const initAction = this.Init(swapData, new BN(timeout), JSON.parse(signature));
-            if (swapData.payIn)
-                initAction.addAction(this.root.Tokens.Approve(sender, this.contract.address, swapData.token, swapData.amount), 0); //Add erc20 approve
-            if (!swapData.getTotalDeposit().isZero())
-                initAction.addAction(this.root.Tokens.Approve(sender, this.contract.address, swapData.feeToken, swapData.getTotalDeposit()), 0); //Add deposit erc20 approve
-            this.logger.debug("txsInitPayIn(): create swap init TX, swap: " + swapData.getClaimHash() +
-                " feerate: " + feeRate);
-            return [yield initAction.tx(feeRate)];
-        });
-    }
-    /**
-     * Get the estimated solana fee of the init transaction, this includes the required deposit for creating swap PDA
-     *  and also deposit for ATAs
-     */
-    getInitFee(swapData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
-            return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? SwapInit.GasCosts.INIT_PAY_IN.l1 : SwapInit.GasCosts.INIT.l1, feeRate);
-        });
-    }
-}
-exports.SwapInit = SwapInit;
-SwapInit.GasCosts = {
-    INIT: { l1: 500, l2: 0 },
-    INIT_PAY_IN: { l1: 1000, l2: 0 },
-};

package/dist/starknet/swaps/modules/SwapRefund.d.ts

@@ -1,63 +0,0 @@
-import * as BN from "bn.js";
-import { StarknetSwapModule } from "../StarknetSwapModule";
-import { StarknetSwapData } from "../StarknetSwapData";
-import { StarknetSwapContract } from "../StarknetSwapContract";
-import { StarknetTx } from "../../base/modules/StarknetTransactions";
-import { StarknetSigner } from "../../wallet/StarknetSigner";
-export declare class SwapRefund extends StarknetSwapModule {
-    private static readonly GasCosts;
-    /**
-     * Action for generic Refund instruction
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param handlerGas
-     * @constructor
-     * @private
-     */
-    private Refund;
-    /**
-     * Action for cooperative refunding with signature
-     *
-     * @param sender
-     * @param swapData
-     * @param timeout
-     * @param signature
-     * @constructor
-     * @private
-     */
-    private RefundWithSignature;
-    constructor(root: StarknetSwapContract);
-    signSwapRefund(signer: StarknetSigner, swapData: StarknetSwapData, authorizationTimeout: number): Promise<{
-        prefix: string;
-        timeout: string;
-        signature: string;
-    }>;
-    isSignatureValid(swapData: StarknetSwapData, timeout: string, prefix: string, signature: string): Promise<null>;
-    /**
-     * Creates transactions required for refunding timed out swap
-     *
-     * @param swapData swap data to refund
-     * @param check whether to check if swap is already expired and refundable
-     * @param feeRate fee rate to be used for the transactions
-     * @param witnessData
-     */
-    txsRefund<T>(swapData: StarknetSwapData, check?: boolean, feeRate?: string, witnessData?: T): Promise<StarknetTx[]>;
-    /**
-     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
-     *
-     * @param swapData swap data to refund
-     * @param timeout signature timeout
-     * @param prefix signature prefix of the counterparty
-     * @param signature signature of the counterparty
-     * @param check whether to check if swap is committed before attempting refund
-     * @param feeRate fee rate to be used for the transactions
-     */
-    txsRefundWithAuthorization(swapData: StarknetSwapData, timeout: string, prefix: string, signature: string, check?: boolean, feeRate?: string): Promise<StarknetTx[]>;
-    /**
-     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
-     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
-     */
-    getRefundFee(swapData: StarknetSwapData, feeRate?: string): Promise<BN>;
-}

package/dist/starknet/swaps/modules/SwapRefund.js

@@ -1,149 +0,0 @@
-"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.SwapRefund = void 0;
-const base_1 = require("@atomiqlabs/base");
-const BN = require("bn.js");
-const Utils_1 = require("../../../utils/Utils");
-const StarknetSwapModule_1 = require("../StarknetSwapModule");
-const StarknetAction_1 = require("../../base/StarknetAction");
-const StarknetFees_1 = require("../../base/modules/StarknetFees");
-const Refund = [
-    { name: 'Swap hash', type: 'felt' },
-    { name: 'Timeout', type: 'timestamp' }
-];
-class SwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
-    /**
-     * Action for generic Refund instruction
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param handlerGas
-     * @constructor
-     * @private
-     */
-    Refund(signer, swapData, witness, handlerGas) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.contract.populateTransaction.refund(swapData.toEscrowStruct(), witness), (0, StarknetAction_1.sumStarknetGas)(swapData.payIn ? SwapRefund.GasCosts.REFUND_PAY_OUT : SwapRefund.GasCosts.REFUND, handlerGas));
-    }
-    /**
-     * Action for cooperative refunding with signature
-     *
-     * @param sender
-     * @param swapData
-     * @param timeout
-     * @param signature
-     * @constructor
-     * @private
-     */
-    RefundWithSignature(sender, swapData, timeout, signature) {
-        return new StarknetAction_1.StarknetAction(sender, this.root, this.contract.populateTransaction.cooperative_refund(swapData.toEscrowStruct(), signature, BigInt(timeout)), swapData.payIn ? SwapRefund.GasCosts.REFUND_PAY_OUT : SwapRefund.GasCosts.REFUND);
-    }
-    constructor(root) {
-        super(root);
-    }
-    signSwapRefund(signer, swapData, authorizationTimeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const authPrefix = "refund";
-            const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
-            const signature = yield this.root.Signatures.signTypedMessage(signer, Refund, "Refund", {
-                "Swap hash": (0, Utils_1.toHex)(swapData.getEscrowHash()),
-                "Timeout": (0, Utils_1.toHex)(authTimeout)
-            });
-            return {
-                prefix: authPrefix,
-                timeout: authTimeout.toString(10),
-                signature: signature
-            };
-        });
-    }
-    isSignatureValid(swapData, timeout, prefix, signature) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (prefix !== "refund")
-                throw new base_1.SignatureVerificationError("Invalid prefix");
-            const expiryTimestamp = new BN(timeout);
-            const currentTimestamp = new BN(Math.floor(Date.now() / 1000));
-            const isExpired = expiryTimestamp.sub(currentTimestamp).lt(new BN(this.root.authGracePeriod));
-            if (isExpired)
-                throw new base_1.SignatureVerificationError("Authorization expired!");
-            const valid = yield this.root.Signatures.isValidSignature(signature, swapData.claimer, Refund, "Refund", {
-                "Swap hash": (0, Utils_1.toHex)(swapData.getEscrowHash()),
-                "Timeout": (0, Utils_1.toHex)(expiryTimestamp)
-            });
-            if (!valid) {
-                throw new base_1.SignatureVerificationError("Invalid signature!");
-            }
-            return null;
-        });
-    }
-    /**
-     * Creates transactions required for refunding timed out swap
-     *
-     * @param swapData swap data to refund
-     * @param check whether to check if swap is already expired and refundable
-     * @param feeRate fee rate to be used for the transactions
-     * @param witnessData
-     */
-    txsRefund(swapData, check, feeRate, witnessData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const refundHandler = this.root.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
-            if (refundHandler == null)
-                throw new Error("Invalid refund handler");
-            if (check && !(yield (0, Utils_1.tryWithRetries)(() => this.root.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy))) {
-                throw new base_1.SwapDataVerificationError("Not refundable yet!");
-            }
-            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
-            const { initialTxns, witness } = yield refundHandler.getWitness(swapData.offerer, swapData, witnessData, feeRate);
-            const action = this.Refund(swapData.offerer, swapData, witness, refundHandler.getGas(swapData));
-            yield action.addToTxs(initialTxns, feeRate);
-            this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
-            return initialTxns;
-        });
-    }
-    /**
-     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
-     *
-     * @param swapData swap data to refund
-     * @param timeout signature timeout
-     * @param prefix signature prefix of the counterparty
-     * @param signature signature of the counterparty
-     * @param check whether to check if swap is committed before attempting refund
-     * @param feeRate fee rate to be used for the transactions
-     */
-    txsRefundWithAuthorization(swapData, timeout, prefix, signature, check, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (check && !(yield (0, Utils_1.tryWithRetries)(() => this.root.isCommited(swapData), this.retryPolicy))) {
-                throw new base_1.SwapDataVerificationError("Not correctly committed");
-            }
-            yield (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
-            const action = this.RefundWithSignature(swapData.offerer, swapData, timeout, JSON.parse(signature));
-            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
-            this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
-                " auth expiry: " + timeout + " signature: " + signature);
-            return [yield action.tx(feeRate)];
-        });
-    }
-    /**
-     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
-     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
-     */
-    getRefundFee(swapData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
-            return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? SwapRefund.GasCosts.REFUND_PAY_OUT.l1 : SwapRefund.GasCosts.REFUND.l1, feeRate);
-        });
-    }
-}
-exports.SwapRefund = SwapRefund;
-SwapRefund.GasCosts = {
-    REFUND: { l1: 750, l2: 0 },
-    REFUND_PAY_OUT: { l1: 1250, l2: 0 }
-};