@bsv/wallet-toolbox 1.1.0

package/test/Wallet/action/internalizeAction.a.test.ts

@@ -0,0 +1,301 @@
+import { Beef, InternalizeOutput } from '@bsv/sdk'
+import { sdk, StorageKnex } from '../../../src/index.all'
+import {
+  _tu,
+  expectToThrowWERR,
+  TestWalletNoSetup
+} from '../../utils/TestUtilsWalletStorage'
+import { getBeefForTransaction } from '../../../src/storage/methods/getBeefForTransaction'
+
+/**
+ * NOT PASSING YET
+ */
+describe.skip('internalizeAction tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL)
+      ctxs.push(await _tu.createLegacyWalletMySQLCopy('internalizeActionTests'))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('internalizeActionTests'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  // Check:  'unproven' or 'completed' status. Any other status is an error.
+  // When the transaction already exists, the description is updated. The isOutgoing sense is not changed.
+
+  test.skip('1_default real wallet data', async () => {
+    // 1. construct a normal transaction with user supplied output.
+    // 2. dito but user input
+    // 3..Repeat 1 & 2  but use sign action
+    // Repeat 1-3 but use noSend and then a sendWith.
+    // Figure the exact fee cost for transactions 1-3 and start with a noSend transaction that creates a change output with just the right fee amount. Then rebuild 1-3, as second tx, feed it the noSend change from the first tx, confirm no additional change is added or produced, use sendWith to send both as a batch.
+    // "basket insertion" Merge Rules:
+    // The "default" basket may not be specified as the insertion basket.
+    // A change output in the "default" basket may not be target of an insertion into a different basket.
+    // These baskets do not affect the wallet's balance and are typed "custom".
+    // "wallet payment" Merge Rules:
+    // Targetting an existing change "default" basket output results in a no-op. No error. No alterations made.
+    // Targetting a previously "custom" non-change output converts it into a change output. This alters the transaction's amount, and the wallet balance.
+
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      try {
+        // Prepare StorageGetBeefOptions
+        const options: sdk.StorageGetBeefOptions = {
+          // Setting 'known' tells it not to include rawTxs it already knows about, just their txids.
+          // trustSelf: 'known',
+          // Setting knownTxids tells it not to include these rawTxs, just their txids.
+          // knownTxids: ['2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122'],
+          // False and undefined are equal here so no need for this.
+          // ignoreStorage: false,
+          // Yes, you expect storage to have the info, so don't use services.
+          ignoreServices: true
+          // Since you aren't using services and there won't be any newProven (rawTx's with merklePaths previously unknown to storage but required for this beef)
+          // ignoreNewProven: false,
+          // You don't expect infinitely deep nonsense
+          // minProofLevel: 0
+        }
+
+        // Fetch Beef object
+        const beef = await storage.getBeefForTransaction(
+          '2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122',
+          options
+        )
+
+        //console.log('Beef Object:\n', beef.toLogString())
+
+        // Ensure Beef object contains valid transactions
+        if (beef.txs.length === 0) {
+          throw new Error('Beef contains no transactions')
+        }
+
+        // Validate the first transaction in the Beef object
+        const firstTx = beef.txs[0]
+        if (!firstTx.isValid) {
+          console.error('First transaction is invalid:', firstTx)
+          throw new Error('Beef contains an invalid transaction')
+        }
+
+        expect(beef.atomicTxid).toBeUndefined()
+
+        // Convert to AtomicBEEF transaction
+        const atomicTx = beef.toBinaryAtomic(
+          '2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122'
+        )
+        //console.log('Atomic Transaction:', atomicTx)
+
+        // {
+        //   const abeef = Beef.fromBinary(atomicTx)
+        //   expect(abeef.atomicTxid).toBe('2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122')
+        // }
+
+        // This needs to be a real output (the locking script and derivation bits / key need to work with each other)
+        // But it is still a valid test to see what the reaction is to this nonsense :-)
+        // Prepare output for internalization
+        const output: InternalizeOutput = {
+          outputIndex: 2,
+          protocol: 'wallet payment',
+          paymentRemittance: {
+            derivationPrefix: 'y0tgyMJbVWKhds2/MWkDBA==',
+            derivationSuffix: 'J1Q1E8re2RbvKONkEiEHDA==',
+            senderIdentityKey:
+              '03ac2d10bdb0023f4145cc2eba2fcd2ad3070cb2107b0b48170c46a9440e4cc3fe'
+          }
+        }
+
+        // Internalize Action
+        const r = await wallet.internalizeAction({
+          tx: atomicTx,
+          outputs: [output],
+          description: 'Default wallet payment'
+        })
+
+        // Validate result
+        //console.log('Internalize Action Result:', r)
+        expect(r).toBeDefined()
+      } catch (error) {
+        console.error('Test failed with error:', error)
+        throw error
+      }
+    }
+  })
+
+  test('2_default real basket insertion', async () => {
+    // 1. construct a normal transaction with user supplied output.
+    // 2. dito but user input
+    // 3..Repeat 1 & 2  but use sign action
+    // Repeat 1-3 but use noSend and then a sendWith.
+    // Figure the exact fee cost for transactions 1-3 and start with a noSend transaction that creates a change output with just the right fee amount. Then rebuild 1-3, as second tx, feed it the noSend change from the first tx, confirm no additional change is added or produced, use sendWith to send both as a batch.
+    // "basket insertion" Merge Rules:
+    // The "default" basket may not be specified as the insertion basket.
+    // A change output in the "default" basket may not be target of an insertion into a different basket.
+    // These baskets do not affect the wallet's balance and are typed "custom".
+    // "wallet payment" Merge Rules:
+    // Targetting an existing change "default" basket output results in a no-op. No error. No alterations made.
+    // Targetting a previously "custom" non-change output converts it into a change output. This alters the transaction's amount, and the wallet balance.
+
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      try {
+        // Prepare StorageGetBeefOptions
+        const options: sdk.StorageGetBeefOptions = {
+          // Setting 'known' tells it not to include rawTxs it already knows about, just their txids.
+          // trustSelf: 'known',
+          // Setting knownTxids tells it not to include these rawTxs, just their txids.
+          // knownTxids: ['2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122'],
+          // False and undefined are equal here so no need for this.
+          // ignoreStorage: false,
+          // Yes, you expect storage to have the info, so don't use services.
+          ignoreServices: true
+          // Since you aren't using services and there won't be any newProven (rawTx's with merklePaths previously unknown to storage but required for this beef)
+          // ignoreNewProven: false,
+          // You don't expect infinitely deep nonsense
+          // minProofLevel: 0
+        }
+
+        // Fetch Beef object
+        const beef = await storage.getBeefForTransaction(
+          'a3b2f0935c7b5bb7a841a09e535c13be86f4df0e7a91cebdc33812bfcc0eb9d7',
+          options
+        )
+
+        //console.log('Beef Object:\n', beef.toLogString())
+
+        // Ensure Beef object contains valid transactions
+        if (beef.txs.length === 0) {
+          throw new Error('Beef contains no transactions')
+        }
+
+        // Validate the first transaction in the Beef object
+        const firstTx = beef.txs[0]
+        if (!firstTx.isValid) {
+          console.error('First transaction is invalid:', firstTx)
+          throw new Error('Beef contains an invalid transaction')
+        }
+
+        expect(beef.atomicTxid).toBeUndefined()
+
+        // Convert to AtomicBEEF transaction
+        const atomicTx = beef.toBinaryAtomic(
+          'a3b2f0935c7b5bb7a841a09e535c13be86f4df0e7a91cebdc33812bfcc0eb9d7'
+        )
+        //console.log('Atomic Transaction:', atomicTx)
+
+        {
+          const abeef = Beef.fromBinary(atomicTx)
+          expect(abeef.atomicTxid).toBe(
+            'a3b2f0935c7b5bb7a841a09e535c13be86f4df0e7a91cebdc33812bfcc0eb9d7'
+          )
+        }
+
+        // This needs to be a real output (the locking script and derivation bits / key need to work with each other)
+        // But it is still a valid test to see what the reaction is to this nonsense :-)
+        // Prepare output for internalization
+        const output: InternalizeOutput = {
+          outputIndex: 0,
+          protocol: 'basket insertion',
+          // export interface BasketInsertion {
+          //   basket: BasketStringUnder300Bytes
+          //   customInstructions?: string
+          //   tags?: OutputTagStringUnder300Bytes[]
+          // }
+          insertionRemittance: {
+            basket: 'babbage-token-access',
+            tags: [
+              'babbage_originator todo.babbage.systems',
+              'babbage_action_originator projectbabbage.com',
+              'babbage_protocolname todo list',
+              'babbage_protocolsecuritylevel 2',
+              'babbage_counterparty self'
+            ]
+          }
+        }
+
+        // Internalize Action
+        const r = await wallet.internalizeAction({
+          tx: atomicTx,
+          outputs: [output],
+          description: 'Default basket insertion'
+        })
+
+        // Validate result
+        //console.log('Internalize Action Result:', r)
+        expect(r).toBeDefined()
+      } catch (error) {
+        console.error('Test failed with error:', error)
+        throw error
+      }
+    }
+  })
+
+  test.skip('3_default', async () => {
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      try {
+        // Prepare StorageGetBeefOptions
+        const options: sdk.StorageGetBeefOptions = {
+          ignoreServices: true
+        }
+
+        // Fetch Beef object
+        const beef = await storage.getBeefForTransaction(
+          '2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122',
+          options
+        )
+
+        //console.log('Beef Object:', beef)
+
+        // Ensure Beef object contains valid transactions
+        if (beef.txs.length === 0) {
+          throw new Error('Beef contains no transactions')
+        }
+
+        // Validate the first transaction in the Beef object
+        const firstTx = beef.txs[0]
+        if (!firstTx.isValid) {
+          console.error('First transaction is invalid:', firstTx)
+          throw new Error('Beef contains an invalid transaction')
+        }
+
+        expect(beef.atomicTxid).toBeDefined()
+
+        // Convert to AtomicBEEF transaction
+        const atomicTx = beef.toBinaryAtomic(
+          '2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122'
+        )
+        //console.log('Atomic Transaction:', atomicTx)
+
+        // Prepare output for internalization
+        const output: InternalizeOutput = {
+          outputIndex: 2,
+          protocol: 'basket insertion',
+          paymentRemittance: {
+            derivationPrefix: 'y0tgyMJbVWKhds2/MWkDBA==',
+            derivationSuffix: 'J1Q1E8re2RbvKONkEiEHDA==',
+            senderIdentityKey:
+              '03ac2d10bdb0023f4145cc2eba2fcd2ad3070cb2107b0b48170c46a9440e4cc3fe'
+          }
+        }
+
+        // Internalize Action
+        const r = await wallet.internalizeAction({
+          tx: atomicTx,
+          outputs: [output],
+          description: 'Default test description'
+        })
+
+        // Validate result
+        //console.log('Internalize Action Result:', r)
+        expect(r).toBeDefined()
+      } catch (error) {
+        console.error('Test failed with error:', error)
+        throw error
+      }
+    }
+  })
+})

package/test/Wallet/certificate/acquireCertificate.test.ts

@@ -0,0 +1,253 @@
+import {
+  AcquireCertificateArgs,
+  CompletedProtoWallet,
+  ProveCertificateArgs
+} from '@bsv/sdk'
+import { _tu, expectToThrowWERR } from '../../utils/TestUtilsWalletStorage'
+import { sdk, Wallet } from '../../../src/index.all'
+
+describe('acquireCertificate tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+
+  beforeAll(async () => {})
+
+  afterAll(async () => {})
+
+  test('1 invalid params', async () => {
+    const { wallet, storage } = await _tu.createLegacyWalletSQLiteCopy(
+      'acquireCertificate1'
+    )
+
+    const invalidArgs: AcquireCertificateArgs[] = [
+      {
+        type: '',
+        certifier: '',
+        acquisitionProtocol: 'direct',
+        fields: {}
+      }
+      // Oh so many things to test...
+    ]
+
+    for (const args of invalidArgs) {
+      await expectToThrowWERR(sdk.WERR_INVALID_PARAMETER, () =>
+        wallet.acquireCertificate(args)
+      )
+    }
+
+    await storage.destroy()
+  })
+
+  test('2 acquireCertificate listCertificate proveCertificate', async () => {
+    const { wallet, storage } = await _tu.createSQLiteTestWallet({
+      databaseName: 'acquireCertificate2',
+      dropAll: true
+    })
+
+    // Make a test certificate from a random certifier for the wallet's identityKey
+    const subject = wallet.keyDeriver.identityKey
+    const { cert, certifier } = _tu.makeSampleCert(subject)
+
+    // Act as the certifier: create a wallet for them...
+    const certifierWallet = new CompletedProtoWallet(certifier)
+    // load the plaintext certificate into a CertOps object
+    const co = new sdk.CertOps(certifierWallet, cert)
+    // encrypt and sign the certificate
+    await co.encryptAndSignNewCertificate()
+    // export the signed certificate and a keyring for this wallet's identity as counterparty
+    const { certificate: c, keyring: kr } = co.exportForSubject()
+
+    // args object to create a new certificate via 'direct' protocol.
+    const args: AcquireCertificateArgs = {
+      serialNumber: c.serialNumber,
+      signature: c.signature,
+      privileged: false,
+      privilegedReason: undefined,
+
+      type: c.type,
+      certifier: c.certifier,
+      acquisitionProtocol: 'direct',
+      fields: c.fields,
+      keyringForSubject: kr,
+      keyringRevealer: 'certifier',
+      revocationOutpoint: c.revocationOutpoint
+    }
+    // store the new signed certificate in user's wallet
+    const r = await wallet.acquireCertificate(args)
+    expect(r.serialNumber).toBe(c.serialNumber)
+
+    // Attempt to retrieve it... since
+    // the certifier is random this should
+    // always be unique :-)
+    const lcs = await wallet.listCertificates({
+      certifiers: [cert.certifier],
+      types: []
+    })
+    expect(lcs.certificates.length).toBe(1)
+    const lc = lcs.certificates[0]
+    // the result should be encrypted.
+    expect(lc.fields['name']).not.toBe('Alice')
+
+    // Use proveCertificate to obtain a decryption keyring:
+    const pkrArgs: ProveCertificateArgs = {
+      certificate: { serialNumber: lc.serialNumber },
+      fieldsToReveal: ['name'],
+      verifier: subject
+    }
+    const pkr = await wallet.proveCertificate(pkrArgs)
+    const co2 = await sdk.CertOps.fromCounterparty(wallet, {
+      certificate: lc,
+      keyring: pkr.keyringForVerifier,
+      counterparty: pkrArgs.verifier
+    })
+    expect(co2._decryptedFields!['name']).toBe('Alice')
+
+    const certs = await wallet.listCertificates({ types: [], certifiers: [] })
+    for (const cert of certs.certificates) {
+      const rr = await wallet.relinquishCertificate({
+        type: cert.type,
+        serialNumber: cert.serialNumber,
+        certifier: cert.certifier
+      })
+      expect(rr.relinquished).toBe(true)
+    }
+    await storage.destroy()
+  })
+
+  test('3 privileged acquireCertificate listCertificate proveCertificate', async () => {
+    const { wallet, storage } = await _tu.createSQLiteTestWallet({
+      databaseName: 'acquireCertificate3',
+      privKeyHex: '42'.repeat(32),
+      dropAll: true
+    })
+
+    // Make a test certificate from a random certifier for the wallet's identityKey
+
+    // Certificate issued to the privileged key must use the privilegedKeyManager's identityKey
+    const subject = (
+      await wallet.privilegedKeyManager!.getPublicKey({ identityKey: true })
+    ).publicKey
+    const { cert, certifier } = _tu.makeSampleCert(subject)
+
+    // Act as the certifier: create a wallet for them...
+    const certifierWallet = new CompletedProtoWallet(certifier)
+    // load the plaintext certificate into a CertOps object
+    const co = new sdk.CertOps(certifierWallet, cert)
+    // encrypt and sign the certificate
+    await co.encryptAndSignNewCertificate()
+    // export the signed certificate and a keyring for this wallet's identity as counterparty
+    const { certificate: c, keyring: kr } = co.exportForSubject()
+
+    // args object to create a new certificate via 'direct' protocol.
+    const args: AcquireCertificateArgs = {
+      serialNumber: c.serialNumber,
+      signature: c.signature,
+      privileged: true,
+      privilegedReason: 'access to my penthouse',
+
+      type: c.type,
+      certifier: c.certifier,
+      acquisitionProtocol: 'direct',
+      fields: c.fields,
+      keyringForSubject: kr,
+      keyringRevealer: 'certifier',
+      revocationOutpoint: c.revocationOutpoint
+    }
+    // store the new signed certificate in user's wallet
+    const r = await wallet.acquireCertificate(args)
+    expect(r.serialNumber).toBe(c.serialNumber)
+
+    // Attempt to retrieve it... since
+    // the certifier is random this should
+    // always be unique :-)
+    const lcs = await wallet.listCertificates({
+      certifiers: [cert.certifier],
+      types: []
+    })
+    expect(lcs.certificates.length).toBe(1)
+    const lc = lcs.certificates[0]
+    // the result should be encrypted.
+    expect(lc.fields['name']).not.toBe('Alice')
+
+    // Use proveCertificate to obtain a decryption keyring:
+    const pkrArgs: ProveCertificateArgs = {
+      certificate: { serialNumber: lc.serialNumber },
+      fieldsToReveal: ['name'],
+      verifier: subject
+    }
+    const pkr = await wallet.proveCertificate(pkrArgs)
+    const co2 = await sdk.CertOps.fromCounterparty(
+      wallet.privilegedKeyManager!,
+      {
+        certificate: lc,
+        keyring: pkr.keyringForVerifier,
+        counterparty: pkrArgs.verifier
+      }
+    )
+    expect(co2._decryptedFields!['name']).toBe('Alice')
+
+    const certs = await wallet.listCertificates({ types: [], certifiers: [] })
+    for (const cert of certs.certificates) {
+      const rr = await wallet.relinquishCertificate({
+        type: cert.type,
+        serialNumber: cert.serialNumber,
+        certifier: cert.certifier
+      })
+      expect(rr.relinquished).toBe(true)
+    }
+
+    // Also cleans up the privilegedKeyManager
+    await wallet.destroy()
+  })
+
+  /**
+   * NOTE: This test requires a generic-certifier-backend to be running
+   * with the following configuration:
+   *
+   *  type: 'h53Tvo8w3nqeF2cPyuRUc/B+gjPXJ3gPS2PKFBZfpDw=',
+   *  certifierIdentityKey: '02be1093d98689b5a5bb49cefff5d98a390213cc5b0a5cd57459407f86a963325f',
+   */
+  test.skip('acquireCertificate via issuance', async () => {
+    const { wallet, storage } = await _tu.createSQLiteTestWallet({
+      databaseName: 'acquireCertificate2',
+      dropAll: true
+    })
+    // Attributes to get certified
+    const fields = {
+      name: 'Bob',
+      email: 'bob@projectbabbage.com'
+    }
+
+    // args object to create a new certificate via 'issuance' protocol.
+    const args: AcquireCertificateArgs = {
+      type: 'h53Tvo8w3nqeF2cPyuRUc/B+gjPXJ3gPS2PKFBZfpDw=',
+      certifier:
+        '02be1093d98689b5a5bb49cefff5d98a390213cc5b0a5cd57459407f86a963325f',
+      certifierUrl: 'http://localhost:3998',
+      acquisitionProtocol: 'issuance',
+      fields: fields
+    }
+    // store the new signed certificate in user's wallet
+    const r = await wallet.acquireCertificate(args)
+    const certificatesFound = await wallet.listCertificates({
+      certifiers: [args.certifier],
+      types: []
+    })
+    expect(certificatesFound.certificates.length).toBe(1)
+    const lc = certificatesFound.certificates[0]
+    // the result should be encrypted.
+    expect(lc.fields['name']).not.toBe('Alice')
+
+    // const certs = await wallet.listCertificates({ types: [], certifiers: [] })
+    for (const cert of certificatesFound.certificates) {
+      const rr = await wallet.relinquishCertificate({
+        type: cert.type,
+        serialNumber: cert.serialNumber,
+        certifier: cert.certifier
+      })
+      expect(rr.relinquished).toBe(true)
+    }
+    await storage.destroy()
+  })
+})