@atomiqlabs/chain-starknet 1.0.0-beta.0

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

@@ -0,0 +1,226 @@
+import {SignatureVerificationError, SwapCommitStatus, SwapDataVerificationError} from "@atomiqlabs/base";
+import {bufferToBytes31Span, toBigInt, toHex, tryWithRetries} from "../../../utils/Utils";
+import {Buffer} from "buffer";
+import {StarknetSwapData} from "../StarknetSwapData";
+import {StarknetAction} from "../../base/StarknetAction";
+import {StarknetSwapModule} from "../StarknetSwapModule";
+import {BigNumberish} from "starknet";
+import {StarknetSigner} from "../../wallet/StarknetSigner";
+import {StarknetFees} from "../../base/modules/StarknetFees";
+import {StarknetTx} from "../../base/modules/StarknetTransactions";
+
+export type StarknetPreFetchVerification = {
+    pendingBlockTime?: number
+};
+
+const Initialize = [
+    { name: 'Swap hash', type: 'felt' },
+    { name: 'Timeout', type: 'timestamp' }
+];
+
+export class StarknetSwapInit extends StarknetSwapModule {
+
+    private static readonly GasCosts = {
+        INIT: {l1: 500, l2: 0},
+        INIT_PAY_IN: {l1: 1000, l2: 0},
+    };
+
+    /**
+     * bare Init action based on the data passed in swapData
+     *
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @private
+     */
+    private Init(swapData: StarknetSwapData, timeout: bigint, signature: BigNumberish[]): StarknetAction {
+        return new StarknetAction(
+            swapData.payIn ? swapData.offerer : swapData.claimer,
+            this.root,
+            this.contract.populateTransaction.initialize(
+                swapData.toEscrowStruct(),
+                signature,
+                timeout,
+                swapData.extraData==null || swapData.extraData==="" ? [] : bufferToBytes31Span(Buffer.from(swapData.extraData, "hex")).map(toHex)
+            ),
+            swapData.payIn ? StarknetSwapInit.GasCosts.INIT_PAY_IN : StarknetSwapInit.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
+     */
+    private getAuthPrefix(swapData: StarknetSwapData): string {
+        return swapData.isPayIn() ? "claim_initialize" : "initialize";
+    }
+
+    public async preFetchForInitSignatureVerification(): Promise<StarknetPreFetchVerification> {
+        return {
+            pendingBlockTime: await this.root.Blocks.getBlockTime("pending")
+        };
+    }
+
+    /**
+     * 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
+     */
+    public async signSwapInitialization(
+        signer: StarknetSigner,
+        swapData: StarknetSwapData,
+        authorizationTimeout: number
+    ): Promise<{prefix: string, timeout: string, signature: string}> {
+        const authTimeout = Math.floor(Date.now()/1000)+authorizationTimeout;
+
+        const signature = await this.root.Signatures.signTypedMessage(signer, Initialize, "Initialize", {
+            "Swap hash": "0x"+swapData.getEscrowHash(),
+            "Timeout": toHex(authTimeout)
+        });
+
+        return {
+            prefix: this.getAuthPrefix(swapData),
+            timeout: authTimeout.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
+     * @param preFetchData
+     * @public
+     */
+    public async isSignatureValid(
+        swapData: StarknetSwapData,
+        timeout: string,
+        prefix: string,
+        signature: string,
+        preFetchData?: StarknetPreFetchVerification
+    ): Promise<null> {
+        const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
+        const signer = swapData.isPayIn() ? swapData.claimer : swapData.offerer;
+
+        if(!swapData.isPayIn() && await this.root.isExpired(sender.toString(), swapData)) {
+            throw new SignatureVerificationError("Swap will expire too soon!");
+        }
+
+        if(prefix!==this.getAuthPrefix(swapData)) throw new SignatureVerificationError("Invalid prefix");
+
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const timeoutBN = BigInt(timeout);
+        const isExpired = (timeoutBN - currentTimestamp) < BigInt(this.root.authGracePeriod);
+        if (isExpired) throw new SignatureVerificationError("Authorization expired!");
+        if(await this.isSignatureExpired(timeout, preFetchData)) throw new SignatureVerificationError("Authorization expired!");
+
+        const valid = await this.root.Signatures.isValidSignature(signature, signer, Initialize, "Initialize", {
+            "Swap hash": "0x"+swapData.getEscrowHash(),
+            "Timeout": toHex(timeoutBN)
+        });
+
+        if(!valid) throw new 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
+     */
+    public async getSignatureExpiry(
+        timeout: string
+    ): Promise<number> {
+        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, compares the timestamp to the current "pending" block timestamp
+     *
+     * @param timeout
+     * @param preFetchData
+     * @public
+     */
+    public async isSignatureExpired(
+        timeout: string,
+        preFetchData?: StarknetPreFetchVerification
+    ): Promise<boolean> {
+        if(preFetchData==null || preFetchData.pendingBlockTime==null) {
+            preFetchData = await this.preFetchForInitSignatureVerification();
+        }
+        return preFetchData.pendingBlockTime > parseInt(timeout);
+    }
+
+    /**
+     * 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
+     */
+    public async txsInit(
+        swapData: StarknetSwapData,
+        timeout: string,
+        prefix: string,
+        signature: string,
+        skipChecks?: boolean,
+        feeRate?: string
+    ): Promise<StarknetTx[]> {
+        const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
+
+        if(!skipChecks) {
+            const [_, payStatus] = await Promise.all([
+                tryWithRetries(
+                    () => this.isSignatureValid(swapData, timeout, prefix, signature),
+                    this.retryPolicy, (e) => e instanceof SignatureVerificationError
+                ),
+                tryWithRetries(() => this.root.getCommitStatus(sender, swapData), this.retryPolicy)
+            ]);
+            if(payStatus!==SwapCommitStatus.NOT_COMMITED) throw new SwapDataVerificationError("Invoice already being paid for or paid");
+        }
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        const initAction = this.Init(swapData, BigInt(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() !== 0n) 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 [await 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
+     */
+    async getInitFee(swapData?: StarknetSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        return StarknetFees.getGasFee(swapData.payIn ? StarknetSwapInit.GasCosts.INIT_PAY_IN.l1 : StarknetSwapInit.GasCosts.INIT.l1, feeRate);
+    }
+}

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

@@ -0,0 +1,202 @@
+import {SignatureVerificationError, SwapDataVerificationError} from "@atomiqlabs/base";
+import {toHex, tryWithRetries} from "../../../utils/Utils";
+import {StarknetSwapModule} from "../StarknetSwapModule";
+import {StarknetSwapData} from "../StarknetSwapData";
+import {StarknetAction, StarknetGas, sumStarknetGas} from "../../base/StarknetAction";
+import {StarknetSwapContract} from "../StarknetSwapContract";
+import {IHandler} from "../handlers/IHandler";
+import {BigNumberish} from "starknet";
+import {StarknetTx} from "../../base/modules/StarknetTransactions";
+import {StarknetSigner} from "../../wallet/StarknetSigner";
+import {StarknetFees} from "../../base/modules/StarknetFees";
+
+const Refund = [
+    { name: 'Swap hash', type: 'felt' },
+    { name: 'Timeout', type: 'timestamp' }
+];
+
+export class StarknetSwapRefund extends StarknetSwapModule {
+
+    private static readonly GasCosts = {
+        REFUND: {l1: 750, l2: 0},
+        REFUND_PAY_OUT: {l1: 1250, l2: 0}
+    };
+
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param handlerGas
+     * @constructor
+     * @private
+     */
+    private Refund(
+        signer: string,
+        swapData: StarknetSwapData,
+        witness: BigNumberish[],
+        handlerGas?: StarknetGas
+    ): StarknetAction {
+        return new StarknetAction(signer, this.root,
+            this.contract.populateTransaction.refund(swapData.toEscrowStruct(), witness),
+            sumStarknetGas(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas)
+        );
+    }
+
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @constructor
+     * @private
+     */
+    private RefundWithSignature(
+        sender: string,
+        swapData: StarknetSwapData,
+        timeout: string,
+        signature: BigNumberish[]
+    ): StarknetAction {
+        return new StarknetAction(sender, this.root,
+            this.contract.populateTransaction.cooperative_refund(swapData.toEscrowStruct(), signature, BigInt(timeout)),
+            swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND
+        );
+    }
+
+    constructor(root: StarknetSwapContract) {
+        super(root);
+    }
+
+    public async signSwapRefund(
+        signer: StarknetSigner,
+        swapData: StarknetSwapData,
+        authorizationTimeout: number
+    ): Promise<{ prefix: string; timeout: string; signature: string }> {
+        const authPrefix = "refund";
+        const authTimeout = Math.floor(Date.now()/1000)+authorizationTimeout;
+
+        const signature = await this.root.Signatures.signTypedMessage(signer, Refund, "Refund", {
+            "Swap hash": "0x"+swapData.getEscrowHash(),
+            "Timeout": toHex(authTimeout)
+        });
+
+        return {
+            prefix: authPrefix,
+            timeout: authTimeout.toString(10),
+            signature: signature
+        };
+    }
+
+    public async isSignatureValid(
+        swapData: StarknetSwapData,
+        timeout: string,
+        prefix: string,
+        signature: string
+    ): Promise<null> {
+        if(prefix!=="refund") throw new SignatureVerificationError("Invalid prefix");
+
+        const expiryTimestamp = BigInt(timeout);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.root.authGracePeriod);
+        if(isExpired) throw new SignatureVerificationError("Authorization expired!");
+
+        const valid = await this.root.Signatures.isValidSignature(signature, swapData.claimer, Refund, "Refund", {
+            "Swap hash": "0x"+swapData.getEscrowHash(),
+            "Timeout": toHex(expiryTimestamp)
+        });
+
+        if(!valid) {
+            throw new SignatureVerificationError("Invalid signature!");
+        }
+
+        return null;
+    }
+
+    /**
+     * Creates transactions required for refunding timed out swap
+     *
+     * @param signer
+     * @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
+     */
+    public async txsRefund<T>(
+        signer: string,
+        swapData: StarknetSwapData,
+        check?: boolean,
+        feeRate?: string,
+        witnessData?: T
+    ): Promise<StarknetTx[]> {
+        const refundHandler: IHandler<any, T> = this.root.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
+        if(refundHandler==null) throw new Error("Invalid refund handler");
+
+        if(check && !await tryWithRetries(() => this.root.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
+            throw new SwapDataVerificationError("Not refundable yet!");
+        }
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        const {initialTxns, witness} = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
+
+        const action = this.Refund(signer, swapData, witness, refundHandler.getGas(swapData));
+        await 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 signer
+     * @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
+     */
+    public async txsRefundWithAuthorization(
+        signer: string,
+        swapData: StarknetSwapData,
+        timeout: string,
+        prefix: string,
+        signature: string,
+        check?: boolean,
+        feeRate?: string
+    ): Promise<StarknetTx[]> {
+        if(check && !await tryWithRetries(() => this.root.isCommited(swapData), this.retryPolicy)) {
+            throw new SwapDataVerificationError("Not correctly committed");
+        }
+        await tryWithRetries(
+            () => this.isSignatureValid(swapData, timeout, prefix, signature),
+            this.retryPolicy,
+            (e) => e instanceof SignatureVerificationError
+        );
+
+        const action = this.RefundWithSignature(signer, swapData, timeout, JSON.parse(signature));
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: "+swapData.getClaimHash()+
+            " auth expiry: "+timeout+" signature: "+signature);
+
+        return [await 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)
+     */
+    async getRefundFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        return StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT.l1 : StarknetSwapRefund.GasCosts.REFUND.l1, feeRate);
+    }
+
+}

package/src/starknet/wallet/StarknetKeypairWallet.ts

@@ -0,0 +1,34 @@
+import {Account, CallData, DeployAccountContractPayload, ec, hash, Provider} from "starknet";
+import {toHex} from "../../utils/Utils";
+
+const OZaccountClassHash = '0x066358a3bf5515033abe327a433e2947f9ee8dcd500ccb260f710b47039ebd36';
+
+//Openzeppelin Account wallet
+export class StarknetKeypairWallet extends Account {
+
+    public readonly publicKey: string;
+
+    constructor(provider: Provider, privateKey: string) {
+        const publicKey = ec.starkCurve.getStarkKey(toHex(privateKey));
+        // Calculate future address of the account
+        const OZaccountConstructorCallData = CallData.compile({ publicKey });
+        const OZcontractAddress = hash.calculateContractAddressFromHash(
+            publicKey,
+            OZaccountClassHash,
+            OZaccountConstructorCallData,
+            0
+        );
+        super(provider, OZcontractAddress, privateKey, "1");
+        this.publicKey = publicKey;
+    }
+
+    public getDeploymentData(): DeployAccountContractPayload {
+        return {
+            classHash: OZaccountClassHash,
+            constructorCalldata: CallData.compile({ publicKey: this.publicKey }),
+            addressSalt: this.publicKey,
+            contractAddress: this.address
+        }
+    }
+
+}

package/src/starknet/wallet/StarknetSigner.ts

@@ -0,0 +1,55 @@
+import {AbstractSigner} from "@atomiqlabs/base";
+import {Account, DeployAccountContractPayload} from "starknet";
+import {toHex} from "../../utils/Utils";
+
+export class StarknetSigner implements AbstractSigner {
+
+    account: Account;
+
+    isDeployed: boolean = null;
+
+    constructor(account: Account) {
+        this.account = account;
+    }
+
+    getPublicKey(): Promise<string> {
+        return this.account.signer.getPubKey();
+    }
+
+    getAddress(): string {
+        return toHex(this.account.address);
+    }
+
+    isWalletAccount() {
+        return (this.account as any).walletProvider!=null;
+    }
+
+    //TODO: Introduce proper nonce management!
+    async getNonce(): Promise<bigint> {
+        try {
+            return BigInt(await this.account.getNonceForAddress(this.getAddress()));
+        } catch (e) {
+            if(e.message!=null && e.message.includes("20: Contract not found")) {
+                return BigInt(0);
+            }
+            throw e;
+        }
+    }
+
+    async checkAndGetDeployPayload(nonce?: bigint): Promise<DeployAccountContractPayload | null> {
+        if(this.isDeployed) return null;
+
+        const _account: Account & {getDeploymentData?: () => DeployAccountContractPayload} = this.account;
+        if(_account.getDeploymentData!=null) {
+            //Check if deployed
+            nonce ??= BigInt(await this.getNonce());
+            this.isDeployed = nonce!=BigInt(0);
+            if(!this.isDeployed ) {
+                return _account.getDeploymentData();
+            }
+        }
+
+        return null;
+    }
+
+}