@atomiqlabs/chain-starknet 4.0.0-dev.9 → 5.0.1

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

@@ -4,7 +4,7 @@ import {Buffer} from "buffer";
 import {StarknetSwapData} from "../StarknetSwapData";
 import {StarknetAction} from "../../chain/StarknetAction";
 import {StarknetSwapModule} from "../StarknetSwapModule";
-import {BigNumberish, cairo} from "starknet";
+import {BigNumberish} from "starknet";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
 import {StarknetFees} from "../../chain/modules/StarknetFees";
 import {StarknetTx} from "../../chain/modules/StarknetTransactions";
@@ -15,45 +15,31 @@ export type StarknetPreFetchVerification = {
 
 const Initialize = [
     { name: 'Swap hash', type: 'felt' },
-    { name: 'Offerer', type: 'ContractAddress'},
-    { name: 'Claimer', type: 'ContractAddress'},
-    { name: 'Token amount', type: 'TokenAmount'},
-    { name: 'Pay in', type: 'bool'},
-    { name: 'Pay out', type: 'bool'},
-    { name: 'Tracking reputation', type: 'bool'},
-    { name: 'Claim handler', type: 'ContractAddress'},
-    { name: 'Claim data', type: 'felt'},
-    { name: 'Refund handler', type: 'ContractAddress'},
-    { name: 'Refund data', type: 'felt'},
-    { name: 'Security deposit', type: 'TokenAmount'},
-    { name: 'Claimer bounty', type: 'TokenAmount'},
-    { name: 'Claim action hash', type: 'felt'},
-    { name: 'Deadline', type: 'timestamp' }
+    { name: 'Timeout', type: 'timestamp' }
 ];
 
 export class StarknetSwapInit extends StarknetSwapModule {
 
     private static readonly GasCosts = {
-        INIT: {l1DataGas: 750, l2Gas: 8_000_000, l1Gas: 0},
-        INIT_PAY_IN: {l1DataGas: 500, l2Gas: 4_800_000, l1Gas: 0},
+        INIT: {l1: 500, l2: 0},
+        INIT_PAY_IN: {l1: 1000, l2: 0},
     };
 
     /**
      * bare Init action based on the data passed in swapData
      *
-     * @param signer
      * @param swapData
      * @param timeout
      * @param signature
      * @private
      */
-    private Init(signer: string, swapData: StarknetSwapData, timeout: bigint, signature: BigNumberish[]): StarknetAction {
+    private Init(swapData: StarknetSwapData, timeout: bigint, signature: BigNumberish[]): StarknetAction {
         return new StarknetAction(
-            signer,
+            swapData.payIn ? swapData.offerer : swapData.claimer,
             this.root,
             this.swapContract.populateTransaction.initialize(
                 swapData.toEscrowStruct(),
-                signature ?? [],
+                signature,
                 timeout,
                 swapData.extraData==null || swapData.extraData==="" ? [] : bufferToBytes31Span(Buffer.from(swapData.extraData, "hex")).map(toHex)
             ),
@@ -96,29 +82,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
 
         const signature = await this.root.Signatures.signTypedMessage(signer, Initialize, "Initialize", {
             "Swap hash": "0x"+swapData.getEscrowHash(),
-            "Offerer": swapData.offerer,
-            "Claimer": swapData.claimer,
-            "Token amount": {
-                token_address: swapData.token,
-                amount: cairo.uint256(swapData.amount)
-            },
-            "Pay in": swapData.isPayIn(),
-            "Pay out": swapData.isPayOut(),
-            "Tracking reputation": swapData.reputation,
-            "Refund handler": swapData.refundHandler,
-            "Claim handler": swapData.claimHandler,
-            "Claim data": "0x"+swapData.getClaimHash(),
-            "Refund data": swapData.refundData.startsWith("0x") ? swapData.refundData : "0x"+swapData.refundData,
-            "Security deposit": {
-                token_address: swapData.feeToken,
-                amount: cairo.uint256(swapData.securityDeposit)
-            },
-            "Claimer bounty": {
-                token_address: swapData.feeToken,
-                amount: cairo.uint256(swapData.claimerBounty)
-            },
-            "Claim action hash": 0n,
-            "Deadline": toHex(authTimeout)
+            "Timeout": toHex(authTimeout)
         });
 
         return {
@@ -131,7 +95,6 @@ export class StarknetSwapInit extends StarknetSwapModule {
     /**
      * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
      *
-     * @param sender
      * @param swapData
      * @param timeout
      * @param prefix
@@ -166,29 +129,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
 
         const valid = await this.root.Signatures.isValidSignature(signature, signer, Initialize, "Initialize", {
             "Swap hash": "0x"+swapData.getEscrowHash(),
-            "Offerer": swapData.offerer,
-            "Claimer": swapData.claimer,
-            "Token amount": {
-                token_address: swapData.token,
-                amount: cairo.uint256(swapData.amount)
-            },
-            "Pay in": swapData.isPayIn(),
-            "Pay out": swapData.isPayOut(),
-            "Tracking reputation": swapData.reputation,
-            "Refund handler": swapData.refundHandler,
-            "Claim handler": swapData.claimHandler,
-            "Claim data": "0x"+swapData.getClaimHash(),
-            "Refund data": swapData.refundData.startsWith("0x") ? swapData.refundData : "0x"+swapData.refundData,
-            "Security deposit": {
-                token_address: swapData.feeToken,
-                amount: cairo.uint256(swapData.securityDeposit)
-            },
-            "Claimer bounty": {
-                token_address: swapData.feeToken,
-                amount: cairo.uint256(swapData.claimerBounty)
-            },
-            "Claim action hash": 0n,
-            "Deadline": toHex(timeoutBN)
+            "Timeout": toHex(timeoutBN)
         });
 
         if(!valid) throw new SignatureVerificationError("Invalid signature!");
@@ -252,7 +193,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
     ): Promise<StarknetTx[]> {
         if(!skipChecks) {
             const [_, payStatus] = await Promise.all([
-                swapData.isOfferer(sender) && !swapData.reputation ? Promise.resolve() : tryWithRetries(
+                tryWithRetries(
                     () => this.isSignatureValid(sender, swapData, timeout, prefix, signature),
                     this.retryPolicy, (e) => e instanceof SignatureVerificationError
                 ),
@@ -263,7 +204,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
 
         feeRate ??= await this.root.Fees.getFeeRate();
 
-        const initAction = this.Init(sender, swapData, BigInt(timeout), JSON.parse(signature));
+        const initAction = this.Init(swapData, BigInt(timeout), JSON.parse(signature));
         if(swapData.payIn && swapData.isOfferer(sender)) initAction.addAction(
             this.root.Tokens.Approve(sender, this.swapContract.address, swapData.token, swapData.amount), 0
         ); //Add erc20 approve
@@ -283,6 +224,6 @@ export class StarknetSwapInit extends StarknetSwapModule {
      */
     async getInitFee(swapData?: StarknetSwapData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.root.Fees.getFeeRate();
-        return StarknetFees.getGasFee(swapData.payIn ? StarknetSwapInit.GasCosts.INIT_PAY_IN : StarknetSwapInit.GasCosts.INIT, feeRate);
+        return StarknetFees.getGasFee(swapData.payIn ? StarknetSwapInit.GasCosts.INIT_PAY_IN.l1 : StarknetSwapInit.GasCosts.INIT.l1, feeRate);
     }
 }

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

@@ -2,12 +2,13 @@ import {SignatureVerificationError, SwapDataVerificationError} from "@atomiqlabs
 import {toHex, tryWithRetries} from "../../../utils/Utils";
 import {StarknetSwapModule} from "../StarknetSwapModule";
 import {StarknetSwapData} from "../StarknetSwapData";
-import {StarknetAction} from "../../chain/StarknetAction";
+import {StarknetAction, StarknetGas, sumStarknetGas} from "../../chain/StarknetAction";
+import {StarknetSwapContract} from "../StarknetSwapContract";
 import {IHandler} from "../handlers/IHandler";
 import {BigNumberish} from "starknet";
 import {StarknetTx} from "../../chain/modules/StarknetTransactions";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
-import {StarknetFees, StarknetGas, starknetGasAdd} from "../../chain/modules/StarknetFees";
+import {StarknetFees} from "../../chain/modules/StarknetFees";
 
 const Refund = [
     { name: 'Swap hash', type: 'felt' },
@@ -17,8 +18,8 @@ const Refund = [
 export class StarknetSwapRefund extends StarknetSwapModule {
 
     private static readonly GasCosts = {
-        REFUND: {l1DataGas: 750, l2Gas: 4_000_000, l1Gas: 0},
-        REFUND_PAY_OUT: {l1DataGas: 900, l2Gas: 6_000_000, l1Gas: 0}
+        REFUND: {l1: 750, l2: 0},
+        REFUND_PAY_OUT: {l1: 1250, l2: 0}
     };
 
     /**
@@ -39,7 +40,7 @@ export class StarknetSwapRefund extends StarknetSwapModule {
     ): StarknetAction {
         return new StarknetAction(signer, this.root,
             this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness),
-            starknetGasAdd(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas)
+            sumStarknetGas(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas)
         );
     }
 
@@ -191,7 +192,7 @@ export class StarknetSwapRefund extends StarknetSwapModule {
      */
     async getRefundFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.root.Fees.getFeeRate();
-        return StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, feeRate);
+        return StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT.l1 : StarknetSwapRefund.GasCosts.REFUND.l1, feeRate);
     }
 
 }

package/src/utils/Utils.ts

@@ -1,4 +1,4 @@
-import {EDAMode} from "@starknet-io/starknet-types-08";
+import {EDAMode} from "starknet-types-07";
 import {BigNumberish, CallData, hash, Uint256} from "starknet";
 import {StarknetTx} from "../starknet/chain/modules/StarknetTransactions";
 import {Buffer} from "buffer";
@@ -34,14 +34,10 @@ export function onceAsync<T>(executor: () => Promise<T>): () => Promise<T> {
 
 export function getLogger(prefix: string) {
     return {
-        // @ts-ignore
-        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix+msg, ...args),
-        // @ts-ignore
-        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix+msg, ...args),
-        // @ts-ignore
-        warn: (msg, ...args) => (global.atomiqLogLevel==null || global.atomiqLogLevel >= 1) && console.warn(prefix+msg, ...args),
-        // @ts-ignore
-        error: (msg, ...args) => (global.atomiqLogLevel==null || global.atomiqLogLevel >= 0) && console.error(prefix+msg, ...args)
+        debug: (msg, ...args) => console.debug(prefix+msg, ...args),
+        info: (msg, ...args) => console.info(prefix+msg, ...args),
+        warn: (msg, ...args) => console.warn(prefix+msg, ...args),
+        error: (msg, ...args) => console.error(prefix+msg, ...args)
     };
 }
 
@@ -83,7 +79,7 @@ export function toHex(value: number | bigint | string | Buffer, length: number =
     switch(typeof(value)) {
         case "string":
             if(value.startsWith("0x")) {
-                return "0x"+value.slice(2).padStart(length, "0").toLowerCase();
+                return "0x"+value.slice(2).padStart(length, "0");
             } else {
                 return "0x"+BigInt(value).toString(16).padStart(length, "0");
             }