@atomiqlabs/chain-solana 12.0.13 → 12.0.15

package/dist/solana/chain/modules/SolanaSignatures.d.ts

@@ -1,23 +1,23 @@
-/// <reference types="node" />
-import { SolanaModule } from "../SolanaModule";
-import { Buffer } from "buffer";
-import { SolanaSigner } from "../../wallet/SolanaSigner";
-export declare class SolanaSignatures extends SolanaModule {
-    /**
-     * 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>;
-    /**
-     * 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>;
-}
+/// <reference types="node" />
+import { SolanaModule } from "../SolanaModule";
+import { Buffer } from "buffer";
+import { SolanaSigner } from "../../wallet/SolanaSigner";
+export declare class SolanaSignatures extends SolanaModule {
+    /**
+     * 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>;
+    /**
+     * 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>;
+}

package/dist/solana/chain/modules/SolanaSignatures.js

@@ -1,39 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaSignatures = void 0;
-const SolanaModule_1 = require("../SolanaModule");
-const tweetnacl_1 = require("tweetnacl");
-const web3_js_1 = require("@solana/web3.js");
-const buffer_1 = require("buffer");
-const sha2_1 = require("@noble/hashes/sha2");
-class SolanaSignatures extends SolanaModule_1.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, data) {
-        if (signer.keypair == null)
-            throw new Error("Unsupported");
-        const buff = (0, sha2_1.sha256)(data);
-        const signature = tweetnacl_1.sign.detached(buff, signer.keypair.secretKey);
-        return Promise.resolve(buffer_1.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, signature, publicKey) {
-        const hash = (0, sha2_1.sha256)(data);
-        return Promise.resolve(tweetnacl_1.sign.detached.verify(hash, buffer_1.Buffer.from(signature, "hex"), new web3_js_1.PublicKey(publicKey).toBuffer()));
-    }
-}
-exports.SolanaSignatures = SolanaSignatures;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaSignatures = void 0;
+const SolanaModule_1 = require("../SolanaModule");
+const tweetnacl_1 = require("tweetnacl");
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("buffer");
+const sha2_1 = require("@noble/hashes/sha2");
+class SolanaSignatures extends SolanaModule_1.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, data) {
+        if (signer.keypair == null)
+            throw new Error("Unsupported");
+        const buff = (0, sha2_1.sha256)(data);
+        const signature = tweetnacl_1.sign.detached(buff, signer.keypair.secretKey);
+        return Promise.resolve(buffer_1.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, signature, publicKey) {
+        const hash = (0, sha2_1.sha256)(data);
+        return Promise.resolve(tweetnacl_1.sign.detached.verify(hash, buffer_1.Buffer.from(signature, "hex"), new web3_js_1.PublicKey(publicKey).toBuffer()));
+    }
+}
+exports.SolanaSignatures = SolanaSignatures;

package/dist/solana/chain/modules/SolanaSlots.d.ts

@@ -1,31 +1,31 @@
-import { SolanaModule } from "../SolanaModule";
-import { Commitment } from "@solana/web3.js";
-export declare class SolanaSlots extends SolanaModule {
-    readonly SLOT_CACHE_SLOTS = 12;
-    readonly SLOT_CACHE_TIME: number;
-    private slotCache;
-    /**
-     * Initiates fetch of a given slot & saves it to cache
-     *
-     * @param commitment
-     * @private
-     */
-    private fetchAndSaveSlot;
-    /**
-     * 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
-     */
-    getSlotAndTimestamp(commitment: Commitment): Promise<{
-        slot: number;
-        timestamp: number;
-    }>;
-    /**
-     * 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)
-     *
-     * @param commitment
-     */
-    getSlot(commitment: Commitment): Promise<number>;
-}
+import { SolanaModule } from "../SolanaModule";
+import { Commitment } from "@solana/web3.js";
+export declare class SolanaSlots extends SolanaModule {
+    readonly SLOT_CACHE_SLOTS = 12;
+    readonly SLOT_CACHE_TIME: number;
+    private slotCache;
+    /**
+     * Initiates fetch of a given slot & saves it to cache
+     *
+     * @param commitment
+     * @private
+     */
+    private fetchAndSaveSlot;
+    /**
+     * 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
+     */
+    getSlotAndTimestamp(commitment: Commitment): Promise<{
+        slot: number;
+        timestamp: number;
+    }>;
+    /**
+     * 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)
+     *
+     * @param commitment
+     */
+    getSlot(commitment: Commitment): Promise<number>;
+}

package/dist/solana/chain/modules/SolanaSlots.js

@@ -1,68 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaSlots = void 0;
-const SolanaModule_1 = require("../SolanaModule");
-class SolanaSlots extends SolanaModule_1.SolanaModule {
-    constructor() {
-        super(...arguments);
-        this.SLOT_CACHE_SLOTS = 12;
-        this.SLOT_CACHE_TIME = this.SLOT_CACHE_SLOTS * this.root.SLOT_TIME;
-        this.slotCache = {};
-    }
-    /**
-     * Initiates fetch of a given slot & saves it to cache
-     *
-     * @param commitment
-     * @private
-     */
-    fetchAndSaveSlot(commitment) {
-        const slotPromise = this.connection.getSlot(commitment);
-        const timestamp = Date.now();
-        this.slotCache[commitment] = {
-            slot: slotPromise,
-            timestamp
-        };
-        slotPromise.catch(e => {
-            if (this.slotCache[commitment] != null && this.slotCache[commitment].slot === slotPromise)
-                delete this.slotCache[commitment];
-            throw e;
-        });
-        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
-     */
-    async getSlotAndTimestamp(commitment) {
-        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)
-     *
-     * @param commitment
-     */
-    async getSlot(commitment) {
-        let cachedSlotData = this.slotCache[commitment];
-        if (cachedSlotData != null && Date.now() - cachedSlotData.timestamp < this.SLOT_CACHE_TIME) {
-            return (await cachedSlotData.slot) + Math.floor((Date.now() - cachedSlotData.timestamp) / this.root.SLOT_TIME);
-        }
-        cachedSlotData = this.fetchAndSaveSlot(commitment);
-        return await cachedSlotData.slot;
-    }
-}
-exports.SolanaSlots = SolanaSlots;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaSlots = void 0;
+const SolanaModule_1 = require("../SolanaModule");
+class SolanaSlots extends SolanaModule_1.SolanaModule {
+    constructor() {
+        super(...arguments);
+        this.SLOT_CACHE_SLOTS = 12;
+        this.SLOT_CACHE_TIME = this.SLOT_CACHE_SLOTS * this.root.SLOT_TIME;
+        this.slotCache = {};
+    }
+    /**
+     * Initiates fetch of a given slot & saves it to cache
+     *
+     * @param commitment
+     * @private
+     */
+    fetchAndSaveSlot(commitment) {
+        const slotPromise = this.connection.getSlot(commitment);
+        const timestamp = Date.now();
+        this.slotCache[commitment] = {
+            slot: slotPromise,
+            timestamp
+        };
+        slotPromise.catch(e => {
+            if (this.slotCache[commitment] != null && this.slotCache[commitment].slot === slotPromise)
+                delete this.slotCache[commitment];
+            throw e;
+        });
+        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
+     */
+    async getSlotAndTimestamp(commitment) {
+        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)
+     *
+     * @param commitment
+     */
+    async getSlot(commitment) {
+        let cachedSlotData = this.slotCache[commitment];
+        if (cachedSlotData != null && Date.now() - cachedSlotData.timestamp < this.SLOT_CACHE_TIME) {
+            return (await cachedSlotData.slot) + Math.floor((Date.now() - cachedSlotData.timestamp) / this.root.SLOT_TIME);
+        }
+        cachedSlotData = this.fetchAndSaveSlot(commitment);
+        return await cachedSlotData.slot;
+    }
+}
+exports.SolanaSlots = SolanaSlots;

package/dist/solana/chain/modules/SolanaTokens.d.ts

@@ -1,136 +1,136 @@
-import { SolanaModule } from "../SolanaModule";
-import { PublicKey } from "@solana/web3.js";
-import { Account } from "@solana/spl-token";
-import { SolanaTx } from "./SolanaTransactions";
-import { SolanaAction } from "../SolanaAction";
-export declare class SolanaTokens extends SolanaModule {
-    static readonly CUCosts: {
-        WRAP_SOL: number;
-        ATA_CLOSE: number;
-        ATA_INIT: number;
-        TRANSFER: number;
-        TRANSFER_SOL: number;
-    };
-    /**
-     * Creates an ATA for a specific public key & token, the ATA creation is paid for by the underlying provider's
-     *  public key
-     *
-     * @param signer
-     * @param publicKey public key address of the user for which to initiate the ATA
-     * @param token token identification for which the ATA should be initialized
-     * @param requiredAta optional required ata address to use, if the address doesn't match it returns null
-     * @constructor
-     */
-    InitAta(signer: PublicKey, publicKey: PublicKey, token: PublicKey, requiredAta?: PublicKey): SolanaAction | null;
-    /**
-     * Action for wrapping SOL to WSOL for a specific public key
-     *
-     * @param publicKey public key of the user for which to wrap the SOL
-     * @param amount amount of SOL in lamports (smallest unit) to wrap
-     * @param initAta whether we should also initialize the ATA before depositing SOL
-     * @constructor
-     */
-    Wrap(publicKey: PublicKey, amount: bigint, initAta: boolean): SolanaAction;
-    /**
-     * Action for unwrapping WSOL to SOL for a specific public key
-     *
-     * @param publicKey public key of the user for which to unwrap the sol
-     * @constructor
-     */
-    Unwrap(publicKey: PublicKey): SolanaAction;
-    static readonly WSOL_ADDRESS: PublicKey;
-    static readonly SPL_ATA_RENT_EXEMPT = 2039280;
-    /**
-     * Action for transferring the native SOL token, uses provider's public key as a sender
-     *
-     * @param signer
-     * @param recipient
-     * @param amount
-     * @constructor
-     * @private
-     */
-    private SolTransfer;
-    /**
-     * Action for transferring the SPL token, uses provider's public key as a sender
-     *
-     * @param signer
-     * @param recipient
-     * @param token
-     * @param amount
-     * @constructor
-     * @private
-     */
-    private Transfer;
-    /**
-     * Creates transactions for sending SOL (the native token)
-     *
-     * @param signer
-     * @param amount amount of the SOL in lamports (smallest unit) to send
-     * @param recipient recipient's address
-     * @param feeRate fee rate to use for the transactions
-     * @private
-     */
-    private txsTransferSol;
-    /**
-     * Creates transactions for sending the over the tokens
-     *
-     * @param signer
-     * @param token token to send
-     * @param amount amount of the token to send
-     * @param recipient recipient's address
-     * @param feeRate fee rate to use for the transactions
-     * @private
-     */
-    private txsTransferTokens;
-    /**
-     * Checks if the provided string is a valid solana token
-     *
-     * @param token
-     */
-    isValidToken(token: string): boolean;
-    /**
-     * Returns the specific ATA or null if it doesn't exist
-     *
-     * @param ata
-     */
-    getATAOrNull(ata: PublicKey): Promise<Account | null>;
-    /**
-     * Checks whether the specific ATA exists, uses tryWithRetries so retries on failure
-     *
-     * @param ata
-     */
-    ataExists(ata: PublicKey): Promise<boolean>;
-    /**
-     * Returns the rent exempt deposit required to initiate the ATA
-     */
-    getATARentExemptLamports(): Promise<bigint>;
-    /**
-     * Returns the token balance of the public key
-     *
-     * @param publicKey
-     * @param token
-     */
-    getTokenBalance(publicKey: PublicKey, token: PublicKey): Promise<{
-        balance: bigint;
-        ataExists: boolean;
-    }>;
-    /**
-     * Returns the native currency address, we use WSOL address as placeholder for SOL
-     */
-    getNativeCurrencyAddress(): PublicKey;
-    /**
-     * Parses string base58 representation of the token address to a PublicKey object
-     * @param address
-     */
-    toTokenAddress(address: string): PublicKey;
-    /**
-     * Create transactions for sending a specific token to a destination address
-     *
-     * @param signer
-     * @param token token to use for the transfer
-     * @param amount amount of token in base units to transfer
-     * @param dstAddress destination address of the recipient
-     * @param feeRate fee rate to use for the transaction
-     */
-    txsTransfer(signer: PublicKey, token: PublicKey, amount: bigint, dstAddress: PublicKey, feeRate?: string): Promise<SolanaTx[]>;
-}
+import { SolanaModule } from "../SolanaModule";
+import { PublicKey } from "@solana/web3.js";
+import { Account } from "@solana/spl-token";
+import { SolanaTx } from "./SolanaTransactions";
+import { SolanaAction } from "../SolanaAction";
+export declare class SolanaTokens extends SolanaModule {
+    static readonly CUCosts: {
+        WRAP_SOL: number;
+        ATA_CLOSE: number;
+        ATA_INIT: number;
+        TRANSFER: number;
+        TRANSFER_SOL: number;
+    };
+    /**
+     * Creates an ATA for a specific public key & token, the ATA creation is paid for by the underlying provider's
+     *  public key
+     *
+     * @param signer
+     * @param publicKey public key address of the user for which to initiate the ATA
+     * @param token token identification for which the ATA should be initialized
+     * @param requiredAta optional required ata address to use, if the address doesn't match it returns null
+     * @constructor
+     */
+    InitAta(signer: PublicKey, publicKey: PublicKey, token: PublicKey, requiredAta?: PublicKey): SolanaAction | null;
+    /**
+     * Action for wrapping SOL to WSOL for a specific public key
+     *
+     * @param publicKey public key of the user for which to wrap the SOL
+     * @param amount amount of SOL in lamports (smallest unit) to wrap
+     * @param initAta whether we should also initialize the ATA before depositing SOL
+     * @constructor
+     */
+    Wrap(publicKey: PublicKey, amount: bigint, initAta: boolean): SolanaAction;
+    /**
+     * Action for unwrapping WSOL to SOL for a specific public key
+     *
+     * @param publicKey public key of the user for which to unwrap the sol
+     * @constructor
+     */
+    Unwrap(publicKey: PublicKey): SolanaAction;
+    static readonly WSOL_ADDRESS: PublicKey;
+    static readonly SPL_ATA_RENT_EXEMPT = 2039280;
+    /**
+     * Action for transferring the native SOL token, uses provider's public key as a sender
+     *
+     * @param signer
+     * @param recipient
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private SolTransfer;
+    /**
+     * Action for transferring the SPL token, uses provider's public key as a sender
+     *
+     * @param signer
+     * @param recipient
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Transfer;
+    /**
+     * Creates transactions for sending SOL (the native token)
+     *
+     * @param signer
+     * @param amount amount of the SOL in lamports (smallest unit) to send
+     * @param recipient recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    private txsTransferSol;
+    /**
+     * Creates transactions for sending the over the tokens
+     *
+     * @param signer
+     * @param token token to send
+     * @param amount amount of the token to send
+     * @param recipient recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    private txsTransferTokens;
+    /**
+     * Checks if the provided string is a valid solana token
+     *
+     * @param token
+     */
+    isValidToken(token: string): boolean;
+    /**
+     * Returns the specific ATA or null if it doesn't exist
+     *
+     * @param ata
+     */
+    getATAOrNull(ata: PublicKey): Promise<Account | null>;
+    /**
+     * Checks whether the specific ATA exists, uses tryWithRetries so retries on failure
+     *
+     * @param ata
+     */
+    ataExists(ata: PublicKey): Promise<boolean>;
+    /**
+     * Returns the rent exempt deposit required to initiate the ATA
+     */
+    getATARentExemptLamports(): Promise<bigint>;
+    /**
+     * Returns the token balance of the public key
+     *
+     * @param publicKey
+     * @param token
+     */
+    getTokenBalance(publicKey: PublicKey, token: PublicKey): Promise<{
+        balance: bigint;
+        ataExists: boolean;
+    }>;
+    /**
+     * Returns the native currency address, we use WSOL address as placeholder for SOL
+     */
+    getNativeCurrencyAddress(): PublicKey;
+    /**
+     * Parses string base58 representation of the token address to a PublicKey object
+     * @param address
+     */
+    toTokenAddress(address: string): PublicKey;
+    /**
+     * Create transactions for sending a specific token to a destination address
+     *
+     * @param signer
+     * @param token token to use for the transfer
+     * @param amount amount of token in base units to transfer
+     * @param dstAddress destination address of the recipient
+     * @param feeRate fee rate to use for the transaction
+     */
+    txsTransfer(signer: PublicKey, token: PublicKey, amount: bigint, dstAddress: PublicKey, feeRate?: string): Promise<SolanaTx[]>;
+}