@atomiqlabs/chain-starknet 1.0.0-beta.0

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

@@ -0,0 +1,49 @@
+import {StarknetSwapData} from "../../../StarknetSwapData";
+import {StarknetGas} from "../../../../base/StarknetAction";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {BigNumberish} from "starknet";
+import {StarknetTx} from "../../../../base/modules/StarknetTransactions";
+import {bufferToU32Array, getLogger} from "../../../../../utils/Utils";
+import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
+
+export type BitcoinTxIdCommitmentData = {
+    txId: string
+};
+
+const logger = getLogger("BitcoinTxIdClaimHandler: ");
+
+export class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler<BitcoinTxIdCommitmentData, BitcoinWitnessData> {
+
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
+    public static readonly gas: StarknetGas = {l1: 20000};
+
+    protected serializeCommitment(data: BitcoinTxIdCommitmentData & BitcoinCommitmentData): BigNumberish[] {
+        return [
+            ...bufferToU32Array(Buffer.from(data.txId, "hex").reverse()),
+            ...super.serializeCommitment(data)
+        ];
+    }
+
+    getWitness(
+        signer: string,
+        swapData: StarknetSwapData,
+        witnessData: BitcoinWitnessData,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[]
+    }> {
+        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
+
+        return this._getWitness(signer, swapData, witnessData, {txId: witnessData.tx.txid});
+    }
+
+    getGas(data: StarknetSwapData): StarknetGas {
+        return BitcoinTxIdClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return BitcoinTxIdClaimHandler.type;
+    }
+
+}

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

@@ -0,0 +1,151 @@
+import {IClaimHandler} from "../ClaimHandlers";
+import {StarknetSwapData} from "../../../StarknetSwapData";
+import {StarknetGas} from "../../../../base/StarknetAction";
+import {ChainSwapType, RelaySynchronizer} from "@atomiqlabs/base";
+import {BigNumberish, hash} from "starknet";
+import {StarknetBtcStoredHeader} from "../../../../btcrelay/headers/StarknetBtcStoredHeader";
+import {StarknetTx} from "../../../../base/modules/StarknetTransactions";
+import {StarknetBtcRelay} from "../../../../btcrelay/StarknetBtcRelay";
+import {bufferToU32Array, getLogger, toHex, tryWithRetries, u32ArrayToBuffer} from "../../../../../utils/Utils";
+
+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;
+    }
+
+    /**
+     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
+     *  requiredConfirmations
+     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
+     *  current chain tip & adds them to the txs array
+     *
+     * @param signer
+     * @param btcRelay
+     * @param txBlockheight transaction blockheight
+     * @param requiredConfirmations required confirmation for the swap to be claimable with that TX
+     * @param blockhash blockhash of the block which includes the transaction
+     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
+     *  txns are added here
+     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
+     *  to the required blockheight
+     * @param feeRate Fee rate to use for synchronization transactions
+     * @private
+     */
+    protected async getCommitedHeaderAndSynchronize(
+        signer: string,
+        btcRelay: StarknetBtcRelay<any>,
+        txBlockheight: number,
+        requiredConfirmations: number,
+        blockhash: string,
+        txs: StarknetTx[],
+        synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>,
+        feeRate?: string
+    ): Promise<StarknetBtcStoredHeader> {
+        const requiredBlockheight = txBlockheight+requiredConfirmations-1;
+
+        const result = await tryWithRetries(
+            () => btcRelay.retrieveLogAndBlockheight({
+                blockhash: blockhash
+            }, requiredBlockheight)
+        );
+
+        if(result!=null) return result.header;
+
+        //Need to synchronize
+        if(synchronizer==null) return null;
+
+        //TODO: We don't have to synchronize to tip, only to our required blockheight
+        const resp = await synchronizer.syncToLatestTxs(signer.toString(), feeRate);
+        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay not synchronized to required blockheight, "+
+            "synchronizing ourselves in "+resp.txs.length+" txs");
+        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay computed header map: ",resp.computedHeaderMap);
+        resp.txs.forEach(tx => txs.push(tx));
+
+        //Retrieve computed header
+        return resp.computedHeaderMap[txBlockheight];
+    }
+
+    public static readonly address = "";
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
+    public static readonly gas: StarknetGas = {l1: 20000};
+
+    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) commitedHeader = await this.getCommitedHeaderAndSynchronize(
+            signer, btcRelay, tx.height, requiredConfirmations,
+            tx.blockhash, txs, synchronizer, feeRate
+        );
+
+        if(commitedHeader==null) throw new Error("Cannot fetch committed header!");
+
+        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

@@ -0,0 +1,39 @@
+import {StarknetTx} from "../../../base/modules/StarknetTransactions";
+import {StarknetSwapData} from "../../StarknetSwapData";
+import {bigNumberishToBuffer, toBigInt} from "../../../../utils/Utils";
+import {BigNumberish} from "starknet";
+import {IHandler} from "../IHandler";
+import {StarknetGas} from "../../../base/StarknetAction";
+
+export class TimelockRefundHandler implements IHandler<bigint, never> {
+
+    public readonly address: string;
+    public static readonly gas: StarknetGas = {l1: 500};
+
+    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);
+    }
+
+}

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

@@ -0,0 +1,148 @@
+import {toBigInt} from "../../../utils/Utils";
+import { IntermediaryReputationType } from "@atomiqlabs/base";
+import {StarknetSwapModule} from "../StarknetSwapModule";
+import {StarknetAction} from "../../base/StarknetAction";
+import {cairo} from "starknet";
+import {StarknetTx} from "../../base/modules/StarknetTransactions";
+
+export class StarknetLpVault extends StarknetSwapModule {
+
+    private static readonly GasCosts = {
+        WITHDRAW: {l1: 750, l2: 0},
+        DEPOSIT: {l1: 750, l2: 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.contract.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.contract.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.root.claimHandlersByAddress).map(claimHandler => cairo.tuple(address, token, claimHandler));
+        const rawReputation = await this.provider.callContract(this.contract.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.root.claimHandlersByAddress).forEach((address) => {
+            const handler = this.root.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.contract.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.contract.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)];
+    }
+
+}

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

@@ -0,0 +1,142 @@
+import {ChainSwapType, RelaySynchronizer, SwapDataVerificationError} from "@atomiqlabs/base";
+import {toHex} from "../../../utils/Utils";
+import {StarknetSwapModule} from "../StarknetSwapModule";
+import {StarknetSwapData} from "../StarknetSwapData";
+import {StarknetAction, StarknetGas, sumStarknetGas} from "../../base/StarknetAction";
+import {BigNumberish} from "starknet";
+import {IClaimHandler} from "../handlers/claim/ClaimHandlers";
+import {StarknetTx} from "../../base/modules/StarknetTransactions";
+import {StarknetFees} from "../../base/modules/StarknetFees";
+import {StarknetBtcStoredHeader} from "../../btcrelay/headers/StarknetBtcStoredHeader";
+import {BitcoinOutputWitnessData} from "../handlers/claim/btc/BitcoinOutputClaimHandler";
+import {BitcoinWitnessData} from "../handlers/claim/btc/IBitcoinClaimHandler";
+import {Buffer} from "buffer";
+
+export class StarknetSwapClaim extends StarknetSwapModule {
+
+    private static readonly GasCosts = {
+        CLAIM: {l1: 500, l2: 0},
+        CLAIM_PAY_OUT: {l1: 1000, l2: 0}
+    };
+
+    /**
+     * Claim action which uses the provided witness for claiming the swap
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param claimHandlerGas
+     * @constructor
+     * @private
+     */
+    private Claim(
+        signer: string,
+        swapData: StarknetSwapData,
+        witness: BigNumberish[],
+        claimHandlerGas?: StarknetGas
+    ): StarknetAction {
+        return new StarknetAction(signer, this.root,
+            this.contract.populateTransaction.claim(swapData.toEscrowStruct(), witness),
+            sumStarknetGas(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.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
+     */
+    async txsClaimWithSecret(
+        signer: string,
+        swapData: StarknetSwapData,
+        secret: string,
+        checkExpiry?: boolean,
+        feeRate?: string
+    ): Promise<StarknetTx[]> {
+        //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 && await this.root.isExpired(swapData.claimer.toString(), swapData)) {
+            throw new SwapDataVerificationError("Not enough time to reliably pay the invoice");
+        }
+
+        const claimHandler: IClaimHandler<Buffer, string> = this.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if(claimHandler==null) throw new SwapDataVerificationError("Unknown claim handler!");
+        if(claimHandler.getType()!==ChainSwapType.HTLC) throw new SwapDataVerificationError("Invalid claim handler!");
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        const {initialTxns, witness} = await claimHandler.getWitness(signer, swapData, secret, feeRate);
+        const action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
+        await action.addToTxs(initialTxns, feeRate);
+
+        this.logger.debug("txsClaimWithSecret(): creating claim transaction, swap: "+swapData.getClaimHash()+" witness: ", witness.map(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
+     */
+    async 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> {
+        const claimHandler: IClaimHandler<any, BitcoinOutputWitnessData | BitcoinWitnessData> = this.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if(claimHandler==null) throw new SwapDataVerificationError("Unknown claim handler!");
+        if(
+            claimHandler.getType()!==ChainSwapType.CHAIN_NONCED &&
+            claimHandler.getType()!==ChainSwapType.CHAIN_TXID &&
+            claimHandler.getType()!==ChainSwapType.CHAIN
+        ) throw new SwapDataVerificationError("Invalid claim handler!");
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        const {initialTxns, witness} = await claimHandler.getWitness(signer, swapData, {
+            tx,
+            vout,
+            requiredConfirmations,
+            commitedHeader,
+            btcRelay: this.root.btcRelay,
+            synchronizer,
+        }, feeRate);
+        const action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
+        await action.addToTxs(initialTxns, feeRate);
+
+        return initialTxns;
+    }
+
+    /**
+     * Get the estimated starknet transaction fee of the claim transaction
+     */
+    public async getClaimFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        let gasRequired = swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM;
+
+        const claimHandler: IClaimHandler<any, any> = this.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if(claimHandler!=null) gasRequired = sumStarknetGas(gasRequired, claimHandler.getGas(swapData));
+
+        return StarknetFees.getGasFee(gasRequired.l1, feeRate);
+    }
+
+}