@btc-vision/transaction 1.0.41 → 1.0.44

package/build/tests/interaction.js

@@ -0,0 +1,62 @@
+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';
+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 = 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');
+}
+export async function interact(contract, calldata, mine = true) {
+    const interactionParameters = {
+        from: wallet.p2wpkh,
+        to: contract,
+        utxos: utxos,
+        signer: wallet.keypair,
+        network: network,
+        feeRate: 1000,
+        priorityFee: 100000n,
+        calldata: calldata,
+    };
+    const finalTx = 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}`, finalTx[1]);
+    if (!secondTxBroadcast) {
+        throw new Error('Could not broadcast second transaction');
+    }
+    if (mine) {
+        await mineBlock();
+    }
+    rpc.destroy();
+}

package/build/tests/mineReg.js

@@ -5,7 +5,6 @@ import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
 const network = networks.regtest;
 const rpc = new BitcoinRPC();
 const wallet = new Wallet(Regtest.wallet, network);
-const shouldMineBlock = true;
 async function mineBlock() {
     const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
     if (!ok) {
@@ -15,7 +14,5 @@ async function mineBlock() {
     return !!ok.length;
 }
 await rpc.init(Regtest.config);
-if (shouldMineBlock) {
-    await mineBlock();
-}
+await mineBlock();
 rpc.destroy();

package/build/tests/moto/airdropToken.d.ts

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

package/build/tests/moto/airdropToken.js

@@ -0,0 +1,21 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+import { interact, wallet } from '../shared/interaction.js';
+import { MOTO_ADDRESS } from '../shared/tokens.js';
+const abiCoder = new ABICoder();
+const airdropSelector = Number(`0x` + abiCoder.encodeSelector('airdrop'));
+function expandToDecimals(n, decimals = 18n) {
+    return BigInt(n) * 10n ** decimals;
+}
+function airdropToken(amount, to) {
+    const aidropToken = new Map();
+    aidropToken.set(to, amount);
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(airdropSelector);
+    calldata.writeAddressValueTupleMap(aidropToken);
+    return Buffer.from(calldata.getBuffer());
+}
+const tokenAmount = expandToDecimals(10000, 8n);
+const receiver = wallet.p2tr;
+const calldata = airdropToken(tokenAmount, receiver);
+console.log('airdrop ->', calldata.toString('hex'));
+await interact(MOTO_ADDRESS, calldata);

package/build/tests/moto/allowance.d.ts

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

package/build/tests/moto/allowance.js

@@ -0,0 +1,5 @@
+import { ROUTER_ADDRESS } from '../shared/tokens.js';
+import { wallet } from '../shared/interaction.js';
+import { allowance } from '../writers/allowance.js';
+const calldata = allowance(wallet.p2tr, ROUTER_ADDRESS);
+console.log('allowance ->', calldata.toString('hex'));

package/build/tests/moto/approve.d.ts

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

package/build/tests/moto/approve.js

@@ -0,0 +1,6 @@
+import { approve, MAX_UINT256 } from '../writers/approve.js';
+import { MOTO_ADDRESS, ROUTER_ADDRESS } from '../shared/tokens.js';
+import { interact } from '../shared/interaction.js';
+const calldata = approve(ROUTER_ADDRESS, MAX_UINT256);
+console.log('approve ->', calldata.toString('hex'));
+await interact(MOTO_ADDRESS, calldata, false);

package/build/tests/moto/approveWBTC.d.ts

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

package/build/tests/moto/approveWBTC.js

@@ -0,0 +1,12 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const abiCoder = new ABICoder();
+const approveSelector = Number(`0x` + abiCoder.encodeSelector('approve'));
+const MAX_UINT256 = 2n ** 256n - 1n;
+function approve(amount = MAX_UINT256) {
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(approveSelector);
+    calldata.writeU256(amount);
+    return Buffer.from(calldata.getBuffer());
+}
+const calldata = approve(MAX_UINT256);
+console.log('approve ->', calldata.toString('hex'));

package/build/tests/moto/balanceOf.d.ts

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

package/build/tests/moto/balanceOf.js

@@ -0,0 +1,13 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+import { wallet } from '../shared/interaction.js';
+const abiCoder = new ABICoder();
+const balanceSelector = Number(`0x` + abiCoder.encodeSelector('balanceOf'));
+function balanceOf(to) {
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(balanceSelector);
+    calldata.writeAddress(to);
+    return Buffer.from(calldata.getBuffer());
+}
+const receiver = wallet.p2tr;
+const calldata = balanceOf(receiver);
+console.log('balanceOf ->', calldata.toString('hex'));

package/build/tests/motoswap/airdropToken.d.ts

@@ -0,0 +1,11 @@
+import { Address } from '@btc-vision/bsi-binary';
+export interface AddLiquidityParameters {
+    readonly tokenA: Address;
+    readonly tokenB: Address;
+    readonly amountADesired: bigint;
+    readonly amountBDesired: bigint;
+    readonly amountAMin: bigint;
+    readonly amountBMin: bigint;
+    readonly to: Address;
+    readonly deadline: bigint;
+}

package/build/tests/motoswap/airdropToken.js

@@ -0,0 +1,36 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+import { wallet } from '../interaction.js';
+import { wBTC } from '../../metadata/contracts/wBTC.js';
+import { networks } from 'bitcoinjs-lib';
+import { MOTO_ADDRESS } from '../tokens.js';
+const abiCoder = new ABICoder();
+const transferSelector = Number(`0x` + abiCoder.encodeSelector('transfer'));
+function expandToDecimals(n, decimals = 18n) {
+    return BigInt(n) * 10n ** decimals;
+}
+function addLiquidity(parameters) {
+    const calldata = new BinaryWriter();
+    calldata.writeAddress(parameters.tokenA);
+    calldata.writeAddress(parameters.tokenB);
+    calldata.writeU256(parameters.amountADesired);
+    calldata.writeU256(parameters.amountBDesired);
+    calldata.writeU256(parameters.amountAMin);
+    calldata.writeU256(parameters.amountBMin);
+    calldata.writeAddress(parameters.to);
+    calldata.writeU64(parameters.deadline);
+    return Buffer.from(calldata.getBuffer());
+}
+const token0Amount = expandToDecimals(1);
+const token1Amount = expandToDecimals(1);
+const receiver = wallet.p2tr;
+const calldata = addLiquidity({
+    tokenA: wBTC.getAddress(networks.regtest),
+    tokenB: MOTO_ADDRESS,
+    amountADesired: token0Amount,
+    amountBDesired: token1Amount,
+    amountAMin: 0n,
+    amountBMin: 0n,
+    to: receiver,
+    deadline: 2n,
+});
+console.log(calldata.toString('hex'));

package/build/tests/motoswap/deployMoto.d.ts

@@ -0,0 +1,4 @@
+export declare function deployMoto(contracts: string[]): Promise<{
+    contract: string;
+    file: string;
+}[]>;

package/build/tests/motoswap/deployMoto.js

@@ -0,0 +1,87 @@
+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 * as fs from 'fs';
+import { shuffleArray } from '../shared/Utils.js';
+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 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 requestedAmount = 100000000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: requestedAmount,
+};
+const utxos = await utxoManager.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+shuffleArray(utxos);
+export async function deployMoto(contracts) {
+    let deployed = [];
+    for (let contract of contracts) {
+        const bytecode = fs.readFileSync(contract);
+        for (let utxo of utxos) {
+            const deploymentParameters = {
+                from: wallet.p2wpkh,
+                utxos: [utxo],
+                signer: wallet.keypair,
+                network: network,
+                feeRate: 500,
+                priorityFee: 50000n,
+                bytecode: bytecode,
+            };
+            try {
+                const finalTx = await factory.signDeployment(deploymentParameters);
+                console.log(`Final transaction:`, finalTx);
+                let txid;
+                try {
+                    txid = await utxoManager.broadcastTransaction(finalTx.transaction[0], false);
+                    console.log(`Transaction ID:`, txid);
+                }
+                catch (e) {
+                    continue;
+                }
+                if (!txid) {
+                    continue;
+                }
+                try {
+                    txid = await utxoManager.broadcastTransaction(finalTx.transaction[1], false);
+                    console.log(`Transaction ID:`, txid);
+                }
+                catch (e) {
+                    continue;
+                }
+                if (!txid) {
+                    continue;
+                }
+                deployed.push({ contract: finalTx.contractAddress, file: contract });
+                console.log(`Contract deployed at ${finalTx.contractAddress}`);
+            }
+            catch (e) {
+                continue;
+            }
+            break;
+        }
+    }
+    if (shouldMineBlock) {
+        await mineBlock();
+    }
+    rpc.destroy();
+    return deployed;
+}

package/build/tests/motoswap/deployMotoRegStep1.d.ts

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

package/build/tests/motoswap/deployMotoRegStep1.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 * as fs from 'fs';
+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 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 requestedAmount = 100000000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: requestedAmount,
+};
+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]];
+    }
+}
+const utxos = await utxoManager.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+shuffleArray(utxos);
+const contracts = ['./bytecode/wbtc.wasm', './bytecode/moto.wasm', './bytecode/pool.wasm'];
+let deployed = [];
+for (let contract of contracts) {
+    const bytecode = fs.readFileSync(contract);
+    for (let utxo of utxos) {
+        const deploymentParameters = {
+            from: wallet.p2wpkh,
+            utxos: [utxo],
+            signer: wallet.keypair,
+            network: network,
+            feeRate: 500,
+            priorityFee: 50000n,
+            bytecode: bytecode,
+        };
+        try {
+            const finalTx = factory.signDeployment(deploymentParameters);
+            console.log(`Final transaction:`, finalTx);
+            let txid;
+            try {
+                txid = await utxoManager.broadcastTransaction(finalTx.transaction[0], false);
+                console.log(`Transaction ID:`, txid);
+            }
+            catch (e) {
+                continue;
+            }
+            if (!txid) {
+                continue;
+            }
+            try {
+                txid = await utxoManager.broadcastTransaction(finalTx.transaction[1], false);
+                console.log(`Transaction ID:`, txid);
+            }
+            catch (e) {
+                continue;
+            }
+            if (!txid) {
+                continue;
+            }
+            deployed.push({ contract: finalTx.contractAddress, file: contract });
+            console.log(`Contract deployed at ${finalTx.contractAddress}`);
+        }
+        catch (e) {
+            continue;
+        }
+        break;
+    }
+}
+console.log(deployed);
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();

package/build/tests/motoswap/deployMotoRegStep2.d.ts

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

package/build/tests/motoswap/deployMotoRegStep2.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 * as fs from 'fs';
+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 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 requestedAmount = 100000000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: requestedAmount,
+};
+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]];
+    }
+}
+const utxos = await utxoManager.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+shuffleArray(utxos);
+const contracts = ['./bytecode/wbtc.wasm', './bytecode/wbtc.wasm'];
+let deployed = [];
+for (let contract of contracts) {
+    const bytecode = fs.readFileSync(contract);
+    for (let utxo of utxos) {
+        const deploymentParameters = {
+            from: wallet.p2wpkh,
+            utxos: [utxo],
+            signer: wallet.keypair,
+            network: network,
+            feeRate: 500,
+            priorityFee: 50000n,
+            bytecode: bytecode,
+        };
+        try {
+            const finalTx = factory.signDeployment(deploymentParameters);
+            console.log(`Final transaction:`, finalTx);
+            let txid;
+            try {
+                txid = await utxoManager.broadcastTransaction(finalTx.transaction[0], false);
+                console.log(`Transaction ID:`, txid);
+            }
+            catch (e) {
+                continue;
+            }
+            if (!txid) {
+                continue;
+            }
+            try {
+                txid = await utxoManager.broadcastTransaction(finalTx.transaction[1], false);
+                console.log(`Transaction ID:`, txid);
+            }
+            catch (e) {
+                continue;
+            }
+            if (!txid) {
+                continue;
+            }
+            deployed.push({ contract: finalTx.contractAddress, file: contract });
+            console.log(`Contract deployed at ${finalTx.contractAddress}`);
+        }
+        catch (e) {
+            continue;
+        }
+        break;
+    }
+}
+console.log(deployed);
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();

package/build/tests/motoswap/deployStep1.d.ts

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

package/build/tests/motoswap/deployStep1.js

@@ -0,0 +1,5 @@
+import { deployMoto } from './deployMoto.js';
+console.log(`Step 1: Deploying MotoSwap contracts`);
+const contractsToDeploy = ['./bytecode/wbtc.wasm', './bytecode/moto.wasm', './bytecode/pool.wasm'];
+const contracts = await deployMoto(contractsToDeploy);
+console.log(`Contracts deployed:`, contracts);

package/build/tests/motoswap/deployStep2.d.ts

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

package/build/tests/motoswap/deployStep2.js

@@ -0,0 +1,5 @@
+import { deployMoto } from './deployMoto.js';
+console.log(`Step 2: Deploying Factory`);
+const contractsToDeploy = ['./bytecode/factory.wasm'];
+const contracts = await deployMoto(contractsToDeploy);
+console.log(`Contracts deployed:`, contracts);

package/build/tests/motoswap/deployStep3.d.ts

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

package/build/tests/motoswap/deployStep3.js

@@ -0,0 +1,5 @@
+import { deployMoto } from './deployMoto.js';
+console.log(`Step 3: Deploying Router`);
+const contractsToDeploy = ['./bytecode/router.wasm'];
+const contracts = await deployMoto(contractsToDeploy);
+console.log(`Contracts deployed:`, contracts);

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

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { Address } from '@btc-vision/bsi-binary';
+export declare function interact(contract: Address, calldata: Buffer): Promise<void>;

package/build/tests/motoswap/interaction.js

@@ -0,0 +1,63 @@
+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';
+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 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');
+}
+export async function interact(contract, calldata) {
+    const interactionParameters = {
+        from: wallet.p2wpkh,
+        to: contract,
+        utxos: utxos,
+        signer: wallet.keypair,
+        network: network,
+        feeRate: 1000,
+        priorityFee: 100000n,
+        calldata: calldata,
+    };
+    const finalTx = 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}`, finalTx[1]);
+    if (!secondTxBroadcast) {
+        throw new Error('Could not broadcast second transaction');
+    }
+    if (shouldMineBlock) {
+        await mineBlock();
+    }
+    rpc.destroy();
+}

package/build/tests/motoswap/routerAddLiquidity.d.ts

@@ -0,0 +1,11 @@
+import { Address } from '@btc-vision/bsi-binary';
+export interface AddLiquidityParameters {
+    readonly tokenA: Address;
+    readonly tokenB: Address;
+    readonly amountADesired: bigint;
+    readonly amountBDesired: bigint;
+    readonly amountAMin: bigint;
+    readonly amountBMin: bigint;
+    readonly to: Address;
+    readonly deadline: bigint;
+}

package/build/tests/motoswap/routerAddLiquidity.js

@@ -0,0 +1,36 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+import { interact, wallet } from '../shared/interaction.js';
+import { wBTC } from '../../metadata/contracts/wBTC.js';
+import { networks } from 'bitcoinjs-lib';
+import { MOTO_ADDRESS, ROUTER_ADDRESS } from '../shared/tokens.js';
+import { expandToDecimals } from '../shared/Utils.js';
+const abiCoder = new ABICoder();
+const addLiquiditySelector = Number(`0x` + abiCoder.encodeSelector('addLiquidity'));
+function addLiquidity(parameters) {
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(addLiquiditySelector);
+    calldata.writeAddress(parameters.tokenA);
+    calldata.writeAddress(parameters.tokenB);
+    calldata.writeU256(parameters.amountADesired);
+    calldata.writeU256(parameters.amountBDesired);
+    calldata.writeU256(parameters.amountAMin);
+    calldata.writeU256(parameters.amountBMin);
+    calldata.writeAddress(parameters.to);
+    calldata.writeU64(parameters.deadline);
+    return Buffer.from(calldata.getBuffer());
+}
+const token0Amount = expandToDecimals(1000, 8n);
+const token1Amount = 600000n;
+const receiver = wallet.p2tr;
+const calldata = addLiquidity({
+    tokenA: MOTO_ADDRESS,
+    tokenB: wBTC.getAddress(networks.regtest),
+    amountADesired: token0Amount,
+    amountBDesired: token1Amount,
+    amountAMin: 0n,
+    amountBMin: 0n,
+    to: receiver,
+    deadline: 5000n,
+});
+console.log('add liquidity:', calldata.toString('hex'));
+await interact(ROUTER_ADDRESS, calldata);

package/build/tests/multisign.js

@@ -36,7 +36,7 @@ const multiSignParams = {
     requestedAmount: 600000n,
 };
 const multiSign = new MultiSignTransaction(multiSignParams);
-const signed = multiSign.signPSBT();
+const signed = await multiSign.signPSBT();
 const signed3 = MultiSignTransaction.signPartial(signed, rlSigner2, 0, [2]);
 console.log(`Signed`, signed3, signed.toHex());
 const signed2 = MultiSignTransaction.signPartial(signed, realSigner.keypair, 0, [2]);

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,9 @@
+export function expandToDecimals(n, decimals = 18n) {
+    return BigInt(n) * 10n ** decimals;
+}
+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]];
+    }
+}