@atomiqlabs/chain-solana 13.5.13 → 13.5.14

package/src/solana/chain/modules/SolanaSignatures.ts

@@ -1,40 +1,40 @@
-import {SolanaModule} from "../SolanaModule";
-import {sign} from "tweetnacl";
-import {PublicKey} from "@solana/web3.js";
-import {Buffer} from "buffer";
-import {SolanaSigner} from "../../wallet/SolanaSigner";
-import {sha256} from "@noble/hashes/sha2";
-
-export class SolanaSignatures extends SolanaModule {
-
-    ///////////////////
-    //// Data signatures
-    /**
-     * Produces an ed25519 signature over the sha256 of a specified data Buffer, only works with providers which
-     *  expose their private key (i.e. backend based, not browser wallet based)
-     *
-     * @param signer
-     * @param data data to sign
-     */
-    getDataSignature(signer: SolanaSigner, data: Buffer): Promise<string> {
-        if(signer.keypair==null) throw new Error("Unsupported");
-        const buff = sha256(data);
-        const signature = sign.detached(buff, signer.keypair.secretKey);
-
-        return Promise.resolve(Buffer.from(signature).toString("hex"));
-    }
-
-    /**
-     * Checks whether a signature is a valid Ed25519 signature produced by publicKey over a data message (computes
-     *  sha256 hash of the message)
-     *
-     * @param data signed data
-     * @param signature data signature
-     * @param publicKey public key of the signer
-     */
-    isValidDataSignature(data: Buffer, signature: string, publicKey: string): Promise<boolean> {
-        const hash = sha256(data);
-        return Promise.resolve(sign.detached.verify(hash, Buffer.from(signature, "hex"), new PublicKey(publicKey).toBuffer()));
-    }
-
+import {SolanaModule} from "../SolanaModule";
+import {sign} from "tweetnacl";
+import {PublicKey} from "@solana/web3.js";
+import {Buffer} from "buffer";
+import {SolanaSigner} from "../../wallet/SolanaSigner";
+import {sha256} from "@noble/hashes/sha2";
+
+export class SolanaSignatures extends SolanaModule {
+
+    ///////////////////
+    //// Data signatures
+    /**
+     * Produces an ed25519 signature over the sha256 of a specified data Buffer, only works with providers which
+     *  expose their private key (i.e. backend based, not browser wallet based)
+     *
+     * @param signer
+     * @param data data to sign
+     */
+    getDataSignature(signer: SolanaSigner, data: Buffer): Promise<string> {
+        if(signer.keypair==null) throw new Error("Unsupported");
+        const buff = sha256(data);
+        const signature = sign.detached(buff, signer.keypair.secretKey);
+
+        return Promise.resolve(Buffer.from(signature).toString("hex"));
+    }
+
+    /**
+     * Checks whether a signature is a valid Ed25519 signature produced by publicKey over a data message (computes
+     *  sha256 hash of the message)
+     *
+     * @param data signed data
+     * @param signature data signature
+     * @param publicKey public key of the signer
+     */
+    isValidDataSignature(data: Buffer, signature: string, publicKey: string): Promise<boolean> {
+        const hash = sha256(data);
+        return Promise.resolve(sign.detached.verify(hash, Buffer.from(signature, "hex"), new PublicKey(publicKey).toBuffer()));
+    }
+
 }

package/src/solana/chain/modules/SolanaSlots.ts

@@ -1,86 +1,86 @@
-import {SolanaModule} from "../SolanaModule";
-import {Commitment} from "@solana/web3.js";
-
-
-export class SolanaSlots extends SolanaModule {
-
-    public readonly SLOT_CACHE_SLOTS = 12;
-    public readonly SLOT_CACHE_TIME = this.SLOT_CACHE_SLOTS*this.root._SLOT_TIME;
-
-    private slotCache: {
-        [key in Commitment]?: {
-            slot: Promise<number>,
-            timestamp: number
-        }
-    } = {};
-
-    /**
-     * Initiates fetch of a given slot & saves it to cache
-     *
-     * @param commitment
-     * @private
-     */
-    private fetchAndSaveSlot(commitment: Commitment): {slot: Promise<number>, timestamp: number} {
-        const slotPromise = this.connection.getSlot(commitment);
-        const timestamp = Date.now();
-        this.slotCache[commitment] = {
-            slot: slotPromise,
-            timestamp
-        }
-        slotPromise.catch(() => {
-            const slotCache = this.slotCache[commitment];
-            if(slotCache!=null && slotCache.slot===slotPromise) delete this.slotCache[commitment];
-        })
-        return {
-            slot: slotPromise,
-            timestamp
-        }
-    }
-
-    ///////////////////
-    //// Slots
-    /**
-     * Gets the latest slot for a given commitment, with the timestamp of when that slot was actually retrieved from
-     *  the RPC (useful for when slots are cached), does no estimation on the current slot number based on cached value
-     *
-     * @param commitment
-     */
-    public async getSlotAndTimestamp(commitment: Commitment): Promise<{
-        slot: number,
-        timestamp: number
-    }> {
-        let cachedSlotData = this.slotCache[commitment];
-
-        if(cachedSlotData==null || Date.now()-cachedSlotData.timestamp>this.SLOT_CACHE_TIME) {
-            cachedSlotData = this.fetchAndSaveSlot(commitment);
-        }
-
-        return {
-            slot: await cachedSlotData.slot,
-            timestamp: cachedSlotData.timestamp
-        };
-    }
-
-    /**
-     * Gets the slot for a given commitment, uses slot cache & tries to estimate current slot based on the cached
-     *  value, cache has relatively short expiry of just 12 slots (4.8 seconds)
-     *
-     * @remarks Doesn't try to extrapolate the slot number for `finalized` commitment level
-     *
-     * @param commitment
-     */
-    public async getSlot(commitment: Commitment): Promise<number> {
-        let cachedSlotData = this.slotCache[commitment];
-
-        if(cachedSlotData!=null && Date.now()-cachedSlotData.timestamp<this.SLOT_CACHE_TIME) {
-            if(commitment==="finalized") return await cachedSlotData.slot;
-            return (await cachedSlotData.slot) + Math.floor((Date.now()-cachedSlotData.timestamp)/this.root._SLOT_TIME);
-        }
-
-        cachedSlotData = this.fetchAndSaveSlot(commitment);
-
-        return await cachedSlotData.slot;
-    }
-
-
+import {SolanaModule} from "../SolanaModule";
+import {Commitment} from "@solana/web3.js";
+
+
+export class SolanaSlots extends SolanaModule {
+
+    public readonly SLOT_CACHE_SLOTS = 12;
+    public readonly SLOT_CACHE_TIME = this.SLOT_CACHE_SLOTS*this.root._SLOT_TIME;
+
+    private slotCache: {
+        [key in Commitment]?: {
+            slot: Promise<number>,
+            timestamp: number
+        }
+    } = {};
+
+    /**
+     * Initiates fetch of a given slot & saves it to cache
+     *
+     * @param commitment
+     * @private
+     */
+    private fetchAndSaveSlot(commitment: Commitment): {slot: Promise<number>, timestamp: number} {
+        const slotPromise = this.connection.getSlot(commitment);
+        const timestamp = Date.now();
+        this.slotCache[commitment] = {
+            slot: slotPromise,
+            timestamp
+        }
+        slotPromise.catch(() => {
+            const slotCache = this.slotCache[commitment];
+            if(slotCache!=null && slotCache.slot===slotPromise) delete this.slotCache[commitment];
+        })
+        return {
+            slot: slotPromise,
+            timestamp
+        }
+    }
+
+    ///////////////////
+    //// Slots
+    /**
+     * Gets the latest slot for a given commitment, with the timestamp of when that slot was actually retrieved from
+     *  the RPC (useful for when slots are cached), does no estimation on the current slot number based on cached value
+     *
+     * @param commitment
+     */
+    public async getSlotAndTimestamp(commitment: Commitment): Promise<{
+        slot: number,
+        timestamp: number
+    }> {
+        let cachedSlotData = this.slotCache[commitment];
+
+        if(cachedSlotData==null || Date.now()-cachedSlotData.timestamp>this.SLOT_CACHE_TIME) {
+            cachedSlotData = this.fetchAndSaveSlot(commitment);
+        }
+
+        return {
+            slot: await cachedSlotData.slot,
+            timestamp: cachedSlotData.timestamp
+        };
+    }
+
+    /**
+     * Gets the slot for a given commitment, uses slot cache & tries to estimate current slot based on the cached
+     *  value, cache has relatively short expiry of just 12 slots (4.8 seconds)
+     *
+     * @remarks Doesn't try to extrapolate the slot number for `finalized` commitment level
+     *
+     * @param commitment
+     */
+    public async getSlot(commitment: Commitment): Promise<number> {
+        let cachedSlotData = this.slotCache[commitment];
+
+        if(cachedSlotData!=null && Date.now()-cachedSlotData.timestamp<this.SLOT_CACHE_TIME) {
+            if(commitment==="finalized") return await cachedSlotData.slot;
+            return (await cachedSlotData.slot) + Math.floor((Date.now()-cachedSlotData.timestamp)/this.root._SLOT_TIME);
+        }
+
+        cachedSlotData = this.fetchAndSaveSlot(commitment);
+
+        return await cachedSlotData.slot;
+    }
+
+
 }