@bsv/wallet-toolbox 1.1.62 → 1.2.2

package/out/src/__tests/WalletPermissionsManager.fixtures.js

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * A permissions manager testing mock/stub file for:
+ *  1) The `@bsv/sdk` library: Transaction, LockingScript, PushDrop, Utils, Random, etc.
+ *  2) A BRC-100 `WalletInterface` (the underlying wallet).
+ *
+ * This file bypasses real validation/logic in `@bsv/sdk`, returning placeholders and
+ * stubs to prevent test-time errors such as "Invalid Atomic BEEF prefix."
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockedBSV_SDK = exports.MockRandom = exports.MockUtils = exports.MockPushDrop = exports.MockLockingScript = exports.MockTransaction = void 0;
+exports.mockUnderlyingWallet = mockUnderlyingWallet;
+/* ---------------------------------------------------------------------------
+ * 1) Partial Mocks for @bsv/sdk
+ * -------------------------------------------------------------------------*/
+/**
+ * A minimal mock for `Transaction` that won't throw "Invalid Atomic BEEF prefix."
+ * We override the static methods so they do not do real parsing/validation.
+ */
+class MockTransaction {
+    constructor() {
+        this.inputs = [{}];
+        this.outputs = [];
+        this.fee = 0;
+    }
+    static fromAtomicBEEF() {
+        // Mocked below
+    }
+    static fromBEEF(beef) {
+        // Same approach as above
+        return new MockTransaction();
+    }
+    getFee() {
+        return this.fee;
+    }
+}
+exports.MockTransaction = MockTransaction;
+;
+MockTransaction.fromAtomicBEEF = jest.fn(() => {
+    // We skip real validation, returning a MockTransaction with minimal structure.
+    const tx = new MockTransaction();
+    return tx;
+});
+/**
+ * Mocks for `LockingScript`. If your code calls e.g. LockingScript.fromHex, we can just
+ * store the hex and do nothing else.
+ */
+class MockLockingScript {
+    constructor(hex) {
+        this.hex = hex;
+    }
+    toHex() {
+        return this.hex;
+    }
+    static fromHex(hex) {
+        return new MockLockingScript(hex);
+    }
+}
+exports.MockLockingScript = MockLockingScript;
+/**
+ * We stub out all methods: `decode()`, `lock()`, `unlock()`.
+ */
+class MockPushDrop {
+    // Typically we might store the wallet reference, but we can skip for now.
+    constructor() {
+        //
+    }
+    // Decodes a LockingScript into some {fields: number[][], protocol...} or undefined
+    static decode(script) {
+        // If you rely on a real format, parse or store a pattern.
+        // For now, returning a minimal stub: empty fields
+        if (!script || !script.hex)
+            return undefined;
+        if (script.hex.includes('some script')) {
+            // When needed, return some fields
+            return {
+                fields: [
+                    [],
+                    [],
+                    [],
+                    [],
+                    [],
+                    [],
+                    [] // 7 fields should always be enough...
+                ]
+            };
+        }
+        // Just pretend we always decode to a single empty field array
+        return { fields: [] };
+    }
+    lock(fields, protocolID, keyID, counterparty, singleSignature, anyoneCanPay) {
+        return new MockLockingScript('deadbeef');
+    }
+    unlock(protocolID, keyID, counterparty, sighashType, enforceReplayProtection, sigSize, lockingScript) {
+        // In real usage, it would handle signature logic. We'll return a minimal stub.
+        return {
+            sign: async (tx, vin) => {
+                // produce a minimal unlocking script
+                return new MockLockingScript('mockUnlockingScript');
+            }
+        };
+    }
+}
+exports.MockPushDrop = MockPushDrop;
+/**
+ * Mocks for Utils, e.g. toHex, toUTF8, fromUTF8, etc.
+ * We can provide minimal stubs that won't break your code.
+ */
+exports.MockUtils = {
+    toHex: (data) => {
+        // Converts an array of numbers to a hexadecimal string.
+        return data.map(num => num.toString(16).padStart(2, '0')).join('');
+    },
+    toArray: (str, encoding = 'utf8') => {
+        // Converts a string to an array of numbers based on the encoding.
+        if (encoding === 'hex') {
+            const arr = [];
+            for (let i = 0; i < str.length; i += 2) {
+                arr.push(parseInt(str.substr(i, 2), 16));
+            }
+            return arr;
+        }
+        else if (encoding === 'base64') {
+            const binaryStr = atob(str);
+            return Array.from(binaryStr, char => char.charCodeAt(0));
+        }
+        else if (encoding === 'utf8') {
+            return Array.from(str, char => char.charCodeAt(0));
+        }
+        else {
+            throw new Error('Unsupported encoding: ' + encoding);
+        }
+    },
+    toUTF8: (arr) => {
+        // Converts an array of numbers to a UTF-8 string.
+        return String.fromCharCode(...arr);
+    }
+};
+/**
+ * Mocks for Random
+ */
+const MockRandom = (size) => {
+    return [...require('crypto').randomBytes(size)];
+};
+exports.MockRandom = MockRandom;
+/**
+ * Overriding the real classes with our mocks.
+ */
+exports.MockedBSV_SDK = {
+    Transaction: MockTransaction,
+    LockingScript: MockLockingScript,
+    PushDrop: MockPushDrop,
+    Utils: exports.MockUtils,
+    Random: exports.MockRandom,
+    Certificate: null
+};
+/* ---------------------------------------------------------------------------
+ * 2) A full mock for the BRC-100 WalletInterface
+ * -------------------------------------------------------------------------*/
+/**
+ * A helper function returning a Jest-mocked `WalletInterface`.
+ * This ensures all required methods exist and return plausible values.
+ *
+ * - By default, `createAction` returns a signableTransaction with empty arrays,
+ *   so that the manager can call `Transaction.fromAtomicBEEF([])` without throwing.
+ * - You can override or chain .mockResolvedValueOnce(...) inside individual tests
+ *   if you want more specific behavior in certain test steps.
+ */
+function mockUnderlyingWallet() {
+    return {
+        getPublicKey: jest.fn().mockResolvedValue({ publicKey: '029999...' }),
+        revealCounterpartyKeyLinkage: jest.fn().mockResolvedValue({
+            encryptedLinkage: [1, 2, 3],
+            encryptedLinkageProof: [4, 5, 6],
+            prover: '02abcdef...',
+            verifier: '02cccccc...',
+            counterparty: '02bbbbbb...',
+            revelationTime: new Date().toISOString()
+        }),
+        revealSpecificKeyLinkage: jest.fn().mockResolvedValue({
+            encryptedLinkage: [1, 2, 3],
+            encryptedLinkageProof: [4, 5, 6],
+            prover: '02abcdef...',
+            verifier: '02cccccc...',
+            counterparty: '02bbbbbb...',
+            protocolID: [1, 'test-protocol'],
+            keyID: 'testKey',
+            proofType: 1
+        }),
+        encrypt: jest.fn().mockResolvedValue({ ciphertext: [42, 42, 42, 42, 42, 42, 42] }),
+        decrypt: jest.fn().mockResolvedValue({ plaintext: [42, 42, 42, 42, 42] }),
+        createHmac: jest.fn().mockResolvedValue({ hmac: [0xaa] }),
+        verifyHmac: jest.fn().mockResolvedValue({ valid: true }),
+        createSignature: jest.fn().mockResolvedValue({ signature: [0x30, 0x44] }),
+        verifySignature: jest.fn().mockResolvedValue({ valid: true }),
+        createAction: jest.fn(async (x) => {
+            if (x.options && x.options.signAndProcess === true) {
+                return {
+                    tx: []
+                };
+            }
+            return {
+                signableTransaction: {
+                    tx: [],
+                    reference: 'mockReference'
+                }
+            };
+        }),
+        signAction: jest.fn().mockResolvedValue({
+            txid: 'fake-txid',
+            tx: []
+        }),
+        abortAction: jest.fn().mockResolvedValue({ aborted: true }),
+        listActions: jest.fn().mockResolvedValue({
+            totalActions: 0,
+            actions: []
+        }),
+        internalizeAction: jest.fn().mockResolvedValue({ accepted: true }),
+        listOutputs: jest.fn().mockResolvedValue({
+            totalOutputs: 0,
+            outputs: []
+        }),
+        relinquishOutput: jest.fn().mockResolvedValue({ relinquished: true }),
+        acquireCertificate: jest.fn().mockResolvedValue({
+            type: 'some-cert-type',
+            subject: '02aaaaaaaaaa...',
+            serialNumber: 'serial123',
+            certifier: '02ccccccccccc...',
+            revocationOutpoint: 'some.txid.1',
+            signature: 'deadbeef',
+            fields: { name: 'Alice', dob: '1990-01-01' }
+        }),
+        listCertificates: jest.fn().mockResolvedValue({
+            totalCertificates: 0,
+            certificates: []
+        }),
+        proveCertificate: jest.fn().mockResolvedValue({
+            keyringForVerifier: {},
+            certificate: undefined,
+            verifier: undefined
+        }),
+        relinquishCertificate: jest.fn().mockResolvedValue({ relinquished: true }),
+        discoverByIdentityKey: jest.fn().mockResolvedValue({
+            totalCertificates: 0,
+            certificates: []
+        }),
+        discoverByAttributes: jest.fn().mockResolvedValue({
+            totalCertificates: 0,
+            certificates: []
+        }),
+        isAuthenticated: jest.fn().mockResolvedValue({ authenticated: true }),
+        waitForAuthentication: jest.fn().mockResolvedValue({ authenticated: true }),
+        getHeight: jest.fn().mockResolvedValue({ height: 777777 }),
+        getHeaderForHeight: jest.fn().mockResolvedValue({
+            header: '000000000000abc...'
+        }),
+        getNetwork: jest.fn().mockResolvedValue({ network: 'testnet' }),
+        getVersion: jest.fn().mockResolvedValue({ version: 'vendor-1.0.0' })
+    };
+}
+//# sourceMappingURL=WalletPermissionsManager.fixtures.js.map

package/out/src/__tests/WalletPermissionsManager.fixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WalletPermissionsManager.fixtures.js","sourceRoot":"","sources":["../../../src/__tests/WalletPermissionsManager.fixtures.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAuLH,oDA6FC;AAlRD;;8EAE8E;AAE9E;;;GAGG;AACH,MAAa,eAAe;IAK1B;QAJO,WAAM,GAAU,CAAC,EAAE,CAAC,CAAA;QACpB,YAAO,GAAU,EAAE,CAAA;QACnB,QAAG,GAAW,CAAC,CAAA;IAEP,CAAC;IAChB,MAAM,CAAC,cAAc;QACnB,eAAe;IACjB,CAAC;IAED,MAAM,CAAC,QAAQ,CAAC,IAAc;QAC5B,yBAAyB;QACzB,OAAO,IAAI,eAAe,EAAE,CAAA;IAC9B,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,GAAG,CAAA;IACjB,CAAC;CACF;AAlBD,0CAkBC;AAED,CAAC;AAAC,eAAuB,CAAC,cAAc,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE;IACtD,+EAA+E;IAC/E,MAAM,EAAE,GAAG,IAAI,eAAe,EAAE,CAAA;IAChC,OAAO,EAAE,CAAA;AACX,CAAC,CAAC,CAAA;AAEF;;;GAGG;AACH,MAAa,iBAAiB;IAE5B,YAAY,GAAW;QACrB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;IAChB,CAAC;IACM,KAAK;QACV,OAAO,IAAI,CAAC,GAAG,CAAA;IACjB,CAAC;IACD,MAAM,CAAC,OAAO,CAAC,GAAW;QACxB,OAAO,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAA;IACnC,CAAC;CACF;AAXD,8CAWC;AAED;;GAEG;AACH,MAAa,YAAY;IACvB,0EAA0E;IAC1E;QACE,EAAE;IACJ,CAAC;IAED,mFAAmF;IACnF,MAAM,CAAC,MAAM,CAAC,MAAyB;QACrC,0DAA0D;QAC1D,kDAAkD;QAClD,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG;YAAE,OAAO,SAAS,CAAA;QAC5C,IAAI,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;YACvC,kCAAkC;YAClC,OAAO;gBACL,MAAM,EAAE;oBACN,EAAE;oBACF,EAAE;oBACF,EAAE;oBACF,EAAE;oBACF,EAAE;oBACF,EAAE;oBACF,EAAE,CAAC,sCAAsC;iBAC1C;aACF,CAAA;QACH,CAAC;QACD,8DAA8D;QAC9D,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,CAAA;IACvB,CAAC;IAED,IAAI,CACF,MAAkB,EAClB,UAA4B,EAC5B,KAAa,EACb,YAAoB,EACpB,eAAwB,EACxB,YAAqB;QAErB,OAAO,IAAI,iBAAiB,CAAC,UAAU,CAAC,CAAA;IAC1C,CAAC;IAED,MAAM,CACJ,UAA4B,EAC5B,KAAa,EACb,YAAoB,EACpB,WAAmB,EACnB,uBAAgC,EAChC,OAAe,EACf,aAAgC;QAIhC,+EAA+E;QAC/E,OAAO;YACL,IAAI,EAAE,KAAK,EAAE,EAAmB,EAAE,GAAW,EAAE,EAAE;gBAC/C,qCAAqC;gBACrC,OAAO,IAAI,iBAAiB,CAAC,qBAAqB,CAAC,CAAA;YACrD,CAAC;SACF,CAAA;IACH,CAAC;CACF;AA3DD,oCA2DC;AAED;;;GAGG;AACU,QAAA,SAAS,GAAG;IACvB,KAAK,EAAE,CAAC,IAAc,EAAE,EAAE;QACxB,wDAAwD;QACxD,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IACpE,CAAC;IAED,OAAO,EAAE,CAAC,GAAW,EAAE,QAAQ,GAAG,MAAM,EAAE,EAAE;QAC1C,kEAAkE;QAClE,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;YACvB,MAAM,GAAG,GAAa,EAAE,CAAA;YACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;YAC1C,CAAC;YACD,OAAO,GAAG,CAAA;QACZ,CAAC;aAAM,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;YACjC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;YAC3B,OAAO,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;QAC1D,CAAC;aAAM,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;YAC/B,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;QACpD,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,wBAAwB,GAAG,QAAQ,CAAC,CAAA;QACtD,CAAC;IACH,CAAC;IAED,MAAM,EAAE,CAAC,GAAa,EAAE,EAAE;QACxB,kDAAkD;QAClD,OAAO,MAAM,CAAC,YAAY,CAAC,GAAG,GAAG,CAAC,CAAA;IACpC,CAAC;CACF,CAAA;AAED;;GAEG;AACI,MAAM,UAAU,GAAG,CAAC,IAAY,EAAY,EAAE;IACnD,OAAO,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;AACjD,CAAC,CAAA;AAFY,QAAA,UAAU,cAEtB;AAED;;GAEG;AACU,QAAA,aAAa,GAAG;IAC3B,WAAW,EAAE,eAAe;IAC5B,aAAa,EAAE,iBAAiB;IAChC,QAAQ,EAAE,YAAY;IACtB,KAAK,EAAE,iBAAS;IAChB,MAAM,EAAE,kBAAU;IAClB,WAAW,EAAE,IAAI;CAClB,CAAA;AAED;;8EAE8E;AAE9E;;;;;;;;GAQG;AACH,SAAgB,oBAAoB;IAClC,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC;QACrE,4BAA4B,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YACxD,gBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAC3B,qBAAqB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAChC,MAAM,EAAE,aAAa;YACrB,QAAQ,EAAE,aAAa;YACvB,YAAY,EAAE,aAAa;YAC3B,cAAc,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACzC,CAAC;QACF,wBAAwB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YACpD,gBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAC3B,qBAAqB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAChC,MAAM,EAAE,aAAa;YACrB,QAAQ,EAAE,aAAa;YACvB,YAAY,EAAE,aAAa;YAC3B,UAAU,EAAE,CAAC,CAAC,EAAE,eAAe,CAAC;YAChC,KAAK,EAAE,SAAS;YAChB,SAAS,EAAE,CAAC;SACb,CAAC;QACF,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;QAClF,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;QACzE,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACzD,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACxD,eAAe,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;QACzE,eAAe,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAE7D,YAAY,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAC,CAAC,EAAC,EAAE;YAC9B,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,cAAc,KAAK,IAAI,EAAE,CAAC;gBACnD,OAAO;oBACL,EAAE,EAAE,EAAE;iBACP,CAAA;YACH,CAAC;YACD,OAAO;gBACL,mBAAmB,EAAE;oBACnB,EAAE,EAAE,EAAE;oBACN,SAAS,EAAE,eAAe;iBAC3B;aACF,CAAA;QACH,CAAC,CAAC;QACF,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YACtC,IAAI,EAAE,WAAW;YACjB,EAAE,EAAE,EAAE;SACP,CAAC;QACF,WAAW,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC3D,WAAW,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YACvC,YAAY,EAAE,CAAC;YACf,OAAO,EAAE,EAAE;SACZ,CAAC;QACF,iBAAiB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;QAClE,WAAW,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YACvC,YAAY,EAAE,CAAC;YACf,OAAO,EAAE,EAAE;SACZ,CAAC;QACF,gBAAgB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;QAErE,kBAAkB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YAC9C,IAAI,EAAE,gBAAgB;YACtB,OAAO,EAAE,iBAAiB;YAC1B,YAAY,EAAE,WAAW;YACzB,SAAS,EAAE,kBAAkB;YAC7B,kBAAkB,EAAE,aAAa;YACjC,SAAS,EAAE,UAAU;YACrB,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE;SAC7C,CAAC;QACF,gBAAgB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YAC5C,iBAAiB,EAAE,CAAC;YACpB,YAAY,EAAE,EAAE;SACjB,CAAC;QACF,gBAAgB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YAC5C,kBAAkB,EAAE,EAAE;YACtB,WAAW,EAAE,SAAS;YACtB,QAAQ,EAAE,SAAS;SACpB,CAAC;QACF,qBAAqB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;QAC1E,qBAAqB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YACjD,iBAAiB,EAAE,CAAC;YACpB,YAAY,EAAE,EAAE;SACjB,CAAC;QACF,oBAAoB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YAChD,iBAAiB,EAAE,CAAC;YACpB,YAAY,EAAE,EAAE;SACjB,CAAC;QACF,eAAe,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;QACrE,qBAAqB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;QAC3E,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAC1D,kBAAkB,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC;YAC9C,MAAM,EAAE,oBAAoB;SAC7B,CAAC;QACF,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;QAC/D,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;KACrE,CAAA;AACH,CAAC"}

package/out/src/__tests/WalletPermissionsManager.flows.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=WalletPermissionsManager.flows.test.d.ts.map

package/out/src/__tests/WalletPermissionsManager.flows.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WalletPermissionsManager.flows.test.d.ts","sourceRoot":"","sources":["../../../src/__tests/WalletPermissionsManager.flows.test.ts"],"names":[],"mappings":""}

package/out/src/__tests/WalletPermissionsManager.flows.test.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WalletPermissionsManager_fixtures_1 = require("./WalletPermissionsManager.fixtures");
+const WalletPermissionsManager_1 = require("../WalletPermissionsManager");
+const globals_1 = require("@jest/globals");
+// We mock the underlying @bsv/sdk references with our test fixtures:
+globals_1.jest.mock('@bsv/sdk', () => WalletPermissionsManager_fixtures_1.MockedBSV_SDK);
+/**
+ * A lightweight helper that forces the manager to never find any on-chain token.
+ * We do this so we can reliably test the request flow (i.e., that it truly initiates
+ * a new permission request if no token is found).
+ */
+function mockNoTokensFound(manager) {
+    globals_1.jest.spyOn(manager, 'findProtocolToken').mockResolvedValue(undefined);
+    globals_1.jest.spyOn(manager, 'findBasketToken').mockResolvedValue(undefined);
+    globals_1.jest.spyOn(manager, 'findCertificateToken').mockResolvedValue(undefined);
+    globals_1.jest.spyOn(manager, 'findSpendingToken').mockResolvedValue(undefined);
+}
+describe('WalletPermissionsManager - Permission Request Flow & Active Requests', () => {
+    let underlying;
+    let manager;
+    beforeEach(() => {
+        underlying = (0, WalletPermissionsManager_fixtures_1.mockUnderlyingWallet)();
+        manager = new WalletPermissionsManager_1.WalletPermissionsManager(underlying, 'admin.test.com');
+    });
+    afterEach(() => {
+        globals_1.jest.clearAllMocks();
+    });
+    /**
+     * UNIT TESTS
+     */
+    describe('Unit Tests: requestPermissionFlow & activeRequests map', () => {
+        it('should coalesce parallel requests for the same resource into a single user prompt', async () => {
+            // We want to test the underlying private method "requestPermissionFlow" indirectly
+            // or we can test it via a public method that calls it. We'll do so via ensureProtocolPermission.
+            // Force no token found => triggers a request flow
+            mockNoTokensFound(manager);
+            // Spy on the manager's "onProtocolPermissionRequested" callbacks
+            const requestCallback = globals_1.jest.fn(() => { });
+            manager.bindCallback('onProtocolPermissionRequested', requestCallback);
+            // Make two parallel calls for the same resource
+            const callA = manager.ensureProtocolPermission({
+                originator: 'example.com',
+                privileged: false,
+                protocolID: [1, 'someproto'],
+                counterparty: 'self',
+                reason: 'UnitTest - same resource A',
+                seekPermission: true,
+                usageType: 'signing'
+            });
+            const callB = manager.ensureProtocolPermission({
+                originator: 'example.com',
+                privileged: false,
+                protocolID: [1, 'someproto'],
+                counterparty: 'self',
+                reason: 'UnitTest - same resource B',
+                seekPermission: true,
+                usageType: 'signing'
+            });
+            // Wait a short moment for the async request flow to trigger
+            await new Promise(res => setTimeout(res, 5));
+            // We expect only one "onProtocolPermissionRequested" event for both calls
+            expect(requestCallback).toHaveBeenCalledTimes(1);
+            // Now let's deny the request:
+            // Grab the requestID that the manager gave us from the callback param
+            const callbackArg = requestCallback.mock.calls[0][0];
+            const requestID = callbackArg.requestID;
+            expect(typeof requestID).toBe('string'); // manager-generated
+            // Deny the request
+            await manager.denyPermission(requestID);
+            // Both calls should reject
+            await expect(callA).rejects.toThrow(/Permission denied/);
+            await expect(callB).rejects.toThrow(/Permission denied/);
+            // Confirm activeRequests map is empty after denial
+            const activeRequests = manager.activeRequests;
+            expect(activeRequests.size).toBe(0);
+        });
+        it('should generate two distinct user prompts for two different permission requests', async () => {
+            // Force no tokens
+            mockNoTokensFound(manager);
+            // Spy on basket & protocol request callbacks
+            const protocolRequestCb = globals_1.jest.fn(() => { });
+            const basketRequestCb = globals_1.jest.fn(() => { });
+            manager.bindCallback('onProtocolPermissionRequested', protocolRequestCb);
+            manager.bindCallback('onBasketAccessRequested', basketRequestCb);
+            // Make one call for protocol usage
+            const pCall = manager.ensureProtocolPermission({
+                originator: 'example.com',
+                privileged: false,
+                protocolID: [1, 'proto-A'],
+                counterparty: 'self',
+                reason: 'Different request A',
+                seekPermission: true,
+                usageType: 'signing'
+            });
+            // Make a second call for basket usage
+            const bCall = manager.ensureBasketAccess({
+                originator: 'example.com',
+                basket: 'some-basket',
+                reason: 'Different request B',
+                seekPermission: true,
+                usageType: 'insertion'
+            });
+            // Wait a moment for them to trigger
+            await new Promise(res => setTimeout(res, 5));
+            // We expect one protocol request AND one basket request
+            expect(protocolRequestCb).toHaveBeenCalledTimes(1);
+            expect(basketRequestCb).toHaveBeenCalledTimes(1);
+            // Deny protocol request
+            const pReqID = protocolRequestCb.mock.calls[0][0].requestID;
+            await manager.denyPermission(pReqID);
+            // Deny basket request
+            const bReqID = basketRequestCb.mock.calls[0][0].requestID;
+            await manager.denyPermission(bReqID);
+            // Both calls should have rejected
+            await expect(pCall).rejects.toThrow(/Permission denied/);
+            await expect(bCall).rejects.toThrow(/Permission denied/);
+            // activeRequests is empty
+            const activeRequests = manager.activeRequests;
+            expect(activeRequests.size).toBe(0);
+        });
+        it('should resolve all parallel requests when permission is granted, referencing the same requestID', async () => {
+            // No tokens => triggers request flow
+            mockNoTokensFound(manager);
+            const requestCb = globals_1.jest.fn(() => { });
+            manager.bindCallback('onProtocolPermissionRequested', requestCb);
+            // Parallel calls
+            const promiseA = manager.ensureProtocolPermission({
+                originator: 'example.com',
+                privileged: false,
+                protocolID: [1, 'proto-X'],
+                counterparty: 'anyone',
+                reason: 'Test parallel grant A',
+                seekPermission: true,
+                usageType: 'encrypting'
+            });
+            const promiseB = manager.ensureProtocolPermission({
+                originator: 'example.com',
+                privileged: false,
+                protocolID: [1, 'proto-X'],
+                counterparty: 'anyone',
+                reason: 'Test parallel grant B',
+                seekPermission: true,
+                usageType: 'encrypting'
+            });
+            // Let the request event fire
+            await new Promise(res => setTimeout(res, 5));
+            expect(requestCb).toHaveBeenCalledTimes(1);
+            // Extract the requestID from the callback
+            const { requestID } = requestCb.mock.calls[0][0];
+            // Now we grant permission for that same requestID
+            // Because ephemeral is false by default, the manager will attempt to create on-chain tokens
+            // We'll mock the internal createPermissionOnChain so it doesn't blow up
+            const createOnChainSpy = globals_1.jest.spyOn(manager, 'createPermissionOnChain').mockResolvedValue(undefined);
+            await manager.grantPermission({ requestID });
+            // Both calls should resolve with `true` (the manager returns a boolean)
+            await expect(promiseA).resolves.toBe(true);
+            await expect(promiseB).resolves.toBe(true);
+            // activeRequests map is empty
+            const activeRequests = manager.activeRequests;
+            expect(activeRequests.size).toBe(0);
+            // The manager tried to create an on-chain permission token once
+            expect(createOnChainSpy).toHaveBeenCalledTimes(1);
+        });
+        it('should reject only the matching request queue on deny if requestID is specified', async () => {
+            // This scenario tests the manager's partial denial logic where we pass { requestID }
+            // to only reject the queued requests with that ID, leaving others (with a different requestID)
+            // in the queue.
+            mockNoTokensFound(manager);
+            // We do two separate calls for the same resource but at different times, resulting in separate queues.
+            // Actually, the manager normally merges them into one queue if the resource is the same.
+            // So let's do two different resources to ensure we get two separate keys.
+            const protoCb = globals_1.jest.fn(() => { });
+            manager.bindCallback('onProtocolPermissionRequested', protoCb);
+            // Resource 1
+            const p1Promise = manager.ensureProtocolPermission({
+                originator: 'siteA.com',
+                privileged: false,
+                protocolID: [1, 'proto-siteA'],
+                counterparty: 'self',
+                usageType: 'encrypting'
+            });
+            await new Promise(res => setTimeout(res, 5));
+            const p1ReqID = protoCb.mock.calls[0][0].requestID;
+            // At this point, resource 1 is pending in activeRequests. We'll not resolve it yet.
+            // Resource 2
+            const p2Promise = manager.ensureProtocolPermission({
+                originator: 'siteB.com',
+                privileged: false,
+                protocolID: [1, 'proto-siteB'],
+                counterparty: 'self',
+                usageType: 'encrypting'
+            });
+            await new Promise(res => setTimeout(res, 5));
+            // the second call triggers a second onProtocolPermissionRequested callback
+            expect(protoCb).toHaveBeenCalledTimes(2);
+            const p2ReqID = protoCb.mock.calls[1][0].requestID;
+            // Deny the second request only
+            await manager.denyPermission(p2ReqID);
+            await expect(p2Promise).rejects.toThrow(/Permission denied/);
+            // But the first request is still waiting
+            const activeRequests = manager.activeRequests;
+            expect(activeRequests.size).toBe(1);
+            // Now let's deny the first request too
+            await manager.denyPermission(p1ReqID);
+            await expect(p1Promise).rejects.toThrow(/Permission denied/);
+            // The queue is empty now
+            expect(activeRequests.size).toBe(0);
+        });
+    });
+    /**
+     * INTEGRATION TESTS
+     */
+    describe('Integration Tests: ephemeral vs. persistent tokens', () => {
+        it('should not create a token if ephemeral=true, so subsequent calls re-trigger the request', async () => {
+            // We'll do a "protocol" permission scenario:
+            mockNoTokensFound(manager);
+            // Bind the request callback
+            const requestCb = globals_1.jest.fn(() => { });
+            manager.bindCallback('onProtocolPermissionRequested', requestCb);
+            // Force any on-chain creation attempt to be spied on
+            const createTokenSpy = globals_1.jest.spyOn(manager, 'createPermissionOnChain');
+            // 1) Call ensureProtocolPermission => triggers request
+            const pCall1 = manager.ensureProtocolPermission({
+                originator: 'appdomain.com',
+                privileged: false,
+                protocolID: [1, 'ephemeral-proto'],
+                counterparty: 'self',
+                reason: 'test ephemeral #1',
+                usageType: 'signing'
+            });
+            // Wait for request callback
+            await new Promise(res => setTimeout(res, 5));
+            expect(requestCb).toHaveBeenCalledTimes(1);
+            const reqID1 = requestCb.mock.calls[0][0].requestID;
+            // Grant ephemeral
+            await manager.grantPermission({
+                requestID: reqID1,
+                ephemeral: true
+            });
+            // pCall1 is resolved
+            await expect(pCall1).resolves.toBe(true);
+            // Because ephemeral=true, we do NOT create an on-chain token
+            expect(createTokenSpy).not.toHaveBeenCalled();
+            // 2) Immediately call ensureProtocolPermission again for the same resource
+            // Because ephemeral usage didn't store a token, it should re-prompt.
+            const pCall2 = manager.ensureProtocolPermission({
+                originator: 'appdomain.com',
+                privileged: false,
+                protocolID: [1, 'ephemeral-proto'],
+                counterparty: 'self',
+                reason: 'test ephemeral #2',
+                usageType: 'signing'
+            });
+            await new Promise(res => setTimeout(res, 5));
+            // We expect a new request callback
+            expect(requestCb).toHaveBeenCalledTimes(2);
+            // We'll deny the second request
+            const reqID2 = requestCb.mock.calls[1][0].requestID;
+            await manager.denyPermission(reqID2);
+            await expect(pCall2).rejects.toThrow(/Permission denied/);
+        });
+        it('should create a token if ephemeral=false, so subsequent calls do not re-trigger if unexpired', async () => {
+            // We want the manager to truly create a token. We'll confirm that
+            // subsequent calls for the same resource skip user prompt.
+            mockNoTokensFound(manager);
+            // We'll also ensure no token is found "the first time."
+            // But on subsequent calls, we can mock that the manager sees the newly created token.
+            // Let's spy on "createPermissionOnChain" so we can intercept the new token
+            const createTokenSpy = globals_1.jest.spyOn(manager, 'createPermissionOnChain').mockResolvedValue(undefined); // no real on-chain creation
+            // Spy on "findProtocolToken" so we can simulate that the second time it's called,
+            // there's a valid token. We'll do this by setting the mock to return undefined the first time,
+            // and a valid token the second time (or we can just rely on the manager's logic).
+            let firstFindCall = true;
+            globals_1.jest.spyOn(manager, 'findProtocolToken').mockImplementation(async () => {
+                if (firstFindCall) {
+                    firstFindCall = false;
+                    return undefined; // first time triggers request
+                }
+                // second time => pretend we found a valid token
+                const mockToken = {
+                    txid: 'abcdef',
+                    outputIndex: 0,
+                    outputScript: '00',
+                    satoshis: 1,
+                    originator: 'persistentdomain.com',
+                    expiry: Math.floor(Date.now() / 1000) + 3600, // unexpired
+                    privileged: false,
+                    protocol: 'persist-proto',
+                    securityLevel: 1,
+                    counterparty: 'self'
+                };
+                return mockToken;
+            });
+            // We'll observe the request callback
+            const requestCb = globals_1.jest.fn(() => { });
+            manager.bindCallback('onProtocolPermissionRequested', requestCb);
+            // 1) First call => no token => triggers request
+            const call1 = manager.ensureProtocolPermission({
+                originator: 'persistentdomain.com',
+                privileged: false,
+                protocolID: [1, 'persist-proto'],
+                counterparty: 'self',
+                reason: 'test persistent #1',
+                usageType: 'signing'
+            });
+            await new Promise(res => setTimeout(res, 5));
+            expect(requestCb).toHaveBeenCalledTimes(1);
+            // Grant ephemeral=false => triggers createPermissionOnChain
+            const reqID = requestCb.mock.calls[0][0].requestID;
+            await manager.grantPermission({ requestID: reqID, ephemeral: false });
+            await expect(call1).resolves.toBe(true);
+            expect(createTokenSpy).toHaveBeenCalledTimes(1);
+            // 2) Second call => the manager should find the token we just "created" => no request prompt
+            const call2 = manager.ensureProtocolPermission({
+                originator: 'persistentdomain.com',
+                privileged: false,
+                protocolID: [1, 'persist-proto'],
+                counterparty: 'self',
+                reason: 'test persistent #2',
+                usageType: 'signing'
+            });
+            // We do not expect a new user prompt => requestCb remains at 1
+            await new Promise(res => setTimeout(res, 5));
+            expect(requestCb).toHaveBeenCalledTimes(1);
+            // The second call should resolve immediately, no prompt
+            await expect(call2).resolves.toBe(true);
+        });
+        it('should handle renewal if the found token is expired, passing previousToken in the request', async () => {
+            // We'll test the "renewal" flow:
+            // If the manager finds a token but it's expired, it sets { renewal: true, previousToken } in the request.
+            // We'll mock findProtocolToken to return an expired token
+            const expiredToken = {
+                txid: 'expiredTxid123',
+                outputIndex: 0,
+                outputScript: '76a914xxxx...88ac',
+                satoshis: 1,
+                originator: 'renewme.com',
+                expiry: Math.floor(Date.now() / 1000) - 100, // in the past
+                privileged: false,
+                protocol: 'renew-proto',
+                securityLevel: 1,
+                counterparty: 'self'
+            };
+            globals_1.jest.spyOn(manager, 'findProtocolToken').mockResolvedValue(expiredToken);
+            // Spy on request callback
+            const requestCb = globals_1.jest.fn(() => { });
+            manager.bindCallback('onProtocolPermissionRequested', requestCb);
+            // We'll also spy on "renewPermissionOnChain" to see if it's called
+            const renewSpy = globals_1.jest.spyOn(manager, 'renewPermissionOnChain').mockResolvedValue(undefined);
+            // Call ensureProtocolPermission => sees expired token => triggers request with renewal
+            const promise = manager.ensureProtocolPermission({
+                originator: 'renewme.com',
+                privileged: false,
+                protocolID: [1, 'renew-proto'],
+                counterparty: 'self',
+                reason: 'test renewal',
+                usageType: 'encrypting'
+            });
+            // Wait for request callback
+            await new Promise(res => setTimeout(res, 10));
+            expect(requestCb).toHaveBeenCalledTimes(1);
+            // Confirm the callback param includes `renewal=true` and `previousToken=expiredToken`
+            const { renewal, previousToken } = requestCb.mock.calls[0][0];
+            expect(renewal).toBe(true);
+            expect(previousToken.txid).toBe('expiredTxid123');
+            // Grant ephemeral=false => manager calls renewPermissionOnChain
+            const { requestID } = requestCb.mock.calls[0][0];
+            await manager.grantPermission({ requestID, ephemeral: false });
+            await expect(promise).resolves.toBe(true);
+            expect(renewSpy).toHaveBeenCalledTimes(1);
+            // The first arg is the old token, second is request, etc.
+            expect(renewSpy).toHaveBeenCalledWith(expiredToken, expect.objectContaining({ originator: 'renewme.com' }), expect.any(Number), undefined);
+        });
+    });
+});
+//# sourceMappingURL=WalletPermissionsManager.flows.test.js.map