@streamflow/common 6.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/solana/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./instructions";
+export * from "./types";
+export * from "./utils";

package/dist/solana/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./instructions"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/solana/instructions.d.ts

@@ -0,0 +1,3 @@
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import BN from "bn.js";
+export declare const prepareWrappedAccount: (connection: Connection, senderAddress: PublicKey, amount: BN) => Promise<TransactionInstruction[]>;

package/dist/solana/instructions.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareWrappedAccount = void 0;
+var spl_token_1 = require("@solana/spl-token");
+var web3_js_1 = require("@solana/web3.js");
+var prepareWrappedAccount = function (connection, senderAddress, amount) { return __awaiter(void 0, void 0, void 0, function () {
+    var tokenAccount, accInfo, instructions;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(spl_token_1.NATIVE_MINT, senderAddress, true)];
+            case 1:
+                tokenAccount = _c.sent();
+                return [4 /*yield*/, connection.getParsedAccountInfo(tokenAccount)];
+            case 2:
+                accInfo = _c.sent();
+                instructions = ((_b = (_a = accInfo.value) === null || _a === void 0 ? void 0 : _a.lamports) !== null && _b !== void 0 ? _b : 0) > 0
+                    ? []
+                    : [(0, spl_token_1.createAssociatedTokenAccountInstruction)(senderAddress, tokenAccount, senderAddress, spl_token_1.NATIVE_MINT)];
+                return [2 /*return*/, __spreadArray(__spreadArray([], __read(instructions), false), [
+                        web3_js_1.SystemProgram.transfer({
+                            fromPubkey: senderAddress,
+                            toPubkey: tokenAccount,
+                            lamports: amount.toNumber(),
+                        }),
+                        (0, spl_token_1.createSyncNativeInstruction)(tokenAccount),
+                    ], false)];
+        }
+    });
+}); };
+exports.prepareWrappedAccount = prepareWrappedAccount;

package/dist/solana/types.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { SignerWalletAdapter } from "@solana/wallet-adapter-base";
+import { AccountInfo, Keypair, PublicKey, TransactionInstruction, TransactionSignature } from "@solana/web3.js";
+export { WalletAdapterNetwork as Cluster } from "@solana/wallet-adapter-base";
+export interface Account {
+    pubkey: PublicKey;
+    account: AccountInfo<Buffer>;
+}
+export interface IInteractStreamSolanaExt {
+    invoker: SignerWalletAdapter | Keypair;
+}
+export interface TransactionResponse {
+    tx: TransactionSignature;
+}
+export interface TxResponse {
+    ixs: TransactionInstruction[];
+    tx: TransactionSignature;
+}
+export interface CheckAssociatedTokenAccountsData {
+    sender: PublicKey;
+    recipient: PublicKey;
+    partner: PublicKey;
+    streamflowTreasury: PublicKey;
+    mint: PublicKey;
+}
+export interface AtaParams {
+    mint: PublicKey;
+    owner: PublicKey;
+}

package/dist/solana/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cluster = void 0;
+var wallet_adapter_base_1 = require("@solana/wallet-adapter-base");
+Object.defineProperty(exports, "Cluster", { enumerable: true, get: function () { return wallet_adapter_base_1.WalletAdapterNetwork; } });

package/dist/solana/utils.d.ts

@@ -0,0 +1,76 @@
+import { SignerWalletAdapter } from "@solana/wallet-adapter-base";
+import { Connection, Keypair, PublicKey, TransactionInstruction, Transaction, BlockhashWithExpiryBlockHeight } from "@solana/web3.js";
+import { AtaParams, Account } from "./types";
+/**
+ * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface
+ * @param {Connection} connection - Solana web3 connection object.
+ * @param {PublicKey} wallet - PublicKey to compare against.
+ * @param {number} offset - Offset of bits of the PublicKey in the account binary.
+ * @param {PublicKey} programId - Solana program ID.
+ * @return {Promise<Account[]>} - Array of resulting accounts.
+ */
+export declare function getProgramAccounts(connection: Connection, wallet: PublicKey, offset: number, programId: PublicKey): Promise<Account[]>;
+/**
+ * Utility function to check if the transaction initiator is a Wallet object
+ * @param {Keypair | SignerWalletAdapter} walletOrKeypair - Wallet or Keypair in question
+ * @return {boolean} - Returns true if parameter is a Wallet.
+ */
+export declare function isSignerWallet(walletOrKeypair: Keypair | SignerWalletAdapter): walletOrKeypair is SignerWalletAdapter;
+/**
+ * Utility function to check if the transaction initiator a Keypair object, tries to mitigate version mismatch issues
+ * @param walletOrKeypair {Keypair | SignerWalletAdapter} walletOrKeypair - Wallet or Keypair in question
+ * @returns {boolean} - Returns true if parameter is a Keypair.
+ */
+export declare function isSignerKeypair(walletOrKeypair: Keypair | SignerWalletAdapter): walletOrKeypair is Keypair;
+export declare function signTransaction(invoker: Keypair | SignerWalletAdapter, tx: Transaction): Promise<Transaction>;
+/**
+ * Signs, sends and confirms Transaction
+ * @param connection - Solana client connection
+ * @param invoker - Keypair used as signer
+ * @param tx - Transaction instance
+ * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @returns Transaction signature
+ */
+export declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction, hash: BlockhashWithExpiryBlockHeight): Promise<string>;
+/**
+ * Shorthand call signature for getAssociatedTokenAddress, with allowance for address to be offCurve
+ * @param {PublicKey} mint - SPL token Mint address.
+ * @param {PublicKey} owner - Owner of the Associated Token Address
+ * @return {Promise<PublicKey>} - Associated Token Address
+ */
+export declare function ata(mint: PublicKey, owner: PublicKey): Promise<PublicKey>;
+/**
+ * Function that checks whether ATA exists for each provided owner
+ * @param connection - Solana client connection
+ * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @returns Array of boolean where each members corresponds to owners member
+ */
+export declare function ataBatchExist(connection: Connection, paramsBatch: AtaParams[]): Promise<boolean[]>;
+/**
+ * Generates a Transaction to create ATA for an array of owners
+ * @param connection - Solana client connection
+ * @param payer - Transaction invoker, should be a signer
+ * @param coparamsBatchnfigs - Array of Params for an each ATA account: {mint, owner}
+ * @returns Unsigned Transaction with create ATA instructions
+ */
+export declare function generateCreateAtaBatchTx(connection: Connection, payer: PublicKey, paramsBatch: AtaParams[]): Promise<{
+    tx: Transaction;
+    hash: BlockhashWithExpiryBlockHeight;
+}>;
+/**
+ * Creates ATA for an array of owners
+ * @param connection - Solana client connection
+ * @param invoker - Transaction invoker and payer
+ * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @returns Transaction signature
+ */
+export declare function createAtaBatch(connection: Connection, invoker: Keypair | SignerWalletAdapter, paramsBatch: AtaParams[]): Promise<string>;
+/**
+ * Utility function that checks whether associated token accounts exist and return instructions to populate them if not
+ * @param connection - Solana client connection
+ * @param owners - Array of ATA owners
+ * @param mint - Mint for which ATA will be checked
+ * @param invoker - Transaction invoker and payer
+ * @returns Array of Transaction Instructions that should be added to a transaction
+ */
+export declare function checkOrCreateAtaBatch(connection: Connection, owners: PublicKey[], mint: PublicKey, invoker: SignerWalletAdapter | Keypair): Promise<TransactionInstruction[]>;

package/dist/solana/utils.js

@@ -0,0 +1,354 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkOrCreateAtaBatch = exports.createAtaBatch = exports.generateCreateAtaBatchTx = exports.ataBatchExist = exports.ata = exports.signAndExecuteTransaction = exports.signTransaction = exports.isSignerKeypair = exports.isSignerWallet = exports.getProgramAccounts = void 0;
+var spl_token_1 = require("@solana/spl-token");
+var web3_js_1 = require("@solana/web3.js");
+var bs58_1 = __importDefault(require("bs58"));
+/**
+ * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface
+ * @param {Connection} connection - Solana web3 connection object.
+ * @param {PublicKey} wallet - PublicKey to compare against.
+ * @param {number} offset - Offset of bits of the PublicKey in the account binary.
+ * @param {PublicKey} programId - Solana program ID.
+ * @return {Promise<Account[]>} - Array of resulting accounts.
+ */
+function getProgramAccounts(connection, wallet, offset, programId) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, connection === null || connection === void 0 ? void 0 : connection.getProgramAccounts(programId, {
+                    filters: [
+                        {
+                            memcmp: {
+                                offset: offset,
+                                bytes: wallet.toBase58(),
+                            },
+                        },
+                    ],
+                })];
+        });
+    });
+}
+exports.getProgramAccounts = getProgramAccounts;
+/**
+ * Utility function to check if the transaction initiator is a Wallet object
+ * @param {Keypair | SignerWalletAdapter} walletOrKeypair - Wallet or Keypair in question
+ * @return {boolean} - Returns true if parameter is a Wallet.
+ */
+function isSignerWallet(walletOrKeypair) {
+    return walletOrKeypair.signTransaction !== undefined;
+}
+exports.isSignerWallet = isSignerWallet;
+/**
+ * Utility function to check if the transaction initiator a Keypair object, tries to mitigate version mismatch issues
+ * @param walletOrKeypair {Keypair | SignerWalletAdapter} walletOrKeypair - Wallet or Keypair in question
+ * @returns {boolean} - Returns true if parameter is a Keypair.
+ */
+function isSignerKeypair(walletOrKeypair) {
+    return (walletOrKeypair instanceof web3_js_1.Keypair ||
+        walletOrKeypair.constructor === web3_js_1.Keypair ||
+        walletOrKeypair.constructor.name === web3_js_1.Keypair.prototype.constructor.name);
+}
+exports.isSignerKeypair = isSignerKeypair;
+function signTransaction(invoker, tx) {
+    return __awaiter(this, void 0, void 0, function () {
+        var signedTx;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isSignerWallet(invoker)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, invoker.signTransaction(tx)];
+                case 1:
+                    signedTx = _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    tx.partialSign(invoker);
+                    signedTx = tx;
+                    _a.label = 3;
+                case 3: return [2 /*return*/, signedTx];
+            }
+        });
+    });
+}
+exports.signTransaction = signTransaction;
+/**
+ * Signs, sends and confirms Transaction
+ * @param connection - Solana client connection
+ * @param invoker - Keypair used as signer
+ * @param tx - Transaction instance
+ * @param hash - blockhash information, the same hash should be used in the Transaction
+ * @returns Transaction signature
+ */
+function signAndExecuteTransaction(connection, invoker, tx, hash) {
+    return __awaiter(this, void 0, void 0, function () {
+        var signedTx, rawTx, confirmationStrategy, signature;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, signTransaction(invoker, tx)];
+                case 1:
+                    signedTx = _a.sent();
+                    rawTx = signedTx.serialize();
+                    if (!hash.lastValidBlockHeight || !signedTx.signature || !hash.blockhash)
+                        throw Error("Error with transaction parameters.");
+                    confirmationStrategy = {
+                        lastValidBlockHeight: hash.lastValidBlockHeight,
+                        signature: bs58_1.default.encode(signedTx.signature),
+                        blockhash: hash.blockhash,
+                    };
+                    return [4 /*yield*/, (0, web3_js_1.sendAndConfirmRawTransaction)(connection, rawTx, confirmationStrategy)];
+                case 2:
+                    signature = _a.sent();
+                    return [2 /*return*/, signature];
+            }
+        });
+    });
+}
+exports.signAndExecuteTransaction = signAndExecuteTransaction;
+/**
+ * Shorthand call signature for getAssociatedTokenAddress, with allowance for address to be offCurve
+ * @param {PublicKey} mint - SPL token Mint address.
+ * @param {PublicKey} owner - Owner of the Associated Token Address
+ * @return {Promise<PublicKey>} - Associated Token Address
+ */
+function ata(mint, owner) {
+    return (0, spl_token_1.getAssociatedTokenAddress)(mint, owner, true);
+}
+exports.ata = ata;
+/**
+ * Function that checks whether ATA exists for each provided owner
+ * @param connection - Solana client connection
+ * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @returns Array of boolean where each members corresponds to owners member
+ */
+function ataBatchExist(connection, paramsBatch) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tokenAccounts, response;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all(paramsBatch.map(function (_a) {
+                        var mint = _a.mint, owner = _a.owner;
+                        return __awaiter(_this, void 0, void 0, function () {
+                            var pubkey;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0: return [4 /*yield*/, ata(mint, owner)];
+                                    case 1:
+                                        pubkey = _b.sent();
+                                        return [2 /*return*/, pubkey];
+                                }
+                            });
+                        });
+                    }))];
+                case 1:
+                    tokenAccounts = _a.sent();
+                    return [4 /*yield*/, connection.getMultipleAccountsInfo(tokenAccounts)];
+                case 2:
+                    response = _a.sent();
+                    return [2 /*return*/, response.map(function (accInfo) { return !!accInfo; })];
+            }
+        });
+    });
+}
+exports.ataBatchExist = ataBatchExist;
+/**
+ * Generates a Transaction to create ATA for an array of owners
+ * @param connection - Solana client connection
+ * @param payer - Transaction invoker, should be a signer
+ * @param coparamsBatchnfigs - Array of Params for an each ATA account: {mint, owner}
+ * @returns Unsigned Transaction with create ATA instructions
+ */
+function generateCreateAtaBatchTx(connection, payer, paramsBatch) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ixs, hash, tx;
+        var _a;
+        var _this = this;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, Promise.all(paramsBatch.map(function (_a) {
+                        var mint = _a.mint, owner = _a.owner;
+                        return __awaiter(_this, void 0, void 0, function () {
+                            var _b, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        _b = spl_token_1.createAssociatedTokenAccountInstruction;
+                                        _c = [payer];
+                                        return [4 /*yield*/, ata(mint, owner)];
+                                    case 1: return [2 /*return*/, _b.apply(void 0, _c.concat([_d.sent(), owner, mint]))];
+                                }
+                            });
+                        });
+                    }))];
+                case 1:
+                    ixs = _b.sent();
+                    return [4 /*yield*/, connection.getLatestBlockhash()];
+                case 2:
+                    hash = _b.sent();
+                    tx = (_a = new web3_js_1.Transaction({
+                        feePayer: payer,
+                        blockhash: hash.blockhash,
+                        lastValidBlockHeight: hash.lastValidBlockHeight,
+                    })).add.apply(_a, __spreadArray([], __read(ixs), false));
+                    return [2 /*return*/, { tx: tx, hash: hash }];
+            }
+        });
+    });
+}
+exports.generateCreateAtaBatchTx = generateCreateAtaBatchTx;
+/**
+ * Creates ATA for an array of owners
+ * @param connection - Solana client connection
+ * @param invoker - Transaction invoker and payer
+ * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
+ * @returns Transaction signature
+ */
+function createAtaBatch(connection, invoker, paramsBatch) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, tx, hash, signature;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, generateCreateAtaBatchTx(connection, invoker.publicKey, paramsBatch)];
+                case 1:
+                    _a = _b.sent(), tx = _a.tx, hash = _a.hash;
+                    return [4 /*yield*/, signAndExecuteTransaction(connection, invoker, tx, hash)];
+                case 2:
+                    signature = _b.sent();
+                    return [2 /*return*/, signature];
+            }
+        });
+    });
+}
+exports.createAtaBatch = createAtaBatch;
+/**
+ * Utility function that checks whether associated token accounts exist and return instructions to populate them if not
+ * @param connection - Solana client connection
+ * @param owners - Array of ATA owners
+ * @param mint - Mint for which ATA will be checked
+ * @param invoker - Transaction invoker and payer
+ * @returns Array of Transaction Instructions that should be added to a transaction
+ */
+function checkOrCreateAtaBatch(connection, owners, mint, invoker) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ixs, atas, owners_1, owners_1_1, owner, _a, _b, e_1_1, response, i;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    ixs = [];
+                    atas = [];
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 6, 7, 8]);
+                    owners_1 = __values(owners), owners_1_1 = owners_1.next();
+                    _d.label = 2;
+                case 2:
+                    if (!!owners_1_1.done) return [3 /*break*/, 5];
+                    owner = owners_1_1.value;
+                    _b = (_a = atas).push;
+                    return [4 /*yield*/, ata(mint, owner)];
+                case 3:
+                    _b.apply(_a, [_d.sent()]);
+                    _d.label = 4;
+                case 4:
+                    owners_1_1 = owners_1.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (owners_1_1 && !owners_1_1.done && (_c = owners_1.return)) _c.call(owners_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [4 /*yield*/, connection.getMultipleAccountsInfo(atas)];
+                case 9:
+                    response = _d.sent();
+                    for (i = 0; i < response.length; i++) {
+                        if (!response[i]) {
+                            ixs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(invoker.publicKey, atas[i], owners[i], mint));
+                        }
+                    }
+                    return [2 /*return*/, ixs];
+            }
+        });
+    });
+}
+exports.checkOrCreateAtaBatch = checkOrCreateAtaBatch;

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+import { TransactionInstruction } from "@solana/web3.js";
+import { Types } from "aptos";
+export interface ITransactionResult {
+    ixs: (TransactionInstruction | Types.TransactionPayload)[];
+    txId: string;
+}
+export declare enum ICluster {
+    Mainnet = "mainnet",
+    Devnet = "devnet",
+    Testnet = "testnet",
+    Local = "local"
+}
+export declare enum IChain {
+    Solana = "Solana",
+    Aptos = "Aptos",
+    Ethereum = "Ethereum",
+    BNB = "BNB",
+    Polygon = "Polygon",
+    Sui = "Sui"
+}
+/**
+ * Error wrapper for calls made to the contract on chain
+ */
+export declare class ContractError extends Error {
+    contractErrorCode: string | null;
+    /**
+     * Constructs the Error Wrapper
+     * @param error Original error raised probably by the chain SDK
+     * @param code extracted code from the error if managed to parse it
+     */
+    constructor(error: Error, code?: string | null);
+}