@atomiqlabs/chain-starknet 4.0.0-dev.12 → 4.0.0-dev.13

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

@@ -1,102 +1,102 @@
-import {IClaimHandler} from "../ClaimHandlers";
-import {StarknetSwapData} from "../../../StarknetSwapData";
-import {ChainSwapType, RelaySynchronizer} from "@atomiqlabs/base";
-import {BigNumberish, hash} from "starknet";
-import {StarknetBtcStoredHeader} from "../../../../btcrelay/headers/StarknetBtcStoredHeader";
-import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
-import {StarknetBtcRelay} from "../../../../btcrelay/StarknetBtcRelay";
-import {bufferToU32Array, getLogger, u32ArrayToBuffer} from "../../../../../utils/Utils";
-import {StarknetGas} from "../../../../chain/modules/StarknetFees";
-
-export type BitcoinCommitmentData = {
-    btcRelay: StarknetBtcRelay<any>,
-    confirmations: number
-}
-
-export type BitcoinWitnessData = {
-    tx: { blockhash: string, confirmations: number, txid: string, hex: string, height: number },
-    requiredConfirmations: number,
-    commitedHeader?: StarknetBtcStoredHeader,
-    btcRelay?: StarknetBtcRelay<any>,
-    synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>
-};
-
-const logger = getLogger("IBitcoinClaimHandler: ");
-
-export abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
-
-    public readonly address: string;
-
-    constructor(address: string) {
-        this.address = address;
-    }
-
-    public static readonly address = "";
-    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
-    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
-
-    protected serializeCommitment(data: BitcoinCommitmentData): BigNumberish[] {
-        return [
-            data.confirmations,
-            data.btcRelay.contract.address
-        ]
-    }
-
-    getCommitment(data: C & BitcoinCommitmentData): BigNumberish {
-        return hash.computePoseidonHashOnElements(this.serializeCommitment(data));
-    }
-
-    protected async _getWitness(
-        signer: string,
-        swapData: StarknetSwapData,
-        {tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations}: BitcoinWitnessData,
-        commitment: C,
-        feeRate?: string
-    ): Promise<{
-        initialTxns: StarknetTx[];
-        witness: BigNumberish[]
-    }> {
-        const serializedData: BigNumberish[] = this.serializeCommitment({
-            ...commitment,
-            btcRelay,
-            confirmations: requiredConfirmations
-        });
-        const commitmentHash = hash.computePoseidonHashOnElements(serializedData);
-
-        if(!swapData.isClaimData(commitmentHash)) throw new Error("Invalid commit data");
-
-        const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
-        logger.debug("getWitness(): merkle proof computed: ", merkleProof);
-
-        const txs: StarknetTx[] = [];
-        if(commitedHeader==null) {
-            const headers = await StarknetBtcRelay.getCommitedHeadersAndSynchronize(
-                signer, btcRelay,
-                [{blockheight: tx.height, requiredConfirmations, blockhash: tx.blockhash}],
-                txs, synchronizer, feeRate
-            );
-            if(headers==null) throw new Error("Cannot fetch committed header!");
-            commitedHeader = headers[tx.blockhash];
-        }
-
-        serializedData.push(...commitedHeader.serialize());
-        serializedData.push(merkleProof.merkle.length, ...merkleProof.merkle.map(bufferToU32Array).flat());
-        serializedData.push(merkleProof.pos);
-
-        return {initialTxns: txs, witness: serializedData};
-    }
-
-    abstract getWitness(signer: string, data: StarknetSwapData, witnessData: W, feeRate?: string): Promise<{
-        initialTxns: StarknetTx[];
-        witness: BigNumberish[]
-    }>;
-
-    abstract getGas(data: StarknetSwapData): StarknetGas;
-
-    abstract getType(): ChainSwapType;
-
-    parseWitnessResult(result: BigNumberish[]): string {
-        return u32ArrayToBuffer(result).toString("hex");
-    }
-
-}
+import {IClaimHandler} from "../ClaimHandlers";
+import {StarknetSwapData} from "../../../StarknetSwapData";
+import {ChainSwapType, RelaySynchronizer} from "@atomiqlabs/base";
+import {BigNumberish, hash} from "starknet";
+import {StarknetBtcStoredHeader} from "../../../../btcrelay/headers/StarknetBtcStoredHeader";
+import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
+import {StarknetBtcRelay} from "../../../../btcrelay/StarknetBtcRelay";
+import {bufferToU32Array, getLogger, u32ArrayToBuffer} from "../../../../../utils/Utils";
+import {StarknetGas} from "../../../../chain/modules/StarknetFees";
+
+export type BitcoinCommitmentData = {
+    btcRelay: StarknetBtcRelay<any>,
+    confirmations: number
+}
+
+export type BitcoinWitnessData = {
+    tx: { blockhash: string, confirmations: number, txid: string, hex: string, height: number },
+    requiredConfirmations: number,
+    commitedHeader?: StarknetBtcStoredHeader,
+    btcRelay?: StarknetBtcRelay<any>,
+    synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>
+};
+
+const logger = getLogger("IBitcoinClaimHandler: ");
+
+export abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
+
+    public readonly address: string;
+
+    constructor(address: string) {
+        this.address = address;
+    }
+
+    public static readonly address = "";
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
+
+    protected serializeCommitment(data: BitcoinCommitmentData): BigNumberish[] {
+        return [
+            data.confirmations,
+            data.btcRelay.contract.address
+        ]
+    }
+
+    getCommitment(data: C & BitcoinCommitmentData): BigNumberish {
+        return hash.computePoseidonHashOnElements(this.serializeCommitment(data));
+    }
+
+    protected async _getWitness(
+        signer: string,
+        swapData: StarknetSwapData,
+        {tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations}: BitcoinWitnessData,
+        commitment: C,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[]
+    }> {
+        const serializedData: BigNumberish[] = this.serializeCommitment({
+            ...commitment,
+            btcRelay,
+            confirmations: requiredConfirmations
+        });
+        const commitmentHash = hash.computePoseidonHashOnElements(serializedData);
+
+        if(!swapData.isClaimData(commitmentHash)) throw new Error("Invalid commit data");
+
+        const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
+        logger.debug("getWitness(): merkle proof computed: ", merkleProof);
+
+        const txs: StarknetTx[] = [];
+        if(commitedHeader==null) {
+            const headers = await StarknetBtcRelay.getCommitedHeadersAndSynchronize(
+                signer, btcRelay,
+                [{blockheight: tx.height, requiredConfirmations, blockhash: tx.blockhash}],
+                txs, synchronizer, feeRate
+            );
+            if(headers==null) throw new Error("Cannot fetch committed header!");
+            commitedHeader = headers[tx.blockhash];
+        }
+
+        serializedData.push(...commitedHeader.serialize());
+        serializedData.push(merkleProof.merkle.length, ...merkleProof.merkle.map(bufferToU32Array).flat());
+        serializedData.push(merkleProof.pos);
+
+        return {initialTxns: txs, witness: serializedData};
+    }
+
+    abstract getWitness(signer: string, data: StarknetSwapData, witnessData: W, feeRate?: string): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[]
+    }>;
+
+    abstract getGas(data: StarknetSwapData): StarknetGas;
+
+    abstract getType(): ChainSwapType;
+
+    parseWitnessResult(result: BigNumberish[]): string {
+        return u32ArrayToBuffer(result).toString("hex");
+    }
+
+}

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

@@ -1,39 +1,39 @@
-import {StarknetTx} from "../../../chain/modules/StarknetTransactions";
-import {StarknetSwapData} from "../../StarknetSwapData";
-import {bigNumberishToBuffer} from "../../../../utils/Utils";
-import {BigNumberish} from "starknet";
-import {IHandler} from "../IHandler";
-import {StarknetGas} from "../../../chain/modules/StarknetFees";
-
-export class TimelockRefundHandler implements IHandler<bigint, never> {
-
-    public readonly address: string;
-    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 4_000_000, l1Gas: 0};
-
-    constructor(address: string) {
-        this.address = address;
-    }
-
-    public getCommitment(data: bigint): BigNumberish {
-        return data;
-    }
-
-    public getWitness(signer: string, data: StarknetSwapData): Promise<{
-        initialTxns: StarknetTx[],
-        witness: BigNumberish[]
-    }> {
-        const expiry = TimelockRefundHandler.getExpiry(data);
-        const currentTimestamp = BigInt(Math.floor(Date.now()/1000));
-        if(expiry > currentTimestamp) throw new Error("Not expired yet!");
-        return Promise.resolve({initialTxns: [], witness: []});
-    }
-
-    getGas(): StarknetGas {
-        return TimelockRefundHandler.gas;
-    }
-
-    public static getExpiry(data: StarknetSwapData): bigint {
-        return bigNumberishToBuffer(data.refundData, 32).readBigUInt64BE(24).valueOf();
-    }
-
+import {StarknetTx} from "../../../chain/modules/StarknetTransactions";
+import {StarknetSwapData} from "../../StarknetSwapData";
+import {bigNumberishToBuffer} from "../../../../utils/Utils";
+import {BigNumberish} from "starknet";
+import {IHandler} from "../IHandler";
+import {StarknetGas} from "../../../chain/modules/StarknetFees";
+
+export class TimelockRefundHandler implements IHandler<bigint, never> {
+
+    public readonly address: string;
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 4_000_000, l1Gas: 0};
+
+    constructor(address: string) {
+        this.address = address;
+    }
+
+    public getCommitment(data: bigint): BigNumberish {
+        return data;
+    }
+
+    public getWitness(signer: string, data: StarknetSwapData): Promise<{
+        initialTxns: StarknetTx[],
+        witness: BigNumberish[]
+    }> {
+        const expiry = TimelockRefundHandler.getExpiry(data);
+        const currentTimestamp = BigInt(Math.floor(Date.now()/1000));
+        if(expiry > currentTimestamp) throw new Error("Not expired yet!");
+        return Promise.resolve({initialTxns: [], witness: []});
+    }
+
+    getGas(): StarknetGas {
+        return TimelockRefundHandler.gas;
+    }
+
+    public static getExpiry(data: StarknetSwapData): bigint {
+        return bigNumberishToBuffer(data.refundData, 32).readBigUInt64BE(24).valueOf();
+    }
+
 }

package/src/starknet/swaps/modules/StarknetLpVault.ts

@@ -1,148 +1,148 @@
-import {toBigInt} from "../../../utils/Utils";
-import { IntermediaryReputationType } from "@atomiqlabs/base";
-import {StarknetSwapModule} from "../StarknetSwapModule";
-import {StarknetAction} from "../../chain/StarknetAction";
-import {cairo} from "starknet";
-import {StarknetTx} from "../../chain/modules/StarknetTransactions";
-
-export class StarknetLpVault extends StarknetSwapModule {
-
-    private static readonly GasCosts = {
-        WITHDRAW: {l1DataGas: 500, l2Gas: 3_200_000, l1Gas: 0},
-        DEPOSIT: {l1: 500, l2Gas: 4_000_000, l1Gas: 0}
-    };
-
-    /**
-     * Action for withdrawing funds from the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @constructor
-     * @private
-     */
-    private Withdraw(signer: string, token: string, amount: bigint): StarknetAction {
-        return new StarknetAction(signer, this.root,
-            this.swapContract.populateTransaction.withdraw(token, cairo.uint256(amount), signer),
-            StarknetLpVault.GasCosts.WITHDRAW
-        );
-    }
-
-    /**
-     * Action for depositing funds to the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @constructor
-     * @private
-     */
-    private Deposit(signer: string, token: string, amount: bigint): StarknetAction {
-        return new StarknetAction(signer, this.root,
-            this.swapContract.populateTransaction.deposit(token, cairo.uint256(amount)),
-            StarknetLpVault.GasCosts.WITHDRAW
-        );
-    }
-
-    /**
-     * Returns intermediary's reputation & vault balance for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    public async getIntermediaryData(address: string, token: string): Promise<{
-        balance: bigint,
-        reputation: IntermediaryReputationType
-    }> {
-        const [balance, reputation] = await Promise.all([
-            this.getIntermediaryBalance(address, token),
-            this.getIntermediaryReputation(address, token)
-        ]);
-
-        return {balance, reputation};
-    }
-
-    /**
-     * Returns intermediary's reputation for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    public async getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType> {
-        const filter = Object.keys(this.contract.claimHandlersByAddress).map(claimHandler => cairo.tuple(address, token, claimHandler));
-        const rawReputation = await this.provider.callContract(this.swapContract.populateTransaction.get_reputation(filter));
-        const length = toBigInt(rawReputation.shift());
-        if(Number(length)!==filter.length) throw new Error("getIntermediaryReputation(): Invalid response length");
-
-        const result: any = {};
-        Object.keys(this.contract.claimHandlersByAddress).forEach((address) => {
-            const handler = this.contract.claimHandlersByAddress[address];
-            result[handler.getType()] = {
-                successVolume: toBigInt({low: rawReputation.shift(), high: rawReputation.shift()}),
-                successCount: toBigInt(rawReputation.shift()),
-                coopCloseVolume: toBigInt({low: rawReputation.shift(), high: rawReputation.shift()}),
-                coopCloseCount: toBigInt(rawReputation.shift()),
-                failVolume: toBigInt({low: rawReputation.shift(), high: rawReputation.shift()}),
-                failCount: toBigInt(rawReputation.shift()),
-            };
-        });
-        return result as any;
-    }
-
-    /**
-     * Returns the balance of the token an intermediary has in his LP vault
-     *
-     * @param address
-     * @param token
-     */
-    public async getIntermediaryBalance(address: string, token: string): Promise<bigint> {
-        const balance = toBigInt((await this.swapContract.get_balance([cairo.tuple(address, token)]))[0]);
-
-        this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: "+token.toString()+
-            " address: "+address+" amount: "+(balance==null ? "null" : balance.toString()));
-
-        return balance;
-    }
-
-    /**
-     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
-     *  WSOL to SOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    public async txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]> {
-        const action = await this.Withdraw(signer, token, amount);
-
-        feeRate ??= await this.root.Fees.getFeeRate();
-
-        this.logger.debug("txsWithdraw(): withdraw TX created, token: "+token.toString()+
-            " amount: "+amount.toString(10));
-
-        return [await action.tx(feeRate)];
-    }
-
-    /**
-     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    public async txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]> {
-        //Approve first
-        const action = await this.root.Tokens.Approve(signer, this.swapContract.address, token, amount);
-        action.add(this.Deposit(signer, token, amount));
-
-        feeRate ??= await this.root.Fees.getFeeRate();
-
-        this.logger.debug("txsDeposit(): deposit TX created, token: "+token.toString()+
-            " amount: "+amount.toString(10));
-
-        return [await action.tx(feeRate)];
-    }
-
+import {toBigInt} from "../../../utils/Utils";
+import { IntermediaryReputationType } from "@atomiqlabs/base";
+import {StarknetSwapModule} from "../StarknetSwapModule";
+import {StarknetAction} from "../../chain/StarknetAction";
+import {cairo} from "starknet";
+import {StarknetTx} from "../../chain/modules/StarknetTransactions";
+
+export class StarknetLpVault extends StarknetSwapModule {
+
+    private static readonly GasCosts = {
+        WITHDRAW: {l1DataGas: 500, l2Gas: 3_200_000, l1Gas: 0},
+        DEPOSIT: {l1: 500, l2Gas: 4_000_000, l1Gas: 0}
+    };
+
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Withdraw(signer: string, token: string, amount: bigint): StarknetAction {
+        return new StarknetAction(signer, this.root,
+            this.swapContract.populateTransaction.withdraw(token, cairo.uint256(amount), signer),
+            StarknetLpVault.GasCosts.WITHDRAW
+        );
+    }
+
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Deposit(signer: string, token: string, amount: bigint): StarknetAction {
+        return new StarknetAction(signer, this.root,
+            this.swapContract.populateTransaction.deposit(token, cairo.uint256(amount)),
+            StarknetLpVault.GasCosts.WITHDRAW
+        );
+    }
+
+    /**
+     * Returns intermediary's reputation & vault balance for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    public async getIntermediaryData(address: string, token: string): Promise<{
+        balance: bigint,
+        reputation: IntermediaryReputationType
+    }> {
+        const [balance, reputation] = await Promise.all([
+            this.getIntermediaryBalance(address, token),
+            this.getIntermediaryReputation(address, token)
+        ]);
+
+        return {balance, reputation};
+    }
+
+    /**
+     * Returns intermediary's reputation for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    public async getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType> {
+        const filter = Object.keys(this.contract.claimHandlersByAddress).map(claimHandler => cairo.tuple(address, token, claimHandler));
+        const rawReputation = await this.provider.callContract(this.swapContract.populateTransaction.get_reputation(filter));
+        const length = toBigInt(rawReputation.shift());
+        if(Number(length)!==filter.length) throw new Error("getIntermediaryReputation(): Invalid response length");
+
+        const result: any = {};
+        Object.keys(this.contract.claimHandlersByAddress).forEach((address) => {
+            const handler = this.contract.claimHandlersByAddress[address];
+            result[handler.getType()] = {
+                successVolume: toBigInt({low: rawReputation.shift(), high: rawReputation.shift()}),
+                successCount: toBigInt(rawReputation.shift()),
+                coopCloseVolume: toBigInt({low: rawReputation.shift(), high: rawReputation.shift()}),
+                coopCloseCount: toBigInt(rawReputation.shift()),
+                failVolume: toBigInt({low: rawReputation.shift(), high: rawReputation.shift()}),
+                failCount: toBigInt(rawReputation.shift()),
+            };
+        });
+        return result as any;
+    }
+
+    /**
+     * Returns the balance of the token an intermediary has in his LP vault
+     *
+     * @param address
+     * @param token
+     */
+    public async getIntermediaryBalance(address: string, token: string): Promise<bigint> {
+        const balance = toBigInt((await this.swapContract.get_balance([cairo.tuple(address, token)]))[0]);
+
+        this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: "+token.toString()+
+            " address: "+address+" amount: "+(balance==null ? "null" : balance.toString()));
+
+        return balance;
+    }
+
+    /**
+     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
+     *  WSOL to SOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    public async txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]> {
+        const action = await this.Withdraw(signer, token, amount);
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        this.logger.debug("txsWithdraw(): withdraw TX created, token: "+token.toString()+
+            " amount: "+amount.toString(10));
+
+        return [await action.tx(feeRate)];
+    }
+
+    /**
+     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    public async txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]> {
+        //Approve first
+        const action = await this.root.Tokens.Approve(signer, this.swapContract.address, token, amount);
+        action.add(this.Deposit(signer, token, amount));
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        this.logger.debug("txsDeposit(): deposit TX created, token: "+token.toString()+
+            " amount: "+amount.toString(10));
+
+        return [await action.tx(feeRate)];
+    }
+
 }