@bsv/wallet-toolbox 1.7.14 → 1.7.16

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

@@ -0,0 +1,263 @@
+/* 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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,258 @@
+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
+    }
+  }
+}