@atomiqlabs/chain-solana 13.5.13 → 13.5.14

package/src/solana/swaps/SwapTypeEnum.ts

@@ -1,31 +1,31 @@
-import {ChainSwapType} from "@atomiqlabs/base";
-
-export class SwapTypeEnum {
-
-    static toChainSwapType(data: any): number {
-        const text = Object.keys(data)[0];
-        if(text==="htlc") return ChainSwapType.HTLC;
-        if(text==="chain") return ChainSwapType.CHAIN;
-        if(text==="chainNonced") return ChainSwapType.CHAIN_NONCED;
-        if(text==="chainTxhash") return ChainSwapType.CHAIN_TXID;
-        throw new Error("Invalid data passed!");
-    }
-
-    static toNumber(data: any): number {
-        const text = Object.keys(data)[0];
-        if(text==="htlc") return 0;
-        if(text==="chain") return 1;
-        if(text==="chainNonced") return 2;
-        if(text==="chainTxhash") return 3;
-        throw new Error("Invalid data passed!");
-    }
-
-    static fromNumber(kind: 0 | 1 | 2 | 3): {htlc?: never; chain?: never; chainNonced?: never;} & {chainTxhash: Record<string,never>} {
-        if(kind===0) return {htlc: null} as any;
-        if(kind===1) return {chain: null} as any;
-        if(kind===2) return {chainNonced: null} as any;
-        if(kind===3) return {chainTxhash: null} as any;
-        throw new Error("Invalid kind number!");
-    }
-
+import {ChainSwapType} from "@atomiqlabs/base";
+
+export class SwapTypeEnum {
+
+    static toChainSwapType(data: any): number {
+        const text = Object.keys(data)[0];
+        if(text==="htlc") return ChainSwapType.HTLC;
+        if(text==="chain") return ChainSwapType.CHAIN;
+        if(text==="chainNonced") return ChainSwapType.CHAIN_NONCED;
+        if(text==="chainTxhash") return ChainSwapType.CHAIN_TXID;
+        throw new Error("Invalid data passed!");
+    }
+
+    static toNumber(data: any): number {
+        const text = Object.keys(data)[0];
+        if(text==="htlc") return 0;
+        if(text==="chain") return 1;
+        if(text==="chainNonced") return 2;
+        if(text==="chainTxhash") return 3;
+        throw new Error("Invalid data passed!");
+    }
+
+    static fromNumber(kind: 0 | 1 | 2 | 3): {htlc?: never; chain?: never; chainNonced?: never;} & {chainTxhash: Record<string,never>} {
+        if(kind===0) return {htlc: null} as any;
+        if(kind===1) return {chain: null} as any;
+        if(kind===2) return {chainNonced: null} as any;
+        if(kind===3) return {chainTxhash: null} as any;
+        throw new Error("Invalid kind number!");
+    }
+
 };

package/src/solana/swaps/modules/SolanaDataAccount.ts

@@ -1,303 +1,303 @@
-import {SolanaSwapModule} from "../SolanaSwapModule";
-import {AccountInfo, PublicKey, Signer, SystemProgram} from "@solana/web3.js";
-import {IStorageManager, StorageObject} from "@atomiqlabs/base";
-import {SolanaSwapProgram} from "../SolanaSwapProgram";
-import {SolanaAction} from "../../chain/SolanaAction";
-import {SolanaTx} from "../../chain/modules/SolanaTransactions";
-import {SolanaSigner} from "../../wallet/SolanaSigner";
-import {randomBytes} from "@noble/hashes/utils";
-import {SolanaChainInterface} from "../../chain/SolanaChainInterface";
-
-export class StoredDataAccount implements StorageObject {
-
-    accountKey: PublicKey;
-    owner: PublicKey;
-
-    constructor(accountKey: PublicKey, owner: PublicKey);
-    constructor(data: any);
-
-    constructor(accountKeyOrData: PublicKey | any, owner?: PublicKey) {
-        if(accountKeyOrData instanceof PublicKey && owner instanceof PublicKey) {
-            this.accountKey = accountKeyOrData;
-            this.owner = owner;
-        } else {
-            this.accountKey = new PublicKey(accountKeyOrData.accountKey);
-            this.owner = new PublicKey(accountKeyOrData.owner);
-        }
-    }
-
-    serialize(): any {
-        return {
-            accountKey: this.accountKey.toBase58(),
-            owner: this.owner.toBase58()
-        }
-    }
-
-}
-
-export class SolanaDataAccount extends SolanaSwapModule {
-
-    readonly SwapTxDataAlt = this.program._keypair(
-        (reversedTxId: Buffer, signer: Signer) => [Buffer.from(signer.secretKey), reversedTxId]
-    );
-    readonly SwapTxDataAltBuffer = this.program._keypair((reversedTxId: Buffer, secret: Buffer) => [secret, reversedTxId]);
-
-    readonly storage: IStorageManager<StoredDataAccount>;
-
-    private static readonly CUCosts = {
-        DATA_REMOVE: 50000,
-        DATA_CREATE_AND_WRITE: 15000,
-        DATA_CREATE: 5000,
-        DATA_WRITE: 15000
-    };
-
-    /**
-     * Action for initialization of the data account
-     *
-     * @param signer
-     * @param accountKey
-     * @param dataLength
-     * @private
-     */
-    private async InitDataAccount(
-        signer: PublicKey,
-        accountKey: Signer,
-        dataLength: number
-    ): Promise<SolanaAction> {
-        const accountSize = this.program.version==="v2"
-            ? 40+dataLength
-            : 32+dataLength;
-        const lamportsDeposit = await this.connection.getMinimumBalanceForRentExemption(accountSize);
-
-        return new SolanaAction(signer, this.root, [
-            SystemProgram.createAccount({
-                fromPubkey: signer,
-                newAccountPubkey: accountKey.publicKey,
-                lamports: lamportsDeposit,
-                space: accountSize,
-                programId: this.swapProgram.programId
-            }),
-            await this.swapProgram.methods
-                .initData()
-                .accounts({
-                    signer,
-                    data: accountKey.publicKey
-                })
-                .instruction(),
-        ], SolanaDataAccount.CUCosts.DATA_CREATE, undefined, [accountKey]);
-    }
-
-    /**
-     * Action for closing the specific data account
-     *
-     * @param signer
-     * @param publicKey
-     */
-    private async CloseDataAccount(signer: PublicKey, publicKey: PublicKey): Promise<SolanaAction> {
-        return new SolanaAction(
-            signer,
-            this.root,
-            await this.swapProgram.methods
-                .closeData()
-                .accounts({
-                    signer,
-                    data: publicKey
-                })
-                .instruction(),
-            SolanaDataAccount.CUCosts.DATA_REMOVE,
-            await this.root.Fees.getFeeRate([signer, publicKey])
-        );
-    }
-
-    /**
-     * Action for writing data to a data account, writes up to sizeLimit starting from the offset position of the
-     *  provided writeData buffer
-     *
-     * @param signer
-     * @param accountKey account public key to write to
-     * @param writeData buffer holding the write data
-     * @param offset data from buffer starting at offset are written
-     * @param sizeLimit maximum amount of data to be written to the data account in this action
-     * @private
-     * @returns {Promise<{bytesWritten: number, action: SolanaAction}>} bytes written to the data account & action
-     */
-    private async WriteData(
-        signer: PublicKey,
-        accountKey: Signer,
-        writeData: Buffer,
-        offset: number,
-        sizeLimit: number
-    ): Promise<{bytesWritten: number, action: SolanaAction}> {
-        const writeLen = Math.min(writeData.length-offset, sizeLimit);
-
-        return {
-            bytesWritten: writeLen,
-            action: new SolanaAction(signer, this.root,
-                await this.swapProgram.methods
-                    .writeData(offset, writeData.slice(offset, offset+writeLen))
-                    .accounts({
-                        signer,
-                        data: accountKey.publicKey
-                    })
-                    .instruction(),
-                SolanaDataAccount.CUCosts.DATA_WRITE
-            )
-        };
-    }
-
-    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram, storage: IStorageManager<StoredDataAccount>) {
-        super(chainInterface, program);
-        this.storage = storage;
-    }
-
-    /**
-     * Saves data account to the storage, the storage is required such that we are able to close the accounts later
-     *  manually in case the claim doesn't happen (expires due to fees, etc.)
-     *
-     * @param signer
-     * @param publicKey
-     * @private
-     */
-    private saveDataAccount(signer: PublicKey, publicKey: PublicKey): Promise<void> {
-        return this.storage.saveData(publicKey.toBase58(), new StoredDataAccount(publicKey, signer));
-    }
-
-    /**
-     * Initializes the data account handler, loads the existing data accounts which should be checked and closed
-     */
-    public async init() {
-        await this.storage.init();
-        const loadedData = await this.storage.loadData(StoredDataAccount);
-        this.logger.info("init(): initialized & loaded stored data accounts, count: "+loadedData.length);
-    }
-
-    /**
-     * Removes data account from the list of accounts that should be checked for reclaiming the locked SOL, this should
-     *  be called after a batch of transactions claiming the swap was confirmed
-     *
-     * @param publicKey
-     */
-    public removeDataAccount(publicKey: PublicKey): Promise<void> {
-        return this.storage.removeData(publicKey.toBase58());
-    }
-
-    public async getDataAccountsInfo(signer: PublicKey): Promise<{closePublicKeys: PublicKey[], count: number, totalValue: bigint}> {
-        const closePublicKeys: PublicKey[] = [];
-        let totalLocked = 0n;
-        for(let key in this.storage.data) {
-            const {accountKey, owner} = this.storage.data[key];
-
-            if(!owner.equals(signer)) continue;
-
-            try {
-                const fetchedDataAccount = await this.connection.getAccountInfo(accountKey);
-                if(fetchedDataAccount==null || fetchedDataAccount.lamports===0 || fetchedDataAccount.data.length===0) {
-                    await this.removeDataAccount(accountKey);
-                    continue;
-                }
-                closePublicKeys.push(accountKey);
-                totalLocked += BigInt(fetchedDataAccount.lamports);
-            } catch (e) {}
-        }
-
-        return {
-            closePublicKeys,
-            count: closePublicKeys.length,
-            totalValue: totalLocked
-        }
-    }
-
-    /**
-     * Sweeps all old data accounts, reclaiming the SOL locked in the PDAs
-     */
-    public async sweepDataAccounts(signer: SolanaSigner): Promise<{txIds: string[], count: number, totalValue: bigint}> {
-        const {closePublicKeys, totalValue} = await this.getDataAccountsInfo(signer.getPublicKey());
-
-        if(closePublicKeys.length===0) {
-            this.logger.debug("sweepDataAccounts(): no old data accounts found, no need to close any!");
-            return { txIds: [], count: 0, totalValue: 0n };
-        }
-
-        this.logger.debug("sweepDataAccounts(): closing old data accounts: ", closePublicKeys);
-
-        let txns: SolanaTx[] = [];
-        for(let publicKey of closePublicKeys) {
-            await (await this.CloseDataAccount(signer.getPublicKey(), publicKey)).addToTxs(txns);
-        }
-
-        const result = await this.root.Transactions.sendAndConfirm(signer, txns, true, undefined, true);
-
-        this.logger.info("sweepDataAccounts(): old data accounts closed: "+
-            closePublicKeys.map(pk => pk.toBase58()).join());
-
-        for(let publicKey of closePublicKeys) {
-            await this.removeDataAccount(publicKey);
-        }
-
-        return {
-            txIds: result,
-            count: closePublicKeys.length,
-            totalValue: totalValue
-        };
-    }
-
-    /**
-     * Adds the transactions writing (and also initializing if it doesn't exist) data to the data account
-     *
-     * @param signer
-     * @param reversedTxId reversed btc tx id is used to derive the data account address
-     * @param writeData full data to be written to the data account
-     * @param txs solana transactions array, where txns for writing & initializing will be added
-     * @param feeRate fee rate to use for the transactions
-     */
-    public async addTxsWriteData(
-        signer: SolanaSigner | PublicKey,
-        reversedTxId: Buffer,
-        writeData: Buffer,
-        txs: SolanaTx[],
-        feeRate: string
-    ): Promise<PublicKey> {
-        let txDataKey: Signer;
-        let fetchedDataAccount: AccountInfo<Buffer> | null = null;
-        if(signer instanceof SolanaSigner && signer.keypair!=null) {
-            txDataKey = this.SwapTxDataAlt(reversedTxId, signer.keypair);
-            fetchedDataAccount = await this.connection.getAccountInfo(txDataKey.publicKey);
-        } else {
-            const secret = Buffer.from(randomBytes(32));
-            txDataKey = this.SwapTxDataAltBuffer(reversedTxId, secret);
-        }
-
-        const signerKey = signer instanceof SolanaSigner ? signer.getPublicKey() : signer;
-
-        let pointer = 0;
-        if(fetchedDataAccount==null) {
-            const action = new SolanaAction(signerKey, this.root);
-            action.add(await this.InitDataAccount(signerKey, txDataKey, writeData.length));
-            const {
-                bytesWritten,
-                action: writeAction
-            } = await this.WriteData(signerKey, txDataKey, writeData, pointer, 420);
-            this.logger.debug("addTxsWriteData(): Write partial data ("+pointer+" .. "+(pointer+bytesWritten)+")/"+writeData.length+
-                " key: "+txDataKey.publicKey.toBase58());
-            pointer += bytesWritten;
-            action.add(writeAction);
-
-            await action.addToTxs(txs, feeRate);
-            await this.saveDataAccount(signerKey, txDataKey.publicKey);
-        }
-
-        while(pointer<writeData.length) {
-            const {
-                bytesWritten,
-                action
-            } = await this.WriteData(signerKey, txDataKey, writeData, pointer, 950);
-            this.logger.debug("addTxsWriteData(): Write partial data ("+pointer+" .. "+(pointer+bytesWritten)+")/"+writeData.length+
-                " key: "+txDataKey.publicKey.toBase58());
-            pointer += bytesWritten;
-            await action.addToTxs(txs, feeRate);
-        }
-
-        return txDataKey.publicKey;
-    }
-
+import {SolanaSwapModule} from "../SolanaSwapModule";
+import {AccountInfo, PublicKey, Signer, SystemProgram} from "@solana/web3.js";
+import {IStorageManager, StorageObject} from "@atomiqlabs/base";
+import {SolanaSwapProgram} from "../SolanaSwapProgram";
+import {SolanaAction} from "../../chain/SolanaAction";
+import {SolanaTx} from "../../chain/modules/SolanaTransactions";
+import {SolanaSigner} from "../../wallet/SolanaSigner";
+import {randomBytes} from "@noble/hashes/utils";
+import {SolanaChainInterface} from "../../chain/SolanaChainInterface";
+
+export class StoredDataAccount implements StorageObject {
+
+    accountKey: PublicKey;
+    owner: PublicKey;
+
+    constructor(accountKey: PublicKey, owner: PublicKey);
+    constructor(data: any);
+
+    constructor(accountKeyOrData: PublicKey | any, owner?: PublicKey) {
+        if(accountKeyOrData instanceof PublicKey && owner instanceof PublicKey) {
+            this.accountKey = accountKeyOrData;
+            this.owner = owner;
+        } else {
+            this.accountKey = new PublicKey(accountKeyOrData.accountKey);
+            this.owner = new PublicKey(accountKeyOrData.owner);
+        }
+    }
+
+    serialize(): any {
+        return {
+            accountKey: this.accountKey.toBase58(),
+            owner: this.owner.toBase58()
+        }
+    }
+
+}
+
+export class SolanaDataAccount extends SolanaSwapModule {
+
+    readonly SwapTxDataAlt = this.program._keypair(
+        (reversedTxId: Buffer, signer: Signer) => [Buffer.from(signer.secretKey), reversedTxId]
+    );
+    readonly SwapTxDataAltBuffer = this.program._keypair((reversedTxId: Buffer, secret: Buffer) => [secret, reversedTxId]);
+
+    readonly storage: IStorageManager<StoredDataAccount>;
+
+    private static readonly CUCosts = {
+        DATA_REMOVE: 50000,
+        DATA_CREATE_AND_WRITE: 15000,
+        DATA_CREATE: 5000,
+        DATA_WRITE: 15000
+    };
+
+    /**
+     * Action for initialization of the data account
+     *
+     * @param signer
+     * @param accountKey
+     * @param dataLength
+     * @private
+     */
+    private async InitDataAccount(
+        signer: PublicKey,
+        accountKey: Signer,
+        dataLength: number
+    ): Promise<SolanaAction> {
+        const accountSize = this.program.version==="v2"
+            ? 40+dataLength
+            : 32+dataLength;
+        const lamportsDeposit = await this.connection.getMinimumBalanceForRentExemption(accountSize);
+
+        return new SolanaAction(signer, this.root, [
+            SystemProgram.createAccount({
+                fromPubkey: signer,
+                newAccountPubkey: accountKey.publicKey,
+                lamports: lamportsDeposit,
+                space: accountSize,
+                programId: this.swapProgram.programId
+            }),
+            await this.swapProgram.methods
+                .initData()
+                .accounts({
+                    signer,
+                    data: accountKey.publicKey
+                })
+                .instruction(),
+        ], SolanaDataAccount.CUCosts.DATA_CREATE, undefined, [accountKey]);
+    }
+
+    /**
+     * Action for closing the specific data account
+     *
+     * @param signer
+     * @param publicKey
+     */
+    private async CloseDataAccount(signer: PublicKey, publicKey: PublicKey): Promise<SolanaAction> {
+        return new SolanaAction(
+            signer,
+            this.root,
+            await this.swapProgram.methods
+                .closeData()
+                .accounts({
+                    signer,
+                    data: publicKey
+                })
+                .instruction(),
+            SolanaDataAccount.CUCosts.DATA_REMOVE,
+            await this.root.Fees.getFeeRate([signer, publicKey])
+        );
+    }
+
+    /**
+     * Action for writing data to a data account, writes up to sizeLimit starting from the offset position of the
+     *  provided writeData buffer
+     *
+     * @param signer
+     * @param accountKey account public key to write to
+     * @param writeData buffer holding the write data
+     * @param offset data from buffer starting at offset are written
+     * @param sizeLimit maximum amount of data to be written to the data account in this action
+     * @private
+     * @returns {Promise<{bytesWritten: number, action: SolanaAction}>} bytes written to the data account & action
+     */
+    private async WriteData(
+        signer: PublicKey,
+        accountKey: Signer,
+        writeData: Buffer,
+        offset: number,
+        sizeLimit: number
+    ): Promise<{bytesWritten: number, action: SolanaAction}> {
+        const writeLen = Math.min(writeData.length-offset, sizeLimit);
+
+        return {
+            bytesWritten: writeLen,
+            action: new SolanaAction(signer, this.root,
+                await this.swapProgram.methods
+                    .writeData(offset, writeData.slice(offset, offset+writeLen))
+                    .accounts({
+                        signer,
+                        data: accountKey.publicKey
+                    })
+                    .instruction(),
+                SolanaDataAccount.CUCosts.DATA_WRITE
+            )
+        };
+    }
+
+    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram, storage: IStorageManager<StoredDataAccount>) {
+        super(chainInterface, program);
+        this.storage = storage;
+    }
+
+    /**
+     * Saves data account to the storage, the storage is required such that we are able to close the accounts later
+     *  manually in case the claim doesn't happen (expires due to fees, etc.)
+     *
+     * @param signer
+     * @param publicKey
+     * @private
+     */
+    private saveDataAccount(signer: PublicKey, publicKey: PublicKey): Promise<void> {
+        return this.storage.saveData(publicKey.toBase58(), new StoredDataAccount(publicKey, signer));
+    }
+
+    /**
+     * Initializes the data account handler, loads the existing data accounts which should be checked and closed
+     */
+    public async init() {
+        await this.storage.init();
+        const loadedData = await this.storage.loadData(StoredDataAccount);
+        this.logger.info("init(): initialized & loaded stored data accounts, count: "+loadedData.length);
+    }
+
+    /**
+     * Removes data account from the list of accounts that should be checked for reclaiming the locked SOL, this should
+     *  be called after a batch of transactions claiming the swap was confirmed
+     *
+     * @param publicKey
+     */
+    public removeDataAccount(publicKey: PublicKey): Promise<void> {
+        return this.storage.removeData(publicKey.toBase58());
+    }
+
+    public async getDataAccountsInfo(signer: PublicKey): Promise<{closePublicKeys: PublicKey[], count: number, totalValue: bigint}> {
+        const closePublicKeys: PublicKey[] = [];
+        let totalLocked = 0n;
+        for(let key in this.storage.data) {
+            const {accountKey, owner} = this.storage.data[key];
+
+            if(!owner.equals(signer)) continue;
+
+            try {
+                const fetchedDataAccount = await this.connection.getAccountInfo(accountKey);
+                if(fetchedDataAccount==null || fetchedDataAccount.lamports===0 || fetchedDataAccount.data.length===0) {
+                    await this.removeDataAccount(accountKey);
+                    continue;
+                }
+                closePublicKeys.push(accountKey);
+                totalLocked += BigInt(fetchedDataAccount.lamports);
+            } catch (e) {}
+        }
+
+        return {
+            closePublicKeys,
+            count: closePublicKeys.length,
+            totalValue: totalLocked
+        }
+    }
+
+    /**
+     * Sweeps all old data accounts, reclaiming the SOL locked in the PDAs
+     */
+    public async sweepDataAccounts(signer: SolanaSigner): Promise<{txIds: string[], count: number, totalValue: bigint}> {
+        const {closePublicKeys, totalValue} = await this.getDataAccountsInfo(signer.getPublicKey());
+
+        if(closePublicKeys.length===0) {
+            this.logger.debug("sweepDataAccounts(): no old data accounts found, no need to close any!");
+            return { txIds: [], count: 0, totalValue: 0n };
+        }
+
+        this.logger.debug("sweepDataAccounts(): closing old data accounts: ", closePublicKeys);
+
+        let txns: SolanaTx[] = [];
+        for(let publicKey of closePublicKeys) {
+            await (await this.CloseDataAccount(signer.getPublicKey(), publicKey)).addToTxs(txns);
+        }
+
+        const result = await this.root.Transactions.sendAndConfirm(signer, txns, true, undefined, true);
+
+        this.logger.info("sweepDataAccounts(): old data accounts closed: "+
+            closePublicKeys.map(pk => pk.toBase58()).join());
+
+        for(let publicKey of closePublicKeys) {
+            await this.removeDataAccount(publicKey);
+        }
+
+        return {
+            txIds: result,
+            count: closePublicKeys.length,
+            totalValue: totalValue
+        };
+    }
+
+    /**
+     * Adds the transactions writing (and also initializing if it doesn't exist) data to the data account
+     *
+     * @param signer
+     * @param reversedTxId reversed btc tx id is used to derive the data account address
+     * @param writeData full data to be written to the data account
+     * @param txs solana transactions array, where txns for writing & initializing will be added
+     * @param feeRate fee rate to use for the transactions
+     */
+    public async addTxsWriteData(
+        signer: SolanaSigner | PublicKey,
+        reversedTxId: Buffer,
+        writeData: Buffer,
+        txs: SolanaTx[],
+        feeRate: string
+    ): Promise<PublicKey> {
+        let txDataKey: Signer;
+        let fetchedDataAccount: AccountInfo<Buffer> | null = null;
+        if(signer instanceof SolanaSigner && signer.keypair!=null) {
+            txDataKey = this.SwapTxDataAlt(reversedTxId, signer.keypair);
+            fetchedDataAccount = await this.connection.getAccountInfo(txDataKey.publicKey);
+        } else {
+            const secret = Buffer.from(randomBytes(32));
+            txDataKey = this.SwapTxDataAltBuffer(reversedTxId, secret);
+        }
+
+        const signerKey = signer instanceof SolanaSigner ? signer.getPublicKey() : signer;
+
+        let pointer = 0;
+        if(fetchedDataAccount==null) {
+            const action = new SolanaAction(signerKey, this.root);
+            action.add(await this.InitDataAccount(signerKey, txDataKey, writeData.length));
+            const {
+                bytesWritten,
+                action: writeAction
+            } = await this.WriteData(signerKey, txDataKey, writeData, pointer, 420);
+            this.logger.debug("addTxsWriteData(): Write partial data ("+pointer+" .. "+(pointer+bytesWritten)+")/"+writeData.length+
+                " key: "+txDataKey.publicKey.toBase58());
+            pointer += bytesWritten;
+            action.add(writeAction);
+
+            await action.addToTxs(txs, feeRate);
+            await this.saveDataAccount(signerKey, txDataKey.publicKey);
+        }
+
+        while(pointer<writeData.length) {
+            const {
+                bytesWritten,
+                action
+            } = await this.WriteData(signerKey, txDataKey, writeData, pointer, 950);
+            this.logger.debug("addTxsWriteData(): Write partial data ("+pointer+" .. "+(pointer+bytesWritten)+")/"+writeData.length+
+                " key: "+txDataKey.publicKey.toBase58());
+            pointer += bytesWritten;
+            await action.addToTxs(txs, feeRate);
+        }
+
+        return txDataKey.publicKey;
+    }
+
 }