ecash-agora 2.2.0 → 2.5.0

package/tests/oneshot.test.ts

@@ -32,6 +32,7 @@ import {
 } from '../src/oneshot.js';
 import { Agora, AgoraOffer } from '../src/agora.js';
 import { EventEmitter, once } from 'node:events';
+import { Wallet } from 'ecash-wallet/src/wallet.js';
 
 use(chaiAsPromised);
 
@@ -704,4 +705,293 @@ describe('SLP', () => {
             numPages: 1,
         });
     });
+    it('We can cancel an Agora Oneshot offer using cancel()', async () => {
+        // Create Agora object to access trades
+        const agora = new Agora(chronik);
+
+        const cancelerSk = fromHex('99'.repeat(32));
+        const cancelerWallet = Wallet.fromSk(cancelerSk, chronik);
+
+        const cancelerPk = cancelerWallet.pk;
+
+        const cancelerP2pkh = cancelerWallet.script;
+
+        await runner.sendToScript(50000n, cancelerP2pkh);
+
+        await cancelerWallet.sync();
+
+        const utxos = cancelerWallet.utxos;
+        expect(utxos.length).to.equal(1);
+        const utxo = utxos[0];
+
+        // 1. Seller creates an NFT1 GROUP token
+        const txBuildGenesisGroup = new TxBuilder({
+            inputs: [
+                {
+                    input: {
+                        prevOut: utxo.outpoint,
+                        signData: {
+                            sats: utxo.sats,
+                            outputScript: cancelerP2pkh,
+                        },
+                    },
+                    signatory: P2PKHSignatory(
+                        cancelerSk,
+                        cancelerPk,
+                        ALL_BIP143,
+                    ),
+                },
+            ],
+            outputs: [
+                {
+                    sats: 0n,
+                    script: slpGenesis(
+                        SLP_NFT1_GROUP,
+                        {
+                            tokenTicker: 'SLP NFT1 GROUP TOKEN',
+                            decimals: 4,
+                        },
+                        1n,
+                    ),
+                },
+                { sats: 10000n, script: cancelerP2pkh },
+            ],
+        });
+        const genesisTx = txBuildGenesisGroup.sign();
+        const genesisTxid = (await chronik.broadcastTx(genesisTx.ser())).txid;
+        const groupTokenId = genesisTxid;
+
+        expect(await chronik.token(genesisTxid)).to.deep.equal({
+            tokenId: groupTokenId,
+            tokenType: SLP_TOKEN_TYPE_NFT1_GROUP,
+            genesisInfo: {
+                tokenTicker: 'SLP NFT1 GROUP TOKEN',
+                tokenName: '',
+                url: '',
+                hash: '',
+                decimals: 4,
+            },
+            timeFirstSeen: 1300000000,
+        });
+
+        // 2. Seller creates an NFT1 CHILD token using the group token
+        const txBuildGenesisChild = new TxBuilder({
+            inputs: [
+                {
+                    input: {
+                        prevOut: {
+                            txid: genesisTxid,
+                            outIdx: 1,
+                        },
+                        signData: {
+                            sats: 10000n,
+                            outputScript: cancelerP2pkh,
+                        },
+                    },
+                    signatory: P2PKHSignatory(
+                        cancelerSk,
+                        cancelerPk,
+                        ALL_BIP143,
+                    ),
+                },
+            ],
+            outputs: [
+                {
+                    sats: 0n,
+                    script: slpGenesis(
+                        SLP_NFT1_CHILD,
+                        {
+                            tokenTicker: 'SLP NFT1 CHILD TOKEN',
+                            decimals: 0,
+                        },
+                        1n,
+                    ),
+                },
+                { sats: 8000n, script: cancelerP2pkh },
+            ],
+        });
+        const genesisChildTx = txBuildGenesisChild.sign();
+        const genesisChildTxid = (
+            await chronik.broadcastTx(genesisChildTx.ser())
+        ).txid;
+        const childTokenId = genesisChildTxid;
+
+        expect(await chronik.token(childTokenId)).to.deep.equal({
+            tokenId: childTokenId,
+            tokenType: SLP_TOKEN_TYPE_NFT1_CHILD,
+            genesisInfo: {
+                tokenTicker: 'SLP NFT1 CHILD TOKEN',
+                tokenName: '',
+                url: '',
+                hash: '',
+                decimals: 0,
+            },
+            timeFirstSeen: 1300000000,
+        });
+
+        const emitter = new EventEmitter();
+        const ws = chronik.ws({
+            onMessage: async msg => {
+                if (!emitter.emit('ws', msg)) {
+                    console.warn('Emitted msg without any listeners', msg);
+                }
+            },
+        });
+        await ws.waitForOpen();
+        agora.subscribeWs(ws, {
+            type: 'TOKEN_ID',
+            tokenId: childTokenId,
+        });
+        const listenNext = () => once(emitter, 'ws') as Promise<[MsgTxClient]>;
+
+        // 3. Seller sends the NFT to an ad setup output for an Agora Oneshot
+        //    covenant that asks for 80000 sats
+        const enforcedOutputs: TxOutput[] = [
+            {
+                sats: BigInt(0),
+                script: slpSend(childTokenId, SLP_NFT1_CHILD, [0n, 1n]),
+            },
+            { sats: BigInt(80000), script: cancelerP2pkh },
+        ];
+        const agoraOneshot = new AgoraOneshot({
+            enforcedOutputs,
+            cancelPk: cancelerPk,
+        });
+        const agoraAdScript = agoraOneshot.adScript();
+        const agoraAdP2sh = Script.p2sh(shaRmd160(agoraAdScript.bytecode));
+        const txBuildAdSetup = new TxBuilder({
+            inputs: [
+                {
+                    input: {
+                        prevOut: {
+                            txid: genesisChildTxid,
+                            outIdx: 1,
+                        },
+                        signData: {
+                            sats: 8000n,
+                            outputScript: cancelerP2pkh,
+                        },
+                    },
+                    signatory: P2PKHSignatory(
+                        cancelerSk,
+                        cancelerPk,
+                        ALL_BIP143,
+                    ),
+                },
+            ],
+            outputs: [
+                {
+                    sats: 0n,
+                    script: slpSend(childTokenId, SLP_NFT1_CHILD, [1n]),
+                },
+                { sats: 7000n, script: agoraAdP2sh },
+            ],
+        });
+        const adSetupTx = txBuildAdSetup.sign();
+        const adSetupTxid = (await chronik.broadcastTx(adSetupTx.ser())).txid;
+
+        // 4. Seller finishes offer setup + sends NFT to the advertised P2SH
+        const agoraScript = agoraOneshot.script();
+        const agoraP2sh = Script.p2sh(shaRmd160(agoraScript.bytecode));
+        const txBuildOffer = new TxBuilder({
+            inputs: [
+                {
+                    input: {
+                        prevOut: {
+                            txid: adSetupTxid,
+                            outIdx: 1,
+                        },
+                        signData: {
+                            sats: 7000n,
+                            redeemScript: agoraAdScript,
+                        },
+                    },
+                    signatory: AgoraOneshotAdSignatory(cancelerSk),
+                },
+            ],
+            outputs: [
+                {
+                    sats: 0n,
+                    script: slpSend(childTokenId, SLP_NFT1_CHILD, [1n]),
+                },
+                { sats: 546n, script: agoraP2sh },
+            ],
+        });
+        const offerTx = txBuildOffer.sign();
+        const offerPromise = listenNext();
+        const offerTxid = (await chronik.broadcastTx(offerTx.ser())).txid;
+        const offerOutpoint: OutPoint = {
+            txid: offerTxid,
+            outIdx: 1,
+        };
+        const offerTxBuilderInput: TxInput = {
+            prevOut: offerOutpoint,
+            signData: {
+                redeemScript: agoraScript,
+                sats: 546n,
+            },
+        };
+
+        // Expected created offer
+        const expectedOffer = new AgoraOffer({
+            variant: {
+                type: 'ONESHOT',
+                params: agoraOneshot,
+            },
+            outpoint: offerOutpoint,
+            txBuilderInput: offerTxBuilderInput,
+            token: {
+                tokenId: childTokenId,
+                tokenType: SLP_TOKEN_TYPE_NFT1_CHILD,
+                atoms: 1n,
+                isMintBaton: false,
+            },
+            status: 'OPEN',
+        });
+
+        const [offerMsg] = await offerPromise;
+        expect(offerMsg.type).to.equal('Tx');
+        expect(offerMsg.msgType).to.equal('TX_ADDED_TO_MEMPOOL');
+        expect(offerMsg.txid).to.equal(offerTxid);
+
+        // 5. Buyer searches for NFT trades, finds the advertised one
+        expect(await agora.allOfferedTokenIds()).to.deep.equal([childTokenId]);
+
+        // Query by group token ID
+        expect(
+            await agora.activeOffersByGroupTokenId(groupTokenId),
+        ).to.deep.equal([expectedOffer]);
+
+        // Query by child token ID
+        expect(await agora.activeOffersByTokenId(childTokenId)).to.deep.equal([
+            expectedOffer,
+        ]);
+
+        // Query by cancelPk
+        expect(
+            await agora.activeOffersByPubKey(toHex(cancelerPk)),
+        ).to.deep.equal([expectedOffer]);
+
+        // We can cancel the offer using cancel()
+        // We need a utxo to spend to cancel this offer
+        await runner.sendToScript(50000n, cancelerP2pkh);
+        await cancelerWallet.sync();
+        await expectedOffer.cancel({
+            wallet: cancelerWallet,
+        });
+
+        // We can no longer find the offer
+        expect(await agora.allOfferedTokenIds()).to.deep.equal([]);
+        expect(await agora.offeredGroupTokenIds()).to.deep.equal([]);
+        expect(await agora.offeredFungibleTokenIds()).to.deep.equal([]);
+        expect(
+            await agora.activeOffersByGroupTokenId(groupTokenId),
+        ).to.deep.equal([]);
+        expect(await agora.activeOffersByTokenId(childTokenId)).to.deep.equal(
+            [],
+        );
+        expect(
+            await agora.activeOffersByPubKey(toHex(cancelerPk)),
+        ).to.deep.equal([]);
+    });
 });

package/tests/partial-helper-alp.ts

@@ -16,6 +16,7 @@ import {
     TxBuilderInput,
     TxBuilderOutput,
 } from 'ecash-lib';
+import { Wallet } from 'ecash-wallet';
 import { expect } from 'chai';
 
 import { AgoraPartial } from '../src/partial.js';
@@ -124,22 +125,23 @@ export async function takeAlpOffer(params: {
     chronik: ChronikClient;
     offer: AgoraOffer;
     takerSk: Uint8Array;
-    takerInput: TxBuilderInput;
     acceptedAtoms: bigint;
     allowUnspendable?: boolean;
 }) {
     const takerSk = params.takerSk;
-    const takerPk = new Ecc().derivePubkey(takerSk);
-    const takerPkh = shaRmd160(takerPk);
-    const takerP2pkh = Script.p2pkh(takerPkh);
-    const acceptTx = params.offer.acceptTx({
-        covenantSk: params.takerSk,
+    const takerWallet = Wallet.fromSk(takerSk, params.chronik);
+    const takerPk = takerWallet.pk;
+    const takerP2pkh = takerWallet.script;
+
+    await takerWallet.sync();
+    const broadcastResult = await params.offer.take({
+        wallet: takerWallet,
+        covenantSk: takerSk,
         covenantPk: takerPk,
-        fuelInputs: [params.takerInput],
         recipientScript: takerP2pkh,
         acceptedAtoms: params.acceptedAtoms,
         allowUnspendable: params.allowUnspendable,
     });
-    const acceptTxid = (await params.chronik.broadcastTx(acceptTx.ser())).txid;
+    const acceptTxid = broadcastResult.broadcasted[0];
     return acceptTxid;
 }

package/tests/partial-helper-slp.ts

@@ -14,6 +14,7 @@ import {
     TxBuilder,
     TxBuilderInput,
 } from 'ecash-lib';
+import { Wallet } from 'ecash-wallet';
 import { expect } from 'chai';
 
 import { AgoraPartial, AgoraPartialAdSignatory } from '../src/partial.js';
@@ -132,22 +133,22 @@ export async function takeSlpOffer(params: {
     chronik: ChronikClient;
     offer: AgoraOffer;
     takerSk: Uint8Array;
-    takerInput: TxBuilderInput;
     acceptedAtoms: bigint;
     allowUnspendable?: boolean;
 }) {
     const takerSk = params.takerSk;
-    const takerPk = new Ecc().derivePubkey(takerSk);
-    const takerPkh = shaRmd160(takerPk);
-    const takerP2pkh = Script.p2pkh(takerPkh);
-    const acceptTx = params.offer.acceptTx({
-        covenantSk: params.takerSk,
+    const takerWallet = Wallet.fromSk(takerSk, params.chronik);
+    const takerPk = takerWallet.pk;
+    const takerP2pkh = takerWallet.script;
+    await takerWallet.sync();
+    const broadcastResult = await params.offer.take({
+        wallet: takerWallet,
+        covenantSk: takerSk,
         covenantPk: takerPk,
-        fuelInputs: [params.takerInput],
         recipientScript: takerP2pkh,
         acceptedAtoms: params.acceptedAtoms,
         allowUnspendable: params.allowUnspendable,
     });
-    const acceptTxid = (await params.chronik.broadcastTx(acceptTx.ser())).txid;
+    const acceptTxid = broadcastResult.broadcasted[0];
     return acceptTxid;
 }

package/tests/partial.alp.bigsats.test.ts

@@ -53,7 +53,10 @@ async function makeBuilderInputs(
     runner: TestRunner,
     values: bigint[],
 ): Promise<TxBuilderInput[]> {
-    const txid = await runner.sendToScript(values, makerScript);
+    const txid = await runner.sendToTwoScripts(
+        { script: makerScript, sats: values[0] },
+        { script: takerScript, sats: values[1] },
+    );
     return values.map((sats, outIdx) => ({
         input: {
             prevOut: {
@@ -84,10 +87,7 @@ describe('AgoraPartial ALP 7450M XEC vs 2p48-1 full accept', () => {
     });
 
     it('AgoraPartial ALP 7450M XEC vs 2p48-1 full accept', async () => {
-        const [fuelInput, takerInput] = await makeBuilderInputs(runner, [
-            10000n,
-            BIGSATS,
-        ]);
+        const [fuelInput] = await makeBuilderInputs(runner, [10000n, BIGSATS]);
 
         const agora = new Agora(chronik);
         const agoraPartial = await agora.selectParams({
@@ -133,7 +133,6 @@ describe('AgoraPartial ALP 7450M XEC vs 2p48-1 full accept', () => {
             chronik,
             offer,
             takerSk,
-            takerInput,
             acceptedAtoms: agoraPartial.offeredAtoms(),
         });
 
@@ -178,10 +177,7 @@ describe('AgoraPartial 7450M XEC vs 2p48-1 small accept', () => {
     });
 
     it('AgoraPartial ALP 7450M XEC vs 2p48-1 small accept', async () => {
-        const [fuelInput, takerInput] = await makeBuilderInputs(runner, [
-            10000n,
-            BIGSATS,
-        ]);
+        const [fuelInput] = await makeBuilderInputs(runner, [10000n, BIGSATS]);
 
         const agora = new Agora(chronik);
         const agoraPartial = await agora.selectParams({
@@ -229,7 +225,6 @@ describe('AgoraPartial 7450M XEC vs 2p48-1 small accept', () => {
             chronik,
             offer,
             takerSk,
-            takerInput,
             acceptedAtoms,
         });
 
@@ -282,10 +277,7 @@ describe('AgoraPartial 7450M XEC vs 2p47-1 full accept', () => {
     });
 
     it('AgoraPartial ALP 7450M XEC vs 2p47-1 full accept', async () => {
-        const [fuelInput, takerInput] = await makeBuilderInputs(runner, [
-            10000n,
-            BIGSATS,
-        ]);
+        const [fuelInput] = await makeBuilderInputs(runner, [10000n, BIGSATS]);
 
         const agora = new Agora(chronik);
         const agoraPartial = await agora.selectParams({
@@ -330,7 +322,6 @@ describe('AgoraPartial 7450M XEC vs 2p47-1 full accept', () => {
             chronik,
             offer,
             takerSk,
-            takerInput,
             acceptedAtoms: agoraPartial.offeredAtoms(),
         });
 
@@ -378,10 +369,7 @@ describe('AgoraPartial ALP 7450M XEC vs 2p47-1 small accept', () => {
     });
 
     it('AgoraPartial ALP 7450M XEC vs 2p47-1 small accept', async () => {
-        const [fuelInput, takerInput] = await makeBuilderInputs(runner, [
-            10000n,
-            BIGSATS,
-        ]);
+        const [fuelInput] = await makeBuilderInputs(runner, [10000n, BIGSATS]);
 
         const agora = new Agora(chronik);
         const agoraPartial = await agora.selectParams({
@@ -429,7 +417,6 @@ describe('AgoraPartial ALP 7450M XEC vs 2p47-1 small accept', () => {
             chronik,
             offer,
             takerSk,
-            takerInput,
             acceptedAtoms,
         });
 
@@ -482,10 +469,7 @@ describe('AgoraPartial ALP 7450M XEC vs 100 full accept', () => {
     });
 
     it('AgoraPartial ALP 7450M XEC vs 100 full accept', async () => {
-        const [fuelInput, takerInput] = await makeBuilderInputs(runner, [
-            10000n,
-            BIGSATS,
-        ]);
+        const [fuelInput] = await makeBuilderInputs(runner, [10000n, BIGSATS]);
 
         const agora = new Agora(chronik);
         const agoraPartial = await agora.selectParams({
@@ -529,7 +513,6 @@ describe('AgoraPartial ALP 7450M XEC vs 100 full accept', () => {
             chronik,
             offer,
             takerSk,
-            takerInput,
             acceptedAtoms: 100n,
         });
         const acceptTx = await chronik.tx(acceptTxid);
@@ -574,10 +557,7 @@ describe('AgoraPartial ALP 7450M XEC vs 100 small accept', () => {
     });
 
     it('AgoraPartial ALP 7450M XEC vs 100 small accept', async () => {
-        const [fuelInput, takerInput] = await makeBuilderInputs(runner, [
-            10000n,
-            BIGSATS,
-        ]);
+        const [fuelInput] = await makeBuilderInputs(runner, [10000n, BIGSATS]);
 
         const agora = new Agora(chronik);
         const agoraPartial = await agora.selectParams({
@@ -617,7 +597,6 @@ describe('AgoraPartial ALP 7450M XEC vs 100 small accept', () => {
             chronik,
             offer,
             takerSk,
-            takerInput,
             acceptedAtoms: 1n,
         });
         const acceptTx = await chronik.tx(acceptTxid);

package/tests/partial.alp.test.ts

@@ -24,6 +24,7 @@ import { TestRunner } from 'ecash-lib/dist/test/testRunner.js';
 import { AgoraPartial } from '../src/partial.js';
 import { makeAlpOffer, takeAlpOffer } from './partial-helper-alp.js';
 import { Agora, TakenInfo } from '../src/agora.js';
+import { Wallet } from 'ecash-wallet/src/wallet.js';
 
 use(chaiAsPromised);
 
@@ -57,7 +58,10 @@ describe('AgoraPartial ALP', () => {
     async function makeBuilderInputs(
         values: bigint[],
     ): Promise<TxBuilderInput[]> {
+        // NB for these "not big sats" tests, we can just send to both, no need to sendToTwoScripts
         const txid = await runner.sendToScript(values, makerScript);
+        // Send some cash to the taker, since the accept() tests spend from this wallet
+        await runner.sendToScript(values, takerScript);
         return values.map((sats, outIdx) => ({
             input: {
                 prevOut: {
@@ -417,6 +421,7 @@ describe('AgoraPartial ALP', () => {
         },
     ];
 
+    let cancelTxsMatchCount = 0;
     for (const testCase of TEST_CASES) {
         it(`AgoraPartial ALP ${testCase.offeredAtoms} for ${testCase.info}`, async () => {
             const agora = new Agora(chronik);
@@ -429,10 +434,7 @@ describe('AgoraPartial ALP', () => {
             });
             const askedSats = agoraPartial.askedSats(testCase.acceptedAtoms);
             const requiredSats = askedSats + 2000n;
-            const [fuelInput, takerInput] = await makeBuilderInputs([
-                4000n,
-                requiredSats,
-            ]);
+            const [fuelInput] = await makeBuilderInputs([4000n, requiredSats]);
 
             const offer = await makeAlpOffer({
                 chronik,
@@ -444,12 +446,10 @@ describe('AgoraPartial ALP', () => {
                 chronik,
                 takerSk,
                 offer,
-                takerInput,
                 acceptedAtoms: testCase.acceptedAtoms,
                 allowUnspendable: testCase.allowUnspendable,
             });
             const acceptTx = await chronik.tx(acceptTxid);
-            // TODO we do not even get here, keep debugging
             const offeredAtoms = agoraPartial.offeredAtoms();
             const isFullAccept = testCase.acceptedAtoms == offeredAtoms;
             if (isFullAccept) {
@@ -543,17 +543,40 @@ describe('AgoraPartial ALP', () => {
                 recipientScript: makerScript,
                 extraInputs: [fuelInput], // dummy input for measuring
             });
-            const cancelTxSer = newOffer
-                .cancelTx({
-                    cancelSk: makerSk,
-                    fuelInputs: await makeBuilderInputs([cancelFeeSats]),
-                    recipientScript: makerScript,
-                })
-                .ser();
-            const cancelTxid = (await chronik.broadcastTx(cancelTxSer)).txid;
-            const cancelTx = await chronik.tx(cancelTxid);
-            expect(cancelTx.outputs[1].token?.atoms).to.equal(leftoverTokens);
-            expect(cancelTx.outputs[1].outputScript).to.equal(makerScriptHex);
+            const cancelTx = newOffer.cancelTx({
+                cancelSk: makerSk,
+                fuelInputs: await makeBuilderInputs([cancelFeeSats]),
+                recipientScript: makerScript,
+            });
+            const cancelTxid = cancelTx.txid();
+
+            // Let's build and broadcast using cancel() instead
+            const cancelWallet = Wallet.fromSk(makerSk, chronik);
+            await cancelWallet.sync();
+            const cancelResult = await newOffer.cancel({
+                wallet: cancelWallet,
+            });
+            const broadcastCancelTxid = cancelResult.broadcasted[0];
+            if (broadcastCancelTxid === cancelTxid) {
+                cancelTxsMatchCount++;
+                console.log(
+                    `${cancelTxsMatchCount} of ${TEST_CASES.length} produce equal txids with cancelTx() and cancel()`,
+                );
+
+                // Between ~5 and ~8 of 46 of these txs are identical from each method
+
+                // On inspection, when cancel() txid does not match,
+                // it is because cancel has selected different fuel inputs
+                // This is expected behavior, these txs still show change
+                // going to the cancel wallet as expected
+            }
+            const cancelChronikTx = await chronik.tx(broadcastCancelTxid);
+            expect(cancelChronikTx.outputs[1].token?.atoms).to.equal(
+                leftoverTokens,
+            );
+            expect(cancelChronikTx.outputs[1].outputScript).to.equal(
+                makerScriptHex,
+            );
 
             // takerIndex is 2 for full accept, 3 for partial accept
             const takerIndex = isFullAccept ? 2 : 3;
@@ -611,10 +634,7 @@ describe('AgoraPartial ALP', () => {
         });
         const askedSats = agoraPartial.askedSats(thisTestCase.acceptedAtoms);
         const requiredSats = askedSats + 2000n;
-        const [fuelInput, takerInput] = await makeBuilderInputs([
-            4000n,
-            requiredSats,
-        ]);
+        const [fuelInput] = await makeBuilderInputs([4000n, requiredSats]);
 
         const offer = await makeAlpOffer({
             chronik,
@@ -639,7 +659,6 @@ describe('AgoraPartial ALP', () => {
                 chronik,
                 takerSk,
                 offer,
-                takerInput,
                 acceptedAtoms: thisTestCase.acceptedAtoms,
                 allowUnspendable: false,
             }),
@@ -678,10 +697,7 @@ describe('AgoraPartial ALP', () => {
         const acceptedAtoms = 500n;
         const askedSats = agoraPartial.askedSats(acceptedAtoms);
         const requiredSats = askedSats + 2000n;
-        const [fuelInput, takerInput] = await makeBuilderInputs([
-            4000n,
-            requiredSats,
-        ]);
+        const [fuelInput] = await makeBuilderInputs([4000n, requiredSats]);
 
         const offer = await makeAlpOffer({
             chronik,
@@ -703,7 +719,6 @@ describe('AgoraPartial ALP', () => {
                 chronik,
                 takerSk,
                 offer,
-                takerInput,
                 acceptedAtoms: acceptedAtoms,
                 allowUnspendable: false,
             }),