@btc-vision/transaction 1.0.85 → 1.0.86

package/build/tests/pool/DecodePoolAddress.js

@@ -0,0 +1,12 @@
+import { BinaryReader } from '@btc-vision/bsi-binary';
+function decodeTransferEvent(data) {
+    const reader = new BinaryReader(data);
+    const from = reader.readAddress();
+    const to = reader.readAddress();
+    const value = reader.readU256();
+    return { from, to, value };
+}
+const transferEventData = Buffer.from('YmNydDFwcHFrMzZhenl1bnhkcGFkemE3Z3RmNTY4ZWxxeG5odTNsd3VmZzk4ZGFlazNrejA3Mzkwc3d5dnpkMgBiY3J0MXFwaDRqejZkbXc1dW53bThnc2M1dTRxbXkwbXF0bjVkOGF2bHhqNgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9CQA==', 'base64');
+const bytes = Uint8Array.from(transferEventData);
+const transferEvent = decodeTransferEvent(bytes);
+console.log(transferEvent);

package/build/tests/pool/decodeReserves.d.ts

@@ -0,0 +1,5 @@
+export interface Reserves {
+    readonly reserve0: bigint;
+    readonly reserve1: bigint;
+    readonly blockTimestampLast: bigint;
+}

package/build/tests/pool/decodeReserves.js

@@ -0,0 +1,13 @@
+import { BinaryReader } from '@btc-vision/bsi-binary';
+function decodeReserves(data) {
+    const reader = new BinaryReader(data);
+    return {
+        reserve0: reader.readU256(),
+        reserve1: reader.readU256(),
+        blockTimestampLast: reader.readU64(),
+    };
+}
+const transferEventData = Buffer.from('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlxkHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGd9QMYGAAAAAAAA', 'base64');
+const bytes = Uint8Array.from(transferEventData);
+const transferEvent = decodeReserves(bytes);
+console.log(transferEvent);

package/build/tests/pool/reserves.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/pool/reserves.js

@@ -0,0 +1,18 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+import { AddressGenerator } from '../../generators/AddressGenerator.js';
+import { networks } from 'bitcoinjs-lib';
+const abiCoder = new ABICoder();
+const reservesSelector = Number(`0x` + abiCoder.encodeSelector('getReserves'));
+function getReserves() {
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(reservesSelector);
+    return Buffer.from(calldata.getBuffer());
+}
+const calldata = getReserves();
+console.log('reserves ->', calldata.toString('hex'));
+const writer = new BinaryWriter();
+writer.writeU256(45230079600746738308285183004243888412290717325243858060208446020071790796183n);
+const virtualAddress = Buffer.from(writer.getBuffer());
+console.log('virtualAddress ->', virtualAddress);
+const poolAddress = AddressGenerator.generatePKSH(virtualAddress, networks.regtest);
+console.log('poolAddress ->', poolAddress);

package/build/tests/shared/Utils.d.ts

@@ -0,0 +1,2 @@
+export declare function expandToDecimals(n: number, decimals?: bigint): bigint;
+export declare function shuffleArray(array: Array<unknown>): void;

package/build/tests/shared/Utils.js

@@ -0,0 +1,14 @@
+import BigNumber from 'bignumber.js';
+BigNumber.config({ EXPONENTIAL_AT: 256 });
+export function expandToDecimals(n, decimals = 18n) {
+    const amount = new BigNumber(n)
+        .multipliedBy(new BigNumber(10).pow(decimals.toString()))
+        .decimalPlaces(0);
+    return BigInt(amount.toString());
+}
+export function shuffleArray(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+}

package/build/tests/shared/interaction.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Wallet } from '../../keypair/Wallet.js';
+import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { BroadcastResponse } from '../../utxo/interfaces/BroadcastResponse.js';
+export declare const wallet: Wallet;
+export declare function interact(contract: Address, calldata: Buffer, mine?: boolean, UTXOs?: UTXO[], feeRate?: number, priorityFee?: bigint): Promise<[[string, string, UTXO[]] | undefined, BroadcastResponse | undefined]>;

package/build/tests/shared/interaction.js

@@ -0,0 +1,85 @@
+import { Wallet } from '../../keypair/Wallet.js';
+import { Regtest } from '../Regtest.js';
+import { OPNetLimitedProvider } from '../../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { shuffleArray } from './Utils.js';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+export const wallet = new Wallet(Regtest.wallet, network);
+const utxoManager = new OPNetLimitedProvider('http://localhost:9001');
+const factory = new TransactionFactory();
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+await rpc.init(Regtest.config);
+const requestedAmount = 10n ** 8n * 500n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: requestedAmount,
+};
+const utxos = await utxoManager.fetchUTXOMultiAddr(utxoSetting);
+shuffleArray(utxos);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+export async function interact(contract, calldata, mine = false, UTXOs = utxos, feeRate = 450, priorityFee = 10000n) {
+    if (!UTXOs.length) {
+        UTXOs = utxos;
+    }
+    if (!UTXOs.length) {
+        throw new Error('No UTXOs found');
+    }
+    let txid;
+    let finalTx;
+    for (let i = 0; i < UTXOs.length; i += 1) {
+        let utxo = UTXOs[i];
+        const interactionParameters = {
+            from: wallet.p2tr,
+            to: contract,
+            utxos: [utxo],
+            signer: wallet.keypair,
+            network: network,
+            feeRate: feeRate,
+            priorityFee: priorityFee,
+            calldata: calldata,
+        };
+        try {
+            finalTx = await factory.signInteraction(interactionParameters);
+            try {
+                txid = await utxoManager.broadcastTransaction(finalTx[0], false);
+                console.log(`Transaction ID:`, txid);
+            }
+            catch (e) {
+                continue;
+            }
+            if (!txid) {
+                continue;
+            }
+            try {
+                txid = await utxoManager.broadcastTransaction(finalTx[1], false);
+                console.log(`Transaction ID:`, txid);
+            }
+            catch (e) {
+                continue;
+            }
+        }
+        catch (e) {
+            console.log(e);
+            continue;
+        }
+        break;
+    }
+    if (mine) {
+        await mineBlock();
+    }
+    rpc.destroy();
+    return [finalTx, txid];
+}

package/build/tests/shared/tokens.d.ts

@@ -0,0 +1,6 @@
+import { Address } from '@btc-vision/bsi-binary';
+export declare const FACTORY_ADDRESS: Address;
+export declare const POOL_ADDRESS: Address;
+export declare const WBTC_ADDRESS: Address;
+export declare const MOTO_ADDRESS: Address;
+export declare const ROUTER_ADDRESS: Address;

package/build/tests/shared/tokens.js

@@ -0,0 +1,5 @@
+export const FACTORY_ADDRESS = 'bcrt1qz98txrd6csz0ljhp0v2rw8846k0zgn57uul8c9';
+export const POOL_ADDRESS = 'bcrt1qzwth3t3wdgy83tt9xegq7yww5dx0rhy3ezglg9';
+export const WBTC_ADDRESS = 'bcrt1q99qtptumw027cw8w274tqzd564q66u537vn0lh';
+export const MOTO_ADDRESS = 'bcrt1qwx9h2fvqlzx84t6jhxa424y7g2ynayt8p9rs38';
+export const ROUTER_ADDRESS = 'bcrt1qelqwcguvwkgr90w6u5f2q0a7gqlnq4w8rl26ht';

package/build/tests/stakeReg.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/stakeReg.js

@@ -0,0 +1,73 @@
+import { wBTC } from '../metadata/contracts/wBTC.js';
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wBtc = new wBTC(network);
+const wallet = new Wallet(Regtest.wallet, network);
+const utxoManager = new OPNetLimitedProvider('http://localhost:9001');
+const factory = new TransactionFactory();
+const abiCoder = new ABICoder();
+const stakeSelector = Number(`0x` + abiCoder.encodeSelector('stake'));
+function generateCalldata(amount) {
+    const addCalldata = new BinaryWriter();
+    addCalldata.writeSelector(stakeSelector);
+    addCalldata.writeU256(amount);
+    return Buffer.from(addCalldata.getBuffer());
+}
+const shouldMineBlock = true;
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+await rpc.init(Regtest.config);
+const requestedAmount = 1n * 100000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: requestedAmount,
+};
+const utxos = await utxoManager.fetchUTXOMultiAddr(utxoSetting);
+console.log(`UTXOs:`, utxos);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const calldata = generateCalldata(520000n);
+const interactionParameters = {
+    from: wallet.p2wpkh,
+    to: wBtc.getAddress(),
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 1000,
+    priorityFee: 100000n,
+    calldata: calldata,
+};
+const finalTx = await factory.signInteraction(interactionParameters);
+const firstTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx[0],
+});
+console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+if (!firstTxBroadcast) {
+    throw new Error('Could not broadcast first transaction');
+}
+const secondTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx[1],
+});
+console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+if (!secondTxBroadcast) {
+    throw new Error('Could not broadcast second transaction');
+}
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();

package/build/tests/stakedReg.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/stakedReg.js

@@ -0,0 +1,28 @@
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { networks } from 'bitcoinjs-lib';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Regtest.wallet, network);
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+await rpc.init(Regtest.config);
+const abiCoder = new ABICoder();
+const transferSelector = Number(`0x` + abiCoder.encodeSelector('stakedAmount'));
+function generateCalldata(to) {
+    const addCalldata = new BinaryWriter();
+    addCalldata.writeSelector(transferSelector);
+    addCalldata.writeAddress(to);
+    return Buffer.from(addCalldata.getBuffer());
+}
+const call = generateCalldata(wallet.p2tr);
+console.log('call', call.toString('hex'));
+rpc.destroy();

package/build/tests/test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/test.js

@@ -0,0 +1,51 @@
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { FundingTransaction } from '../transaction/builders/FundingTransaction.js';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Regtest.wallet, network);
+const utxoManager = new OPNetLimitedProvider('http://localhost:9001');
+const shouldMineBlock = true;
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+(async () => {
+    await rpc.init(Regtest.config);
+    const utxoSetting = {
+        address: wallet.p2wpkh,
+        minAmount: 10000n,
+        requestedAmount: 100000n,
+    };
+    const utxos = await utxoManager.fetchUTXO(utxoSetting);
+    if (!utxos) {
+        throw new Error('No UTXOs found');
+    }
+    const interactionParameters = {
+        from: wallet.p2wpkh,
+        to: 'bcrt1qqvf4gprr05z248ph6gvx54rpg08p8ngq3zh8uh',
+        utxos: utxos,
+        signer: wallet.keypair,
+        network: network,
+        feeRate: 150,
+        priorityFee: 1000n,
+        amount: 0n,
+    };
+    const fundingTransaction = new FundingTransaction(interactionParameters);
+    const fundingTx = await fundingTransaction.signTransaction();
+    console.log(fundingTx.toHex());
+    const secondTxBroadcast = await rpc.sendRawTransaction({
+        hexstring: fundingTx.toHex(),
+    });
+    console.log(`Transaction broadcasted: ${secondTxBroadcast}`);
+    if (shouldMineBlock) {
+        await mineBlock();
+    }
+})();

package/build/tests/test2.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/test2.js

@@ -0,0 +1,73 @@
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
+import { networks, Psbt } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { EcKeyPair } from '../keypair/EcKeyPair.js';
+import { MultiSignTransaction } from '../transaction/builders/MultiSignTransaction.js';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Regtest.wallet, network);
+const opnet = new OPNetLimitedProvider('http://localhost:9001');
+const factory = new TransactionFactory();
+const shouldMineBlock = false;
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+await rpc.init(Regtest.config);
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: 300000n,
+};
+const utxos = await opnet.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const unwrapAmount = 300000n;
+const unwrapUtxos = await opnet.fetchUnWrapParameters(unwrapAmount, wallet.p2tr);
+if (!unwrapUtxos) {
+    throw new Error('No UTXOs found for unwrap');
+}
+const unwrapParameters = {
+    from: wallet.p2tr,
+    utxos: utxos,
+    unwrapUTXOs: unwrapUtxos.vaultUTXOs,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 100,
+    priorityFee: 10000n,
+    amount: unwrapAmount,
+};
+const finalTx = await factory.unwrap(unwrapParameters);
+const pubkeys = [
+    'AtOOpbDsniLbs2QGuqPFu7AnCOK9lNSSl+pvPr0m0Yx3',
+    'AgPmjuI2/MNJM9STswWm8MdWEllHHRPs0Q3+DjdjOny+',
+    'A4JEwTBwTx5QaLCFORTow27UQvkLQWZguhz6N+d8FczI',
+    'A7ZKMoDQJlcQNbzIikCE5MPiFC81RvHHTeTMRx2/bFiO',
+]
+    .map((key) => Buffer.from(key, 'base64'))
+    .sort((a, b) => a.compare(b));
+const rlSigner2 = EcKeyPair.fromPrivateKey(Buffer.from('c3878546c453bca783fd91965218242eecc32d5443764d4a7f233ff018f002e0', 'hex'), network);
+const realSigner = Wallet.fromWif('cRHbWamSVDkJWwjq5vMtriuFsWcptWmA7z8Nkqotk9vJ891KMBXc', network);
+console.log('FUNDING', finalTx.fundingTransaction);
+const removedFirstTwoChar = finalTx.psbt.slice(4);
+const psbtTransaction2 = Psbt.fromHex(removedFirstTwoChar, { network });
+const signed3 = MultiSignTransaction.signPartial(psbtTransaction2, rlSigner2, 1, [2, 2, 2, 2]);
+const finalized = MultiSignTransaction.attemptFinalizeInputs(psbtTransaction2, 1, [pubkeys, pubkeys, pubkeys, pubkeys], false);
+console.log(`Signed`, signed3, finalized);
+const signed4 = MultiSignTransaction.signPartial(psbtTransaction2, realSigner.keypair, 1, [2, 2, 2, 2]);
+const finalized2 = MultiSignTransaction.attemptFinalizeInputs(psbtTransaction2, 1, [pubkeys, pubkeys, pubkeys, pubkeys], true);
+console.log(`Signed`, signed4, finalized2);
+const final = psbtTransaction2.extractTransaction().toHex();
+console.log(`Finalized`, final);
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();

package/build/tests/testReg.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/testReg.js

@@ -0,0 +1,91 @@
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Regtest.wallet, network);
+const utxoManager = new OPNetLimitedProvider('http://localhost:9001');
+const factory = new TransactionFactory();
+const abiCoder = new ABICoder();
+const transferSelector = Number(`0x` + abiCoder.encodeSelector('mintAndApproveWBTC'));
+function getTransferToCalldata(to, amount) {
+    const addCalldata = new BinaryWriter();
+    addCalldata.writeSelector(transferSelector);
+    addCalldata.writeU256(amount);
+    addCalldata.writeAddress(to);
+    return Buffer.from(addCalldata.getBuffer());
+}
+const shouldMineBlock = true;
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+await rpc.init(Regtest.config);
+const requestedAmount = 10000000000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: requestedAmount,
+};
+const utxos = await utxoManager.fetchUTXOMultiAddr(utxoSetting);
+console.log(`UTXOs:`, utxos);
+try {
+    for (let i = 0; i < 3000; i++) {
+        if (!utxos) {
+            console.log(`Used all UTXOs`);
+            throw new Error('No UTXOs found');
+        }
+        const calldata = getTransferToCalldata('bcrt1p4q7vkuvy9k0cez7vs4cp9yuwqxafesmdgtu0g5928w9cdvtax54snmucw8', 520000n);
+        const utxo = utxos.shift();
+        if (!utxo) {
+            break;
+        }
+        const interactionParameters = {
+            from: wallet.p2wpkh,
+            to: 'bcrt1qs3re7ly4we7wtwncfcv22xcsmas0gngalazm9f',
+            utxos: [utxo],
+            signer: wallet.keypair,
+            network: network,
+            feeRate: 1000,
+            priorityFee: 100000n,
+            calldata: calldata,
+        };
+        try {
+            const finalTx = await factory.signInteraction(interactionParameters);
+            const firstTxBroadcast = await rpc
+                .sendRawTransaction({
+                hexstring: finalTx[0],
+            })
+                .catch((e) => { });
+            console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+            if (!firstTxBroadcast) {
+                continue;
+            }
+            const secondTxBroadcast = await rpc
+                .sendRawTransaction({
+                hexstring: finalTx[1],
+            })
+                .catch((e) => { });
+            console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+            if (!secondTxBroadcast) {
+            }
+        }
+        catch (e) { }
+    }
+}
+catch (e) {
+    console.error(e);
+}
+console.log(`All transactions broadcasted`);
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();

package/build/tests/tokens.d.ts

@@ -0,0 +1,6 @@
+import { Address } from '@btc-vision/bsi-binary';
+export declare const FACTORY_ADDRESS: Address;
+export declare const POOL_ADDRESS: Address;
+export declare const WBTC_ADDRESS: Address;
+export declare const MOTO_ADDRESS: Address;
+export declare const ROUTER_ADDRESS: Address;

package/build/tests/tokens.js

@@ -0,0 +1,5 @@
+export const FACTORY_ADDRESS = 'bcrt1qkg4gn2g0zwksthnykuv2ey59dek3sg4tegd90c';
+export const POOL_ADDRESS = 'bcrt1qljpxj4sg5dd6v8knx5g6jq9ycsr0wgtwfqxfjs';
+export const WBTC_ADDRESS = 'bcrt1qq377w5zsu2p8ywfvr6qa86duy9y8wrdl3jf9td';
+export const MOTO_ADDRESS = 'bcrt1qwx9h2fvqlzx84t6jhxa424y7g2ynayt8p9rs38';
+export const ROUTER_ADDRESS = 'bcrt1qekusxelmczqcw2cy22m4d0rrmkh29xcrtf4a4r';

package/build/tests/totalRewardReg.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/totalRewardReg.js

@@ -0,0 +1,28 @@
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { networks } from 'bitcoinjs-lib';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Regtest.wallet, network);
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+await rpc.init(Regtest.config);
+const wrapAmount = 1n * 100000000n;
+const abiCoder = new ABICoder();
+const transferSelector = Number(`0x` + abiCoder.encodeSelector('totalStaked'));
+function generateCalldata(to, amount) {
+    const addCalldata = new BinaryWriter();
+    addCalldata.writeSelector(transferSelector);
+    return Buffer.from(addCalldata.getBuffer());
+}
+const call = generateCalldata(wallet.p2tr, wrapAmount);
+console.log('call', call.toString('hex'));
+rpc.destroy();

package/build/tests/transfer.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/transfer.js

@@ -0,0 +1,74 @@
+import { wBTC } from '../metadata/contracts/wBTC.js';
+import { Wallet } from '../keypair/Wallet.js';
+import { Testnet } from './Regtest.js';
+import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const network = networks.testnet;
+const rpc = new BitcoinRPC();
+const wBtc = new wBTC(network);
+const wallet = new Wallet(Testnet.wallet, network);
+const utxoManager = new OPNetLimitedProvider('https://testnet.opnet.org');
+const factory = new TransactionFactory();
+const abiCoder = new ABICoder();
+const transferSelector = Number(`0x` + abiCoder.encodeSelector('transfer'));
+function getTransferToCalldata(to, amount) {
+    const addCalldata = new BinaryWriter();
+    addCalldata.writeSelector(transferSelector);
+    addCalldata.writeAddress(to);
+    addCalldata.writeU256(amount);
+    return Buffer.from(addCalldata.getBuffer());
+}
+const shouldMineBlock = false;
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+(async () => {
+    await rpc.init(Testnet.config);
+    const utxoSetting = {
+        address: wallet.p2wpkh,
+        minAmount: 10000n,
+        requestedAmount: 100000n,
+    };
+    const utxos = await utxoManager.fetchUTXO(utxoSetting);
+    console.log(`UTXOs:`, utxos);
+    if (!utxos) {
+        throw new Error('No UTXOs found');
+    }
+    const calldata = getTransferToCalldata('tb1pt3ncc5ktfzpry2uvnag06v3jkv4quvmdydf09q8fx6rkgd7f5s8q3aenuk', 5000000n);
+    const interactionParameters = {
+        from: wallet.p2wpkh,
+        to: wBtc.getAddress(),
+        utxos: utxos,
+        signer: wallet.keypair,
+        network: network,
+        feeRate: 1000,
+        priorityFee: 50000n,
+        calldata: calldata,
+    };
+    const finalTx = await factory.signInteraction(interactionParameters);
+    const firstTxBroadcast = await rpc.sendRawTransaction({
+        hexstring: finalTx[0],
+    });
+    console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+    if (!firstTxBroadcast) {
+        throw new Error('Could not broadcast first transaction');
+    }
+    const secondTxBroadcast = await rpc.sendRawTransaction({
+        hexstring: finalTx[1],
+    });
+    console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+    if (!secondTxBroadcast) {
+        throw new Error('Could not broadcast second transaction');
+    }
+    if (shouldMineBlock) {
+        await mineBlock();
+    }
+})();

package/build/tests/transferReg.d.ts

@@ -0,0 +1 @@
+export {};