chia-blockchain-gui/packages/gui/src/electron/api/nftGetMetadata.test.ts at 72a9b8d580bf6ef5102ab727a8de6db753fb0fd9 · Chia-Network/chia-blockchain-gui · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
import crypto from 'node:crypto';

type FetchBuffer = typeof import('../utils/fetchBuffer').default;

const mockFetchBuffer = jest.fn<ReturnType<FetchBuffer>, Parameters<FetchBuffer>>();

jest.mock('../utils/fetchBuffer', () => ({
  __esModule: true,
  default: mockFetchBuffer,
  MaxSizeExceededError:
    jest.requireActual<typeof import('../utils/fetchBuffer')>('../utils/fetchBuffer').MaxSizeExceededError,
}));

const mockMaybeIpfsToGatewayUrl = jest.fn<string, [string]>();

jest.mock('../utils/ipfsGateway', () => ({
  __esModule: true,
  default: mockMaybeIpfsToGatewayUrl,
}));

const mockAllowUnverifiedNftPreviews = jest.fn<boolean, []>();

jest.mock('../utils/allowUnverifiedNftPreviews', () => ({
  __esModule: true,
  default: mockAllowUnverifiedNftPreviews,
}));

const { MaxSizeExceededError } = jest.requireActual<typeof import('../utils/fetchBuffer')>('../utils/fetchBuffer');

const ipfsToGatewayUrl = jest.requireActual<typeof import('../../util/ipfs')>('../../util/ipfs').default;

const { nftGetImageDataUrl, nftGetMetadata } =
  jest.requireActual<typeof import('./nftGetMetadata')>('./nftGetMetadata');

function sha256(data: Buffer): string {
  return crypto.createHash('sha256').update(data.toString('latin1'), 'latin1').digest('hex');
}

describe('nftGetMetadata', () => {
  beforeEach(() => {
    mockFetchBuffer.mockReset();
  });

  it('parses metadata only after its raw bytes match the expected hash', async () => {
    const data = Buffer.from('{"name":"Verified NFT","preview_image_uris":["https://example.com/preview.png"]}');
    mockFetchBuffer.mockResolvedValue({
      data,
      headers: {
        'content-type': 'application/json',
      },
    });

    await expect(nftGetMetadata('https://example.com/metadata.json', `0x${sha256(data)}`)).resolves.toEqual({
      name: 'Verified NFT',
      preview_image_uris: ['https://example.com/preview.png'],
    });
  });

  it('rejects metadata whose bytes do not match the on-chain hash', async () => {
    const data = Buffer.from('{"name":"Tampered NFT"}');
    mockFetchBuffer.mockResolvedValue({
      data,
      headers: {},
    });

    await expect(nftGetMetadata('https://example.com/metadata.json', '00')).resolves.toBeUndefined();
  });

  it('does not fetch metadata without an expected hash', async () => {
    await expect(nftGetMetadata('https://example.com/metadata.json', undefined)).resolves.toBeUndefined();
    expect(mockFetchBuffer).not.toHaveBeenCalled();
  });
});

describe('nftGetImageDataUrl', () => {
  beforeEach(() => {
    mockFetchBuffer.mockReset();
    mockMaybeIpfsToGatewayUrl.mockReset();
    // gateway option off: URLs pass through untranslated
    mockMaybeIpfsToGatewayUrl.mockImplementation((url) => url);
    mockAllowUnverifiedNftPreviews.mockReset();
    mockAllowUnverifiedNftPreviews.mockReturnValue(false);
  });

  it('returns an immutable data URL for a verified image response', async () => {
    const data = Buffer.from('verified image bytes');
    mockFetchBuffer.mockResolvedValue({
      data,
      headers: {
        'content-type': 'image/png; charset=binary',
      },
    });

    await expect(nftGetImageDataUrl('https://example.com/preview.png', sha256(data))).resolves.toBe(
      `data:image/png;base64,${data.toString('base64')}`,
    );
  });

  it('rejects a hash-matched response that is not an image', async () => {
    const data = Buffer.from('<html>not an image</html>');
    mockFetchBuffer.mockResolvedValue({
      data,
      headers: {
        'content-type': 'text/html',
      },
    });

    await expect(nftGetImageDataUrl('https://example.com/preview.png', sha256(data))).resolves.toBeUndefined();
  });

  it('does not fetch an image without an expected hash', async () => {
    await expect(nftGetImageDataUrl('https://example.com/preview.png', undefined)).resolves.toBeUndefined();
    expect(mockFetchBuffer).not.toHaveBeenCalled();
  });

  it('omits the preview for an oversized image response by default', async () => {
    mockFetchBuffer.mockRejectedValue(
      new MaxSizeExceededError({
        'content-type': 'image/gif',
      }),
    );

    await expect(nftGetImageDataUrl('https://example.com/large.gif', '00')).resolves.toBeUndefined();
  });

  it('falls back to the direct URL for an oversized image when unverified previews are enabled', async () => {
    mockAllowUnverifiedNftPreviews.mockReturnValue(true);
    mockFetchBuffer.mockRejectedValue(
      new MaxSizeExceededError({
        'content-type': 'image/gif',
      }),
    );

    await expect(nftGetImageDataUrl('https://example.com/large.gif', '00')).resolves.toBe(
      'https://example.com/large.gif',
    );
  });

  it('falls back to the gateway URL for an oversized ipfs image when both options are on', async () => {
    mockAllowUnverifiedNftPreviews.mockReturnValue(true);
    mockMaybeIpfsToGatewayUrl.mockImplementation(ipfsToGatewayUrl);
    mockFetchBuffer.mockRejectedValue(
      new MaxSizeExceededError({
        'content-type': 'image/gif',
      }),
    );

    // the dialog CSP only allows https: and data: images, so the raw ipfs
    // URI would render as a broken image
    await expect(nftGetImageDataUrl('ipfs://bafybeigdyrztest/large.gif', '00')).resolves.toBe(
      'https://ipfs.io/ipfs/bafybeigdyrztest/large.gif',
    );
  });

  it('omits the preview for an oversized ipfs image while the gateway option is off', async () => {
    mockAllowUnverifiedNftPreviews.mockReturnValue(true);
    mockFetchBuffer.mockRejectedValue(
      new MaxSizeExceededError({
        'content-type': 'image/gif',
      }),
    );

    // an untranslated ipfs URI would be blocked by the dialog CSP, so no
    // preview is returned at all even though unverified previews are allowed
    await expect(nftGetImageDataUrl('ipfs://bafybeigdyrztest/large.gif', '00')).resolves.toBeUndefined();
  });

  it('omits the preview for an oversized ipfs image while unverified previews are off', async () => {
    mockMaybeIpfsToGatewayUrl.mockImplementation(ipfsToGatewayUrl);
    mockFetchBuffer.mockRejectedValue(
      new MaxSizeExceededError({
        'content-type': 'image/gif',
      }),
    );

    // the gateway option alone does not opt into unverified fallbacks
    await expect(nftGetImageDataUrl('ipfs://bafybeigdyrztest/large.gif', '00')).resolves.toBeUndefined();
  });

  it('rejects an oversized response that is not an image even when unverified previews are enabled', async () => {
    mockAllowUnverifiedNftPreviews.mockReturnValue(true);
    mockFetchBuffer.mockRejectedValue(
      new MaxSizeExceededError({
        'content-type': 'video/mp4',
      }),
    );

    await expect(nftGetImageDataUrl('https://example.com/large.mp4', '00')).resolves.toBeUndefined();
  });

  it('rejects on any other download failure', async () => {
    mockFetchBuffer.mockRejectedValue(new Error('Request timeout after 10000ms'));

    await expect(nftGetImageDataUrl('https://example.com/preview.png', '00')).resolves.toBeUndefined();
  });
});