@atomiqlabs/chain-starknet 1.0.9 → 2.0.0-beta.1

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

@@ -2,11 +2,11 @@ import {ChainSwapType, RelaySynchronizer, SwapDataVerificationError} from "@atom
 import {toHex} from "../../../utils/Utils";
 import {StarknetSwapModule} from "../StarknetSwapModule";
 import {StarknetSwapData} from "../StarknetSwapData";
-import {StarknetAction, StarknetGas, sumStarknetGas} from "../../base/StarknetAction";
+import {StarknetAction, StarknetGas, sumStarknetGas} from "../../chain/StarknetAction";
 import {BigNumberish} from "starknet";
 import {IClaimHandler} from "../handlers/claim/ClaimHandlers";
-import {StarknetTx} from "../../base/modules/StarknetTransactions";
-import {StarknetFees} from "../../base/modules/StarknetFees";
+import {StarknetTx} from "../../chain/modules/StarknetTransactions";
+import {StarknetFees} from "../../chain/modules/StarknetFees";
 import {StarknetBtcStoredHeader} from "../../btcrelay/headers/StarknetBtcStoredHeader";
 import {BitcoinOutputWitnessData} from "../handlers/claim/btc/BitcoinOutputClaimHandler";
 import {BitcoinWitnessData} from "../handlers/claim/btc/IBitcoinClaimHandler";
@@ -36,7 +36,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
         claimHandlerGas?: StarknetGas
     ): StarknetAction {
         return new StarknetAction(signer, this.root,
-            this.contract.populateTransaction.claim(swapData.toEscrowStruct(), witness),
+            this.swapContract.populateTransaction.claim(swapData.toEscrowStruct(), witness),
             sumStarknetGas(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas)
         );
     }
@@ -60,11 +60,11 @@ export class StarknetSwapClaim extends StarknetSwapModule {
     ): 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)) {
+        if(checkExpiry && await this.contract.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()];
+        const claimHandler: IClaimHandler<Buffer, string> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
         if(claimHandler==null) throw new SwapDataVerificationError("Unknown claim handler!");
         if(claimHandler.getType()!==ChainSwapType.HTLC) throw new SwapDataVerificationError("Invalid claim handler!");
 
@@ -101,7 +101,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
         synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>,
         feeRate?: string
     ): Promise<StarknetTx[] | null> {
-        const claimHandler: IClaimHandler<any, BitcoinOutputWitnessData | BitcoinWitnessData> = this.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        const claimHandler: IClaimHandler<any, BitcoinOutputWitnessData | BitcoinWitnessData> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
         if(claimHandler==null) throw new SwapDataVerificationError("Unknown claim handler!");
         if(
             claimHandler.getType()!==ChainSwapType.CHAIN_NONCED &&
@@ -116,7 +116,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
             vout,
             requiredConfirmations,
             commitedHeader,
-            btcRelay: this.root.btcRelay,
+            btcRelay: this.contract.btcRelay,
             synchronizer,
         }, feeRate);
         const action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
@@ -133,7 +133,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
 
         let gasRequired = swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM;
 
-        const claimHandler: IClaimHandler<any, any> = this.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        const claimHandler: IClaimHandler<any, any> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
         if(claimHandler!=null) gasRequired = sumStarknetGas(gasRequired, claimHandler.getGas(swapData));
 
         return StarknetFees.getGasFee(gasRequired.l1, feeRate);

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

@@ -2,12 +2,12 @@ import {SignatureVerificationError, SwapCommitStatus, SwapDataVerificationError}
 import {bufferToBytes31Span, toBigInt, toHex, tryWithRetries} from "../../../utils/Utils";
 import {Buffer} from "buffer";
 import {StarknetSwapData} from "../StarknetSwapData";
-import {StarknetAction} from "../../base/StarknetAction";
+import {StarknetAction} from "../../chain/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";
+import {StarknetFees} from "../../chain/modules/StarknetFees";
+import {StarknetTx} from "../../chain/modules/StarknetTransactions";
 
 export type StarknetPreFetchVerification = {
     pendingBlockTime?: number
@@ -37,7 +37,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
         return new StarknetAction(
             swapData.payIn ? swapData.offerer : swapData.claimer,
             this.root,
-            this.contract.populateTransaction.initialize(
+            this.swapContract.populateTransaction.initialize(
                 swapData.toEscrowStruct(),
                 signature,
                 timeout,
@@ -112,7 +112,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
         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)) {
+        if(!swapData.isPayIn() && await this.contract.isExpired(sender.toString(), swapData)) {
             throw new SignatureVerificationError("Swap will expire too soon!");
         }
 
@@ -120,7 +120,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
 
         const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
         const timeoutBN = BigInt(timeout);
-        const isExpired = (timeoutBN - currentTimestamp) < BigInt(this.root.authGracePeriod);
+        const isExpired = (timeoutBN - currentTimestamp) < BigInt(this.contract.authGracePeriod);
         if (isExpired) throw new SignatureVerificationError("Authorization expired!");
         if(await this.isSignatureExpired(timeout, preFetchData)) throw new SignatureVerificationError("Authorization expired!");
 
@@ -144,7 +144,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
         timeout: string
     ): Promise<number> {
         const now = Date.now();
-        const timeoutExpiryTime = (parseInt(timeout)-this.root.authGracePeriod)*1000;
+        const timeoutExpiryTime = (parseInt(timeout)-this.contract.authGracePeriod)*1000;
 
         if(timeoutExpiryTime<now) return 0;
 
@@ -194,7 +194,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
                     () => this.isSignatureValid(swapData, timeout, prefix, signature),
                     this.retryPolicy, (e) => e instanceof SignatureVerificationError
                 ),
-                tryWithRetries(() => this.root.getCommitStatus(sender, swapData), this.retryPolicy)
+                tryWithRetries(() => this.contract.getCommitStatus(sender, swapData), this.retryPolicy)
             ]);
             if(payStatus!==SwapCommitStatus.NOT_COMMITED) throw new SwapDataVerificationError("Invoice already being paid for or paid");
         }
@@ -203,10 +203,10 @@ export class StarknetSwapInit extends StarknetSwapModule {
 
         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
+            this.root.Tokens.Approve(sender, this.swapContract.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
+            this.root.Tokens.Approve(sender, this.swapContract.address, swapData.feeToken, swapData.getTotalDeposit()), 0
         ); //Add deposit erc20 approve
 
         this.logger.debug("txsInitPayIn(): create swap init TX, swap: "+swapData.getClaimHash()+

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

@@ -2,13 +2,13 @@ import {SignatureVerificationError, SwapDataVerificationError} from "@atomiqlabs
 import {toHex, tryWithRetries} from "../../../utils/Utils";
 import {StarknetSwapModule} from "../StarknetSwapModule";
 import {StarknetSwapData} from "../StarknetSwapData";
-import {StarknetAction, StarknetGas, sumStarknetGas} from "../../base/StarknetAction";
+import {StarknetAction, StarknetGas, sumStarknetGas} from "../../chain/StarknetAction";
 import {StarknetSwapContract} from "../StarknetSwapContract";
 import {IHandler} from "../handlers/IHandler";
 import {BigNumberish} from "starknet";
-import {StarknetTx} from "../../base/modules/StarknetTransactions";
+import {StarknetTx} from "../../chain/modules/StarknetTransactions";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
-import {StarknetFees} from "../../base/modules/StarknetFees";
+import {StarknetFees} from "../../chain/modules/StarknetFees";
 
 const Refund = [
     { name: 'Swap hash', type: 'felt' },
@@ -39,7 +39,7 @@ export class StarknetSwapRefund extends StarknetSwapModule {
         handlerGas?: StarknetGas
     ): StarknetAction {
         return new StarknetAction(signer, this.root,
-            this.contract.populateTransaction.refund(swapData.toEscrowStruct(), witness),
+            this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness),
             sumStarknetGas(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas)
         );
     }
@@ -61,15 +61,11 @@ export class StarknetSwapRefund extends StarknetSwapModule {
         signature: BigNumberish[]
     ): StarknetAction {
         return new StarknetAction(sender, this.root,
-            this.contract.populateTransaction.cooperative_refund(swapData.toEscrowStruct(), signature, BigInt(timeout)),
+            this.swapContract.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,
@@ -101,7 +97,7 @@ export class StarknetSwapRefund extends StarknetSwapModule {
         const expiryTimestamp = BigInt(timeout);
         const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
 
-        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.root.authGracePeriod);
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
         if(isExpired) throw new SignatureVerificationError("Authorization expired!");
 
         const valid = await this.root.Signatures.isValidSignature(signature, swapData.claimer, Refund, "Refund", {
@@ -132,10 +128,10 @@ export class StarknetSwapRefund extends StarknetSwapModule {
         feeRate?: string,
         witnessData?: T
     ): Promise<StarknetTx[]> {
-        const refundHandler: IHandler<any, T> = this.root.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
+        const refundHandler: IHandler<any, T> = this.contract.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)) {
+        if(check && !await tryWithRetries(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
             throw new SwapDataVerificationError("Not refundable yet!");
         }
 
@@ -171,7 +167,7 @@ export class StarknetSwapRefund extends StarknetSwapModule {
         check?: boolean,
         feeRate?: string
     ): Promise<StarknetTx[]> {
-        if(check && !await tryWithRetries(() => this.root.isCommited(swapData), this.retryPolicy)) {
+        if(check && !await tryWithRetries(() => this.contract.isCommited(swapData), this.retryPolicy)) {
             throw new SwapDataVerificationError("Not correctly committed");
         }
         await tryWithRetries(

package/src/starknet/wallet/StarknetSigner.ts

@@ -27,7 +27,7 @@ export class StarknetSigner implements AbstractSigner {
     //TODO: Introduce proper nonce management!
     async getNonce(): Promise<bigint> {
         try {
-            return BigInt(await this.account.getNonceForAddress(this.getAddress()));
+            return BigInt(await this.account.getNonceForAddress(this.getAddress(), "pending"));
         } catch (e) {
             if(e.message!=null && e.message.includes("20: Contract not found")) {
                 return BigInt(0);

package/src/utils/Utils.ts

@@ -1,6 +1,6 @@
 import {EDAMode} from "starknet-types-07";
 import {BigNumberish, CallData, hash, Uint256} from "starknet";
-import {StarknetTx} from "../starknet/base/modules/StarknetTransactions";
+import {StarknetTx} from "../starknet/chain/modules/StarknetTransactions";
 import {Buffer} from "buffer";
 import {StarknetSwapData} from "../starknet/swaps/StarknetSwapData";
 import {IClaimHandler} from "../starknet/swaps/handlers/claim/ClaimHandlers";
@@ -150,7 +150,7 @@ export function u32ReverseEndianness(value: number): number {
         ((valueBN >> 24n) & 0xFFn));
 }
 
-export function bigNumberishToBuffer(value: BigNumberish | Uint256, length: number): Buffer {
+export function bigNumberishToBuffer(value: BigNumberish | Uint256, length?: number): Buffer {
     if(isUint256(value)) {
         return Buffer.concat([bigNumberishToBuffer(value.high, 16), bigNumberishToBuffer(value.low, 16)])
     }
@@ -163,7 +163,8 @@ export function bigNumberishToBuffer(value: BigNumberish | Uint256, length: numb
     } else {
         value = value.toString(16);
     }
-    const buff = Buffer.from(value.padStart(length*2, "0"), "hex");
+    if(length!=null) value = value.padStart(length*2, "0");
+    const buff = Buffer.from(value, "hex");
     if(buff.length > length) return buff.slice(buff.length-length);
     return buff;
 }

package/dist/starknet/base/StarknetBase.d.ts

@@ -1,34 +0,0 @@
-import { Provider, constants } from "starknet";
-import { StarknetTransactions } from "./modules/StarknetTransactions";
-import { StarknetFees } from "./modules/StarknetFees";
-import { StarknetAddresses } from "./modules/StarknetAddresses";
-import { StarknetTokens } from "./modules/StarknetTokens";
-import { StarknetEvents } from "./modules/StarknetEvents";
-import { StarknetSignatures } from "./modules/StarknetSignatures";
-import { StarknetAccounts } from "./modules/StarknetAccounts";
-import { StarknetBlocks } from "./modules/StarknetBlocks";
-export type StarknetRetryPolicy = {
-    maxRetries?: number;
-    delay?: number;
-    exponential?: boolean;
-};
-export declare class StarknetBase {
-    readonly provider: Provider;
-    readonly retryPolicy: StarknetRetryPolicy;
-    readonly starknetChainId: constants.StarknetChainId;
-    Fees: StarknetFees;
-    readonly Tokens: StarknetTokens;
-    readonly Transactions: StarknetTransactions;
-    readonly Addresses: StarknetAddresses;
-    readonly Signatures: StarknetSignatures;
-    readonly Events: StarknetEvents;
-    readonly Accounts: StarknetAccounts;
-    readonly Blocks: StarknetBlocks;
-    protected readonly logger: {
-        debug: (msg: any, ...args: any[]) => void;
-        info: (msg: any, ...args: any[]) => void;
-        warn: (msg: any, ...args: any[]) => void;
-        error: (msg: any, ...args: any[]) => void;
-    };
-    constructor(chainId: constants.StarknetChainId, provider: Provider, retryPolicy?: StarknetRetryPolicy, solanaFeeEstimator?: StarknetFees);
-}

package/dist/starknet/base/StarknetBase.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetBase = void 0;
-const Utils_1 = require("../../utils/Utils");
-const StarknetTransactions_1 = require("./modules/StarknetTransactions");
-const StarknetFees_1 = require("./modules/StarknetFees");
-const StarknetAddresses_1 = require("./modules/StarknetAddresses");
-const StarknetTokens_1 = require("./modules/StarknetTokens");
-const StarknetEvents_1 = require("./modules/StarknetEvents");
-const StarknetSignatures_1 = require("./modules/StarknetSignatures");
-const StarknetAccounts_1 = require("./modules/StarknetAccounts");
-const StarknetBlocks_1 = require("./modules/StarknetBlocks");
-class StarknetBase {
-    constructor(chainId, provider, retryPolicy, solanaFeeEstimator = new StarknetFees_1.StarknetFees(provider)) {
-        this.logger = (0, Utils_1.getLogger)(this.constructor.name + ": ");
-        this.starknetChainId = chainId;
-        this.provider = provider;
-        this.retryPolicy = retryPolicy;
-        this.Fees = solanaFeeEstimator;
-        this.Tokens = new StarknetTokens_1.StarknetTokens(this);
-        this.Transactions = new StarknetTransactions_1.StarknetTransactions(this);
-        this.Addresses = new StarknetAddresses_1.StarknetAddresses(this);
-        this.Signatures = new StarknetSignatures_1.StarknetSignatures(this);
-        this.Events = new StarknetEvents_1.StarknetEvents(this);
-        this.Accounts = new StarknetAccounts_1.StarknetAccounts(this);
-        this.Blocks = new StarknetBlocks_1.StarknetBlocks(this);
-    }
-}
-exports.StarknetBase = StarknetBase;

package/src/starknet/base/StarknetBase.ts

@@ -1,56 +0,0 @@
-import {Provider, constants} from "starknet";
-import {getLogger} from "../../utils/Utils";
-import {StarknetTransactions} from "./modules/StarknetTransactions";
-import {StarknetFees} from "./modules/StarknetFees";
-import {StarknetAddresses} from "./modules/StarknetAddresses";
-import {StarknetTokens} from "./modules/StarknetTokens";
-import {StarknetEvents} from "./modules/StarknetEvents";
-import {StarknetSignatures} from "./modules/StarknetSignatures";
-import {StarknetAccounts} from "./modules/StarknetAccounts";
-import {StarknetBlocks} from "./modules/StarknetBlocks";
-
-export type StarknetRetryPolicy = {
-    maxRetries?: number,
-    delay?: number,
-    exponential?: boolean
-}
-
-export class StarknetBase {
-
-    readonly provider: Provider;
-    readonly retryPolicy: StarknetRetryPolicy;
-
-    public readonly starknetChainId: constants.StarknetChainId;
-
-    public Fees: StarknetFees;
-    public readonly Tokens: StarknetTokens;
-    public readonly Transactions: StarknetTransactions;
-    public readonly Addresses: StarknetAddresses;
-    public readonly Signatures: StarknetSignatures;
-    public readonly Events: StarknetEvents;
-    public readonly Accounts: StarknetAccounts;
-    public readonly Blocks: StarknetBlocks;
-
-    protected readonly logger = getLogger(this.constructor.name+": ");
-
-    constructor(
-        chainId: constants.StarknetChainId,
-        provider: Provider,
-        retryPolicy?: StarknetRetryPolicy,
-        solanaFeeEstimator: StarknetFees = new StarknetFees(provider)
-    ) {
-        this.starknetChainId = chainId;
-        this.provider = provider;
-        this.retryPolicy = retryPolicy;
-
-        this.Fees = solanaFeeEstimator;
-        this.Tokens = new StarknetTokens(this);
-        this.Transactions = new StarknetTransactions(this);
-        this.Addresses = new StarknetAddresses(this);
-        this.Signatures = new StarknetSignatures(this);
-        this.Events = new StarknetEvents(this);
-        this.Accounts = new StarknetAccounts(this);
-        this.Blocks = new StarknetBlocks(this);
-    }
-
-}