@bsv/wallet-toolbox 1.7.16 → 1.7.18

package/mobile/node_modules/@bsv/sdk/src/script/templates/__tests/PushDrop.test.ts

@@ -1,263 +0,0 @@
-/* eslint-env jest */
-import PushDrop from '../../../script/templates/PushDrop'
-import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
-import { PrivateKey, Utils } from '../../../primitives/index'
-import { Script, Spend } from '../../../script/index'
-import { Transaction } from '../../../transaction/index'
-
-describe('PushDrop', () => {
-  let wallet
-  let pushDrop: PushDrop
-
-  const createDecodeRedeem = async (
-    fields: number[][] = [],
-    protocolID: [0 | 1 | 2, string] = [0, 'tests'],
-    keyID: string = 'test-key',
-    counterparty: string = 'self',
-    signOutputs: 'all' | 'none' | 'single' = 'all',
-    anyoneCanPay: boolean = false
-  ): Promise<void> => {
-    const lockingScript = await pushDrop.lock(
-      fields,
-      protocolID,
-      keyID,
-      counterparty
-    )
-    expect(lockingScript).toBeInstanceOf(Script)
-    const decoded = await PushDrop.decode(lockingScript)
-    expect(decoded.fields).toEqual(fields)
-    const expectedPublicKey = (
-      await wallet.getPublicKey({ protocolID, keyID, counterparty })
-    ).publicKey
-    expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
-    const satoshis = 1
-    const unlockingTemplate = await pushDrop.unlock(
-      protocolID,
-      keyID,
-      counterparty,
-      signOutputs,
-      anyoneCanPay
-    )
-    const sourceTx = new Transaction(
-      1,
-      [],
-      [
-        {
-          lockingScript,
-          satoshis
-        }
-      ],
-      0
-    )
-    const spendTx = new Transaction(
-      1,
-      [
-        {
-          sourceTransaction: sourceTx,
-          sourceOutputIndex: 0,
-          sequence: 0xffffffff
-        }
-      ],
-      [],
-      0
-    )
-    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
-    expect(await unlockingTemplate.estimateLength()).toEqual(73)
-    const spend = new Spend({
-      sourceTXID: sourceTx.id('hex'),
-      sourceOutputIndex: 0,
-      sourceSatoshis: satoshis,
-      lockingScript,
-      transactionVersion: 1,
-      otherInputs: [],
-      inputIndex: 0,
-      unlockingScript,
-      outputs: [],
-      inputSequence: 0xffffffff,
-      lockTime: 0
-    })
-    const valid = spend.validate()
-    expect(valid).toBe(true)
-  }
-
-  beforeEach(() => {
-    const privateKey = PrivateKey.fromRandom()
-    wallet = new CompletedProtoWallet(privateKey)
-    pushDrop = new PushDrop(wallet)
-  })
-
-  it('Passes various test vectors', async () => {
-    await createDecodeRedeem()
-    await createDecodeRedeem([[0]])
-    await createDecodeRedeem([[1]])
-    await createDecodeRedeem([[0x81]])
-    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]])
-    await createDecodeRedeem([new Array(200).fill(0xff)])
-    await createDecodeRedeem([new Array(400).fill(0xff)])
-    await createDecodeRedeem([new Array(70000).fill(0xff)])
-    await createDecodeRedeem([[0], [1], [2]])
-    await createDecodeRedeem([[0], [1], [2], [3]])
-    await createDecodeRedeem(
-      [[3, 1, 4, 1, 5, 9]],
-      undefined,
-      undefined,
-      undefined,
-      'none',
-      false
-    )
-    await createDecodeRedeem(
-      [[3, 1, 4, 1, 5, 9]],
-      undefined,
-      undefined,
-      undefined,
-      'single',
-      false
-    )
-    await createDecodeRedeem(
-      [[3, 1, 4, 1, 5, 9]],
-      undefined,
-      undefined,
-      undefined,
-      'all',
-      true
-    )
-    await createDecodeRedeem(
-      [[3, 1, 4, 1, 5, 9]],
-      undefined,
-      undefined,
-      undefined,
-      'none',
-      true
-    )
-    await createDecodeRedeem(
-      [[3, 1, 4, 1, 5, 9]],
-      undefined,
-      undefined,
-      undefined,
-      'single',
-      true
-    )
-  })
-
-  describe('lock', () => {
-    it('creates a correct locking script', async () => {
-      const fields = [
-        Utils.toArray('hello world', 'utf8'),
-        Utils.toArray('This is a field', 'utf8'),
-        [0xde, 0xad, 0xbe, 0xef]
-      ]
-      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
-      const keyID = 'test-key'
-      const counterparty = 'self'
-      const lockingScript = await pushDrop.lock(
-        fields,
-        protocolID,
-        keyID,
-        counterparty
-      )
-
-      // Check that the locking script is not null
-      expect(lockingScript).toBeInstanceOf(Script)
-
-      // Decode the locking script and check the fields and locking public key
-      const decoded = await PushDrop.decode(lockingScript)
-      expect(decoded.fields).toEqual(fields)
-      const expectedPublicKey = (
-        await wallet.getPublicKey({ protocolID, keyID, counterparty })
-      ).publicKey
-      expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
-    })
-  })
-
-  describe('unlock', () => {
-    it('creates a correct unlocking script', async () => {
-      const fields = [
-        Utils.toArray('hello world', 'utf8'),
-        Utils.toArray('This is a field', 'utf8'),
-        [0xde, 0xad, 0xbe, 0xef]
-      ]
-      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
-      const keyID = 'test-key'
-      const counterparty = 'self'
-      const lockingScript = await pushDrop.lock(
-        fields,
-        protocolID,
-        keyID,
-        counterparty
-      )
-      const satoshis = 1
-      const unlockingTemplate = await pushDrop.unlock(
-        protocolID,
-        keyID,
-        counterparty
-      )
-      const sourceTx = new Transaction(
-        1,
-        [],
-        [
-          {
-            lockingScript,
-            satoshis
-          }
-        ],
-        0
-      )
-      const spendTx = new Transaction(
-        1,
-        [
-          {
-            sourceTransaction: sourceTx,
-            sourceOutputIndex: 0,
-            sequence: 0xffffffff
-          }
-        ],
-        [],
-        0
-      )
-      const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
-      expect(await unlockingTemplate.estimateLength()).toEqual(73)
-      const spend = new Spend({
-        sourceTXID: sourceTx.id('hex'),
-        sourceOutputIndex: 0,
-        sourceSatoshis: satoshis,
-        lockingScript,
-        transactionVersion: 1,
-        otherInputs: [],
-        inputIndex: 0,
-        unlockingScript,
-        outputs: [],
-        inputSequence: 0xffffffff,
-        lockTime: 0
-      })
-      const valid = spend.validate()
-      expect(valid).toBe(true)
-    })
-  })
-
-  describe('decode', () => {
-    it('decodes the locking script correctly', async () => {
-      const fields = [
-        Utils.toArray('hello world', 'utf8'),
-        Utils.toArray('This is a field', 'utf8'),
-        [0xde, 0xad, 0xbe, 0xef]
-      ]
-      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
-      const keyID = 'test-key'
-      const counterparty = 'self'
-
-      const lockingScript = await pushDrop.lock(
-        fields,
-        protocolID,
-        keyID,
-        counterparty
-      )
-
-      const decoded = await PushDrop.decode(lockingScript)
-      expect(decoded.fields).toEqual(fields)
-      const expectedPublicKey = (
-        await wallet.getPublicKey({ protocolID, keyID, counterparty })
-      ).publicKey
-      expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
-    })
-  })
-})

package/mobile/node_modules/@bsv/sdk/src/script/templates/index.ts

@@ -1,3 +0,0 @@
-export { default as P2PKH } from './P2PKH.js'
-export { default as RPuzzle } from './RPuzzle.js'
-export { default as PushDrop } from './PushDrop.js'

package/mobile/node_modules/@bsv/sdk/src/storage/StorageDownloader.ts

@@ -1,114 +0,0 @@
-import { LookupResolver } from '../overlay-tools/index.js'
-import { StorageUtils } from './index.js'
-import PushDrop from '../script/templates/PushDrop.js'
-import Transaction from '../transaction/Transaction.js'
-import { Hash, Utils } from '../primitives/index.js'
-
-export interface DownloaderConfig {
-  networkPreset: 'mainnet' | 'testnet' | 'local'
-}
-
-export interface DownloadResult {
-  data: Uint8Array
-  mimeType: string | null
-}
-
-export class StorageDownloader {
-  private readonly networkPreset?: 'mainnet' | 'testnet' | 'local' = 'mainnet'
-  private readonly lookupResolver: LookupResolver
-
-  constructor (config?: DownloaderConfig) {
-    this.networkPreset = config?.networkPreset ?? 'mainnet'
-    this.lookupResolver = new LookupResolver({ networkPreset: this.networkPreset })
-  }
-
-  /**
-   * Resolves the UHRP URL to a list of HTTP URLs where content can be downloaded.
-   * @param uhrpUrl The UHRP URL to resolve.
-   * @returns A promise that resolves to an array of HTTP URLs.
-   */
-  public async resolve (uhrpUrl: string): Promise<string[]> {
-    // Use UHRP lookup service
-    const response = await this.lookupResolver.query({ service: 'ls_uhrp', query: { uhrpUrl } })
-    if (response.type !== 'output-list') {
-      throw new Error('Lookup answer must be an output list')
-    }
-    const decodedResults: string[] = []
-    const currentTime = Math.floor(Date.now() / 1000)
-    for (let i = 0; i < response.outputs.length; i++) {
-      const tx = Transaction.fromBEEF(response.outputs[i].beef)
-      const { fields } = PushDrop.decode(tx.outputs[response.outputs[i].outputIndex].lockingScript)
-
-      const expiryTime = new Utils.Reader(fields[3]).readVarIntNum()
-      if (expiryTime < currentTime) {
-        continue
-      }
-
-      decodedResults.push(Utils.toUTF8(fields[2]))
-    }
-    return decodedResults
-  }
-
-  /**
-   * Downloads the content from the UHRP URL after validating the hash for integrity.
-   * @param uhrpUrl The UHRP URL to download.
-   * @returns A promise that resolves to the downloaded content.
-   */
-  public async download (uhrpUrl: string): Promise<DownloadResult> {
-    if (!StorageUtils.isValidURL(uhrpUrl)) {
-      throw new Error('Invalid parameter UHRP url')
-    }
-    const hash = StorageUtils.getHashFromURL(uhrpUrl)
-    const expected = Utils.toHex(hash)
-    const downloadURLs = await this.resolve(uhrpUrl)
-
-    if (!Array.isArray(downloadURLs) || downloadURLs.length === 0) {
-      throw new Error('No one currently hosts this file!')
-    }
-
-    for (let i = 0; i < downloadURLs.length; i++) {
-      try {
-        // The url is fetched
-        const result = await fetch(downloadURLs[i], { method: 'GET' })
-
-        // If the request fails, continue to the next url
-        if (!result.ok || result.status >= 400 || result.body == null) {
-          continue
-        }
-
-        const reader = result.body.getReader()
-        const hashStream = new Hash.SHA256()
-        const chunks: Uint8Array[] = []
-        let totalLength = 0
-
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-          hashStream.update(Array.from(value))
-          chunks.push(value)
-          totalLength += value.length
-        }
-
-        const digest = Utils.toHex(hashStream.digest())
-        if (digest !== expected) {
-          throw new Error('Data integrity error: value of content does not match hash of the url given')
-        }
-
-        const data = new Uint8Array(totalLength)
-        let offset = 0
-        for (const chunk of chunks) {
-          data.set(chunk, offset)
-          offset += chunk.length
-        }
-
-        return {
-          data,
-          mimeType: result.headers.get('Content-Type')
-        }
-      } catch (error) {
-        continue
-      }
-    }
-    throw new Error(`Unable to download content from ${uhrpUrl}`)
-  }
-}

package/mobile/node_modules/@bsv/sdk/src/storage/StorageUploader.ts

@@ -1,258 +0,0 @@
-import { AuthFetch } from '../auth/clients/AuthFetch.js'
-import { WalletInterface } from '../wallet/Wallet.interfaces.js'
-import * as StorageUtils from './StorageUtils.js'
-
-export interface UploaderConfig {
-  storageURL: string
-  wallet: WalletInterface
-}
-
-export interface UploadableFile {
-  data: Uint8Array | number[]
-  type: string
-}
-
-export interface UploadFileResult {
-  published: boolean
-  uhrpURL: string
-}
-
-export interface FindFileData {
-  name: string
-  size: string
-  mimeType: string
-  expiryTime: number
-}
-
-export interface RenewFileResult {
-  status: string
-  prevExpiryTime?: number
-  newExpiryTime?: number
-  amount?: number
-}
-
-/**
- * The StorageUploader class provides client-side methods for:
- * - Uploading files with a specified retention period
- * - Finding file metadata by UHRP URL
- * - Listing all user uploads
- * - Renewing an existing advertisement's expiry time
- */
-export class StorageUploader {
-  private readonly authFetch: AuthFetch
-  private readonly baseURL: string
-
-  /**
-   * Creates a new StorageUploader instance.
-   * @param {UploaderConfig} config - An object containing the storage server's URL and a wallet interface
-   */
-  constructor (config: UploaderConfig) {
-    this.baseURL = config.storageURL
-    this.authFetch = new AuthFetch(config.wallet)
-  }
-
-  /**
-   * Requests information from the server to upload a file (including presigned URL and headers).
-   * @private
-   * @param {number} fileSize - The size of the file, in bytes
-   * @param {number} retentionPeriod - The desired hosting time, in minutes
-   * @returns {Promise<{ uploadURL: string; requiredHeaders: Record<string, string>; amount?: number }>}
-   * @throws {Error} If the server returns a non-OK response or an error status
-   */
-  private async getUploadInfo (
-    fileSize: number,
-    retentionPeriod: number
-  ): Promise<{
-      uploadURL: string
-      requiredHeaders: Record<string, string>
-      amount?: number
-    }> {
-    const url = `${this.baseURL}/upload`
-    const body = { fileSize, retentionPeriod }
-
-    const response = await this.authFetch.fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body)
-    })
-    if (!response.ok) {
-      throw new Error(`Upload info request failed: HTTP ${response.status}`)
-    }
-    const data = await response.json() as {
-      status: string
-      uploadURL: string
-      amount?: number
-      requiredHeaders: Record<string, string>
-    }
-    if (data.status === 'error') {
-      throw new Error('Upload route returned an error.')
-    }
-    return {
-      uploadURL: data.uploadURL,
-      requiredHeaders: data.requiredHeaders,
-      amount: data.amount
-    }
-  }
-
-  /**
-   * Performs the actual file upload (HTTP PUT) to the presigned URL returned by the server.
-   * @private
-   * @param {string} uploadURL - The presigned URL where the file is to be uploaded
-   * @param {UploadableFile} file - The file to upload, including its raw data and MIME type
-   * @param {Record<string, string>} requiredHeaders - Additional headers required by the server (e.g. content-length)
-   * @returns {Promise<UploadFileResult>} An object indicating whether publishing was successful and the resulting UHRP URL
-   * @throws {Error} If the server returns a non-OK response
-   */
-  private async uploadFile (
-    uploadURL: string,
-    file: UploadableFile,
-    requiredHeaders: Record<string, string>
-  ): Promise<UploadFileResult> {
-    const body = file.data instanceof Uint8Array ? file.data : Uint8Array.from(file.data)
-
-    const response = await fetch(uploadURL, {
-      method: 'PUT',
-      body: body as BodyInit,
-      headers: {
-        'Content-Type': file.type,
-        ...requiredHeaders
-      }
-    })
-    if (!response.ok) {
-      throw new Error(`File upload failed: HTTP ${response.status}`)
-    }
-
-    const uhrpURL = StorageUtils.getURLForFile(body)
-    return {
-      published: true,
-      uhrpURL
-    }
-  }
-
-  /**
-   * Publishes a file to the storage server with the specified retention period.
-   *
-   * This will:
-   * 1. Request an upload URL from the server.
-   * 2. Perform an HTTP PUT to upload the file’s raw bytes.
-   * 3. Return a UHRP URL referencing the file once published.
-   *
-   * @param {Object} params
-   * @param {UploadableFile} params.file - The file data + type
-   * @param {number} params.retentionPeriod - Number of minutes to host the file
-   * @returns {Promise<UploadFileResult>} An object with the file's UHRP URL
-   * @throws {Error} If the server or upload step returns a non-OK response
-   */
-  public async publishFile (params: {
-    file: UploadableFile
-    retentionPeriod: number
-  }): Promise<UploadFileResult> {
-    const { file, retentionPeriod } = params
-    const data = file.data instanceof Uint8Array ? file.data : Uint8Array.from(file.data)
-    const fileSize = data.byteLength
-
-    const { uploadURL, requiredHeaders } = await this.getUploadInfo(fileSize, retentionPeriod)
-    return await this.uploadFile(uploadURL, { data, type: file.type }, requiredHeaders)
-  }
-
-  /**
-   * Retrieves metadata for a file matching the given UHRP URL from the `/find` route.
-   * @param {string} uhrpUrl - The UHRP URL, e.g. "uhrp://abcd..."
-   * @returns {Promise<FindFileData>} An object with file name, size, MIME type, and expiry time
-   * @throws {Error} If the server or the route returns an error
-   */
-  public async findFile (uhrpUrl: string): Promise<FindFileData> {
-    const url = new URL(`${this.baseURL}/find`)
-    url.searchParams.set('uhrpUrl', uhrpUrl)
-
-    const response = await this.authFetch.fetch(url.toString(), {
-      method: 'GET'
-    })
-    if (!response.ok) {
-      throw new Error(`findFile request failed: HTTP ${response.status}`)
-    }
-
-    const data = await response.json() as {
-      status: string
-      data: { name: string, size: string, mimeType: string, expiryTime: number }
-      code?: string
-      description?: string
-    }
-
-    if (data.status === 'error') {
-      const errCode = data.code ?? 'unknown-code'
-      const errDesc = data.description ?? 'no-description'
-      throw new Error(`findFile returned an error: ${errCode} - ${errDesc}`)
-    }
-    return data.data
-  }
-
-  /**
-   * Lists all advertisements belonging to the user from the `/list` route.
-   * @returns {Promise<any>} The array of uploads returned by the server
-   * @throws {Error} If the server or the route returns an error
-   */
-  public async listUploads (): Promise<any> {
-    const url = `${this.baseURL}/list`
-    const response = await this.authFetch.fetch(url, {
-      method: 'GET'
-    })
-    if (!response.ok) {
-      throw new Error(`listUploads request failed: HTTP ${response.status}`)
-    }
-
-    const data = await response.json()
-    if (data.status === 'error') {
-      const errCode = data.code as string ?? 'unknown-code'
-      const errDesc = data.description as string ?? 'no-description'
-      throw new Error(`listUploads returned an error: ${errCode} - ${errDesc}`)
-    }
-    return data.uploads
-  }
-
-  /**
-   * Renews the hosting time for an existing file advertisement identified by uhrpUrl.
-   * Calls the `/renew` route to add `additionalMinutes` to the GCS customTime
-   * and re-mint the advertisement token on-chain.
-   *
-   * @param {string} uhrpUrl - The UHRP URL of the file (e.g., "uhrp://abcd1234...")
-   * @param {number} additionalMinutes - The number of minutes to extend
-   * @returns {Promise<RenewFileResult>} An object with the new and previous expiry times, plus any cost
-   * @throws {Error} If the request fails or the server returns an error
-   */
-  public async renewFile (uhrpUrl: string, additionalMinutes: number): Promise<RenewFileResult> {
-    const url = `${this.baseURL}/renew`
-    const body = { uhrpUrl, additionalMinutes }
-
-    const response = await this.authFetch.fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body)
-    })
-    if (!response.ok) {
-      throw new Error(`renewFile request failed: HTTP ${response.status}`)
-    }
-
-    const data = await response.json() as {
-      status: string
-      prevExpiryTime?: number
-      newExpiryTime?: number
-      amount?: number
-      code?: string
-      description?: string
-    }
-
-    if (data.status === 'error') {
-      const errCode = data.code ?? 'unknown-code'
-      const errDesc = data.description ?? 'no-description'
-      throw new Error(`renewFile returned an error: ${errCode} - ${errDesc}`)
-    }
-
-    return {
-      status: data.status,
-      prevExpiryTime: data.prevExpiryTime,
-      newExpiryTime: data.newExpiryTime,
-      amount: data.amount
-    }
-  }
-}