@bsv/wallet-toolbox 1.7.18 → 2.0.0-beta.0

package/test/wallet/action/createAction.test.ts

@@ -1,299 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { AtomicBEEF, Beef, CreateActionArgs, SignActionArgs } from '@bsv/sdk'
-import { sdk, StorageKnex } from '../../../src/index.all'
-import { _tu, expectToThrowWERR, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
-import { WalletLogger } from '../../../src/WalletLogger'
-
-const includeTestChaintracks = false
-const noLog = true
-
-describe('createAction test', () => {
-  jest.setTimeout(99999999)
-
-  const amount = 1319
-  const env = _tu.getEnv('test')
-  const testName = () => expect.getState().currentTestName || 'test'
-
-  let ctxs: TestWalletNoSetup[]
-
-  beforeEach(async () => {
-    ctxs = []
-    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('createActionTests'))
-    ctxs.push(await _tu.createLegacyWalletSQLiteCopy(`${testName()}`))
-    _tu.mockPostServicesAsSuccess(ctxs)
-  })
-
-  afterEach(async () => {
-    for (const ctx of ctxs) {
-      await ctx.storage.destroy()
-    }
-  })
-
-  test('0_invalid_params', async () => {
-    for (const { wallet } of ctxs) {
-      {
-        const args: CreateActionArgs[] = [
-          // description is too short...
-          { description: '' },
-          // no outputs, inputs or sendWith, now legal as isRemixChange transaction
-          //{ description: '12345' },
-          // lockingScript must be hexadecimal
-          {
-            description: '12345',
-            outputs: [
-              {
-                satoshis: 42,
-                lockingScript: 'fred',
-                outputDescription: 'pay fred'
-              }
-            ]
-          },
-          // lockingScript must be even length
-          {
-            description: '12345',
-            outputs: [
-              {
-                satoshis: 42,
-                lockingScript: 'abc',
-                outputDescription: 'pay fred'
-              }
-            ]
-          }
-        ]
-
-        for (const a of args) {
-          await expectToThrowWERR(sdk.WERR_INVALID_PARAMETER, () => wallet.createAction(a))
-        }
-      }
-    }
-  })
-
-  test('1_repeatable txid', async () => {
-    for (const { wallet } of ctxs) {
-      //wallet.makeLogger = () => console
-      wallet.makeLogger = () => new WalletLogger()
-      wallet.randomVals = [0.1, 0.2, 0.3, 0.7, 0.8, 0.9]
-      const root = '02135476'
-      const kp = _tu.getKeyPair(root.repeat(8))
-      const createArgs: CreateActionArgs = {
-        description: `repeatable`,
-        outputs: [
-          {
-            satoshis: 45,
-            lockingScript: _tu.getLockP2PKH(kp.address).toHex(),
-            outputDescription: 'pay echo'
-          }
-        ],
-        options: {
-          randomizeOutputs: false,
-          signAndProcess: true,
-          noSend: true
-        }
-      }
-
-      const cr = await wallet.createAction(createArgs)
-      expect(cr.txid === '4f428a93c43c2d120204ecdc06f7916be8a5f4542cc8839a0fd79bd1b44582f3')
-    }
-  })
-
-  test('2_signableTransaction', async () => {
-    if (!includeTestChaintracks) return
-    for (const { wallet } of ctxs) {
-      const root = '02135476'
-      const kp = _tu.getKeyPair(root.repeat(8))
-
-      let txid1: string
-      let txid2: string
-      const outputSatoshis = 42
-      let noSendChange: string[] | undefined
-      let inputBEEF: AtomicBEEF | undefined
-
-      {
-        const createArgs: CreateActionArgs = {
-          description: `${kp.address} of ${root}`,
-          outputs: [
-            {
-              satoshis: outputSatoshis,
-              lockingScript: _tu.getLockP2PKH(kp.address).toHex(),
-              outputDescription: 'pay fred'
-            }
-          ],
-          options: {
-            randomizeOutputs: false,
-            signAndProcess: false,
-            noSend: true
-          }
-        }
-
-        const cr = await wallet.createAction(createArgs)
-
-        noSendChange = cr.noSendChange
-
-        expect(cr.noSendChange).toBeTruthy()
-        expect(cr.sendWithResults).toBeUndefined()
-        expect(cr.tx).toBeUndefined()
-        expect(cr.txid).toBeUndefined()
-
-        expect(cr.signableTransaction).toBeTruthy()
-        const st = cr.signableTransaction!
-        expect(st.reference).toBeTruthy()
-        // const tx = Transaction.fromAtomicBEEF(st.tx) // Transaction doesn't support V2 Beef yet.
-        const atomicBeef = Beef.fromBinary(st.tx)
-        const tx = atomicBeef.txs[atomicBeef.txs.length - 1].tx!
-        for (const input of tx.inputs) {
-          expect(atomicBeef.findTxid(input.sourceTXID!)).toBeTruthy()
-        }
-
-        // Spending authorization check happens here...
-        //expect(st.amount > 242 && st.amount < 300).toBe(true)
-
-        // sign and complete
-        const signArgs: SignActionArgs = {
-          reference: st.reference,
-          spends: {},
-          options: {
-            returnTXIDOnly: false,
-            noSend: true
-          }
-        }
-
-        const sr = await wallet.signAction(signArgs)
-        inputBEEF = sr.tx
-
-        txid1 = sr.txid!
-        // Update the noSendChange txid to final signed value.
-        noSendChange = noSendChange!.map(op => `${txid1}.${op.split('.')[1]}`)
-      }
-
-      {
-        const unlock = _tu.getUnlockP2PKH(kp.privateKey, outputSatoshis)
-        const unlockingScriptLength = await unlock.estimateLength()
-
-        const createArgs: CreateActionArgs = {
-          description: `${kp.address} of ${root}`,
-          inputs: [
-            {
-              outpoint: `${txid1}.0`,
-              inputDescription: 'spend ${kp.address} of ${root}',
-              unlockingScriptLength
-            }
-          ],
-          inputBEEF,
-          options: {
-            noSendChange,
-            // signAndProcess: false, // Not required as an input lacks unlock script...
-            noSend: true
-          }
-        }
-
-        const cr = await wallet.createAction(createArgs)
-
-        expect(cr.noSendChange).toBeTruthy()
-        expect(cr.sendWithResults).toBeUndefined()
-        expect(cr.tx).toBeUndefined()
-        expect(cr.txid).toBeUndefined()
-        expect(cr.signableTransaction).toBeTruthy()
-        const st = cr.signableTransaction!
-        expect(st.reference).toBeTruthy()
-        const atomicBeef = Beef.fromBinary(st.tx)
-        const tx = atomicBeef.txs[atomicBeef.txs.length - 1].tx!
-
-        tx.inputs[0].unlockingScriptTemplate = unlock
-        await tx.sign()
-        const unlockingScript = tx.inputs[0].unlockingScript!.toHex()
-
-        const signArgs: SignActionArgs = {
-          reference: st.reference,
-          spends: { 0: { unlockingScript } },
-          options: {
-            returnTXIDOnly: true,
-            noSend: true
-          }
-        }
-
-        const sr = await wallet.signAction(signArgs)
-
-        txid2 = sr.txid!
-      }
-      {
-        const createArgs: CreateActionArgs = {
-          description: `${kp.address} of ${root}`,
-          options: {
-            acceptDelayedBroadcast: false,
-            sendWith: [txid1, txid2]
-          }
-        }
-
-        const cr = await wallet.createAction(createArgs)
-
-        expect(cr.noSendChange).not.toBeTruthy()
-        expect(cr.sendWithResults?.length).toBe(2)
-        const [swr1, swr2] = cr.sendWithResults!
-        expect(swr1.status !== 'failed').toBe(true)
-        expect(swr2.status !== 'failed').toBe(true)
-        expect(swr1.txid).toBe(txid1)
-        expect(swr2.txid).toBe(txid2)
-      }
-    }
-  })
-
-  test('3_Transaction with multiple outputs()', async () => {
-    const root = '02135476'
-    const kp = _tu.getKeyPair(root.repeat(8))
-    for (const { wallet } of ctxs) {
-      const args: CreateActionArgs = {
-        description: 'Multiple outputs',
-        outputs: [
-          {
-            satoshis: 10,
-            lockingScript: _tu.getLockP2PKH(kp.address).toHex(),
-            outputDescription: 'Output 1'
-          },
-          {
-            satoshis: 20,
-            lockingScript: _tu.getLockP2PKH(kp.address).toHex(),
-            outputDescription: 'Output 2'
-          }
-        ],
-        options: {
-          signAndProcess: false,
-          noSend: true
-        }
-      }
-      const r = await wallet.createAction(args)
-      expect(r.signableTransaction?.reference).toBeTruthy()
-      expect(r.noSendChange?.length).toBe(1)
-      expect(r.signableTransaction?.reference).toBeTruthy()
-      expect(Array.isArray(r.signableTransaction?.tx)).toBe(true)
-    }
-  })
-
-  test('4_Transaction with large number of outputs(50) and randomized', async () => {
-    const root = '02135476'
-    const kp = _tu.getKeyPair(root.repeat(8))
-
-    for (const { wallet } of ctxs) {
-      const outputs = Array.from({ length: 50 }, (_, i) => ({
-        satoshis: i + 1, // Increment amounts
-        lockingScript: _tu.getLockP2PKH(kp.address).toHex(),
-        outputDescription: `Output ${i}`
-      }))
-
-      const args: CreateActionArgs = {
-        description: 'Randomized Outputs',
-        lockTime: 500000,
-        outputs,
-        options: {
-          signAndProcess: false,
-          noSend: true,
-          randomizeOutputs: true
-        }
-      }
-      const r = await wallet.createAction(args)
-      expect(r.signableTransaction?.reference).toBeTruthy()
-      expect(r.noSendChange?.length).toBe(1)
-      expect(r.signableTransaction?.reference).toBeTruthy()
-      expect(Array.isArray(r.signableTransaction?.tx)).toBe(true)
-    }
-  })
-})