Feature resize images

.env.example

@@ -20,3 +20,5 @@ IPFS_PIN_JWT=asdf
 MAX_PROMISES_PER_MINUTE=1000
 IPFS_PIN_MAX_PROMISES_PER_MINUTE=60
 POSTGRAPHILE_SERVE_PORT=6001
+MAX_IMAGEMAGIC_PER_MINUTE=300
+MAX_CONCURRENT_IMAGEMAGIC=20

.vscode/settings.json

@@ -0,0 +1,2 @@
+{
+}

package.json

@@ -22,6 +22,7 @@
   "license": "ISC",
   "devDependencies": {
     "@babel/core": "^7.17.9",
+    "@types/imagemagick": "^0.0.31",
     "@types/lodash": "^4.14.181",
     "@types/node": "^17.0.35",
     "@types/prompt": "^1.1.2",
@@ -31,8 +32,8 @@
     "babel-plugin-module-resolver": "^4.1.0",
     "eslint": "^8.16.0",
     "eslint-import-resolver-babel-module": "^5.3.1",
-    "eslint-plugin-unused-imports": "^2.0.0",
     "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
     "nodemon": "^2.0.15",
     "ts-node": "^10.7.0",
     "typechain": "^8.0.0",
@@ -47,6 +48,8 @@
     "ethers": "^5.6.2",
     "graphql": "^16.3.0",
     "graphql-request": "^4.2.0",
+    "imagemagick": "^0.1.3",
+    "ipfs-http-client": "^56.0.3",
     "knex": "^1.0.7",
     "knex-dump": "^1.0.11",
     "lodash": "^4.17.21",
@@ -56,6 +59,7 @@
     "prompt": "^1.2.2",
     "slugify": "^1.6.5",
     "sqlite3": "^5.0.3",
+    "temp-dir": "^2.0.0",
     "yargs": "^17.4.0"
   }
-}
+}

src/clients/ethereum.ts

@@ -68,6 +68,7 @@ const init = async (): Promise<EthClient> => {
       const iface = new ethers.utils.Interface(MetaABI.abi);
       return events.map((event: ethers.Event) => ({
         ...iface.parseLog(event),
+        logIndex: BigNumber.from(event.logIndex).toString(),
         blockNumber: BigNumber.from(event.blockNumber).toString(),
         blockHash: event.blockHash,
         address: event.address

src/clients/sound.ts

@@ -1,19 +1,20 @@
 import { gql, GraphQLClient } from 'graphql-request';
 
 import { formatAddress } from '../types/address';
+import { ERC721NFT } from '../types/erc721nft';
 
 const soundAPI = new GraphQLClient(
   'https://api.sound.xyz/graphql',
 );
 
 const mapAPITrackToTrackID = (apiTrack: any): string => {
-  if(!apiTrack) {
+  if (!apiTrack) {
     throw new Error('Missing sound.xyz api track');
   }
-  if(!apiTrack.artist || !apiTrack.artist.artistContractAddress) {
+  if (!apiTrack.artist || !apiTrack.artist.artistContractAddress) {
     throw new Error('Missing sound.xyz api track artist');
   }
-  if(!apiTrack.editionId) {
+  if (!apiTrack.editionId) {
     throw new Error('Missing sound.xyz api track editionId');
   }
   return `ethereum/${formatAddress(apiTrack.artist.artistContractAddress)}/${apiTrack.editionId}`
@@ -44,10 +45,10 @@ const init = async () => {
   };
   const getAllMintedReleasesFunction = async (
   ): Promise<any[]> => {
-    const { getAllMintedReleases } = await soundAPI.request(
+    const { allMintedReleases } = await soundAPI.request(
       gql`
         {
-          getAllMintedReleases {
+          allMintedReleases {
               id
               createdAt
               title
@@ -80,8 +81,69 @@ const init = async () => {
       }
       `,
     );
-    return getAllMintedReleases;
+    return allMintedReleases;
   };
+
+  const getNFTTitle = (nft: ERC721NFT) => {
+    if (!nft.metadata) {
+      console.error({ nft })
+      throw new Error('Missing nft metadata');
+    }
+    if (!nft.metadata.name) {
+      console.error({ nft })
+      throw new Error('Missing name');
+    }
+    const splitName = nft.metadata.name.split('#');
+    if (splitName.length !== 2) {
+      console.error({ nft })
+      throw new Error('Name split by # failed');
+    }
+    return splitName[0].trim();
+  }
+
+  const nftMatchesTrack = (nft: ERC721NFT, apiTrack: any) => {
+    const sameArtistAsNFT = formatAddress(apiTrack.artist.artistContractAddress) === formatAddress(nft.contractAddress);
+    const sameTrackAsNFT = apiTrack.title.trim() === getNFTTitle(nft);
+    return sameArtistAsNFT && sameTrackAsNFT;
+  }
+
+  const fetchTracksByNFT = async (nfts: ERC721NFT[]) => {
+    const apiResponse = await getAllMintedReleasesFunction();
+    const apiTracks = apiResponse.map(apiTrack => ({
+      ...apiTrack,
+      trackId: mapAPITrackToTrackID(apiTrack),
+    }))
+
+    const filteredAPITracks = apiTracks.filter(apiTrack => {
+      const matchedNFT = nfts.find((nft: ERC721NFT) => nftMatchesTrack(nft, apiTrack));
+      return !!matchedNFT;
+    });
+    filteredAPITracks.forEach(apiTrack => {
+      if (apiTrack.tracks.length > 1) {
+        return { isError: true, error: new Error('Sound release with multiple tracks not yet implemented') };
+      }
+    });
+    const audioAPITrackPromises = filteredAPITracks.map(async apiTrack => {
+      return {
+        ...apiTrack,
+        tracks: [{
+          ...apiTrack.tracks[0],
+          audio: await audioFromTrack(apiTrack.tracks[0].id),
+        }]
+      };
+    });
+    const audioAPITracks = await Promise.all(audioAPITrackPromises);
+    return nfts.reduce((accum, nft) => {
+      const nftTrack = audioAPITracks.find(track => nftMatchesTrack(nft, track));
+      if (!nftTrack || !nftTrack.trackId) {
+        console.dir({ nftTrack, nft })
+        throw new Error('No track found for NFT')
+      }
+      accum[nft.id] = nftTrack.trackId;
+      return accum;
+    }, {} as any);
+  };
+
   const fetchTracksByTrackId = async (trackIds: string[]) => {
     const apiResponse = await getAllMintedReleasesFunction();
     const apiTracks = apiResponse.map(apiTrack => ({
@@ -106,10 +168,12 @@ const init = async () => {
     const audioAPITracks = await Promise.all(audioAPITrackPromises);
     return audioAPITracks;
   };
+
   return {
     audioFromTrack,
     getAllMintedReleases: getAllMintedReleasesFunction,
-    fetchTracksByTrackId
+    fetchTracksByTrackId,
+    fetchTracksByNFT
   };
 }
 

src/db/db.ts

@@ -1,9 +1,11 @@
 import { Knex } from 'knex';
+
 import { Cursor } from '../types/trigger'
 
 export enum Table {
   platforms = 'platforms',
   erc721nfts = 'erc721nfts',
+  erc721Transfers = 'erc721Transfers',
   artists = 'artists',
   artistProfiles = 'artistProfiles',
   processedTracks = 'processedTracks',
@@ -13,14 +15,15 @@ export enum Table {
   erc721nfts_processedTracks = 'erc721nfts_processedTracks',
   erc721nftProcessErrors = 'erc721nftProcessErrors',
   ipfsPins = 'ipfsPins',
+  processedArtworks = 'processedArtworks'
 }
 
 export type WhereFunc = 'where'
-| 'whereNull'
-| 'andWhere'
-| 'whereJsonPath'
-| 'whereNotNull'
-| 'whereIn';
+  | 'whereNull'
+  | 'andWhere'
+  | 'whereJsonPath'
+  | 'whereNotNull'
+  | 'whereIn';
 
 export type WhereField = 'and';
 

src/db/migrations/12-track-all-erc721-transfers.ts

@@ -0,0 +1,25 @@
+import { Knex } from 'knex';
+
+import { Table } from '../db';
+
+const tableConfig =
+{
+  name: Table.erc721Transfers, create: (table: Knex.CreateTableBuilder) => {
+    table.string('id').primary();
+    table.datetime('createdAtTime', { precision: 3 });
+    table.bigint('createdAtEthereumBlockNumber');
+    table.string('from');
+    table.string('to');
+    table.string('contractAddress');
+    table.string('tokenId');
+  }
+};
+
+export const up = async (knex: Knex) => {
+  await knex.schema.createTable(tableConfig.name, tableConfig.create);
+  await knex.raw(`GRANT SELECT ON "${Table.erc721Transfers}" TO ${process.env.POSTGRES_USERNAME_OPEN}`);
+};
+
+exports.down = async (knex: Knex) => {
+  await knex.schema.dropTable(tableConfig.name);
+}

src/db/migrations/20220528044344_processedArtworks.ts

@@ -0,0 +1,19 @@
+import { Knex } from 'knex';
+
+import { Table } from '../db';
+
+export const up = async (knex: Knex) => {
+  console.log('Running create contracts bootstrap');
+  await knex.schema.createTable(Table.processedArtworks, (table: Knex.CreateTableBuilder) => {
+    table.increments('id');
+    table.string('error');
+    table.string('size');
+    table.string('trackId');
+    table.string('cid');
+  });
+  await knex.raw(`GRANT SELECT ON "${Table.processedArtworks}" TO ${process.env.POSTGRES_USERNAME_OPEN}`);
+};
+
+exports.down = async (knex: Knex) => {
+  await knex.schema.dropTable(Table.processedArtworks);
+}

src/index.ts

@@ -6,16 +6,17 @@ import { Table } from './db/db';
 import db from './db/sql-db';
 import { addMetadataIPFSHashProcessor } from './processors/default/addMetadataIPFSHash';
 import { addMetadataObjectProcessor } from './processors/default/addMetadataObject';
-import { addTimestampToERC721NFTs } from './processors/default/addTimestampToERC721NFTs';
+import { addTimestampToERC721NFTs, addTimestampToERC721Transfers } from './processors/default/addTimestampToERC721NFTs';
 import { categorizeZora } from './processors/default/categorizeZora';
 import { createERC721ContractFromFactoryProcessor } from './processors/default/createERC721ContractFromFactoryProcessor';
 import { createERC721NFTsFromTransfersProcessor } from './processors/default/createERC721NFTsFromTransfersProcessor';
 import { createProcessedTracksFromAPI } from './processors/default/createProcessedTracksFromAPI';
 import { stripIgnoredNFTs, stripNonAudio } from './processors/default/deleter';
 import { getERC721ContractFieldsProcessor } from './processors/default/getERC721ContractFieldsProcessor';
 import { getERC721TokenFieldsProcessor } from './processors/default/getERC721TokenFieldsProcessor';
-import { ipfsAudioPinner, ipfsArtworkPinner } from './processors/default/ipfs';
+import { ipfsAudioPinner, ipfsArtworkPinner, ipfsProcessedArtworksPinner } from './processors/default/ipfs';
 import { processPlatformTracks } from './processors/default/processPlatformTracks';
+import { processTrackArtworks } from './processors/default/processTrackArtworks';
 import { runProcessors } from './runner';
 import { ERC721Contract, FactoryContract } from './types/ethereum';
 import { MusicPlatform } from './types/platform';
@@ -33,6 +34,7 @@ const PROCESSORS = (erc721Contracts: ERC721Contract[], factoryContracts: Factory
     getERC721ContractFieldsProcessor,
     erc721TransferProcessors,
     stripIgnoredNFTs,
+    addTimestampToERC721Transfers,
     addTimestampToERC721NFTs,
     getERC721TokenFieldsProcessor(erc721ContractsByAddress),
     addMetadataIPFSHashProcessor(erc721ContractsByAddress),
@@ -41,8 +43,10 @@ const PROCESSORS = (erc721Contracts: ERC721Contract[], factoryContracts: Factory
     categorizeZora,
     ...platformTrackProcessors,
     createProcessedTracksFromAPI('noizd'), //TODO: noizd here is being used both as platformId and MusicPlatformType. Need to bring in the full noizd platform object here and avoid mixing them
+    processTrackArtworks,
     ipfsAudioPinner,
     ipfsArtworkPinner,
+    ipfsProcessedArtworksPinner,
   ]
 };
 

src/processors/default/addTimestampToERC721NFTs.ts

@@ -2,28 +2,35 @@ import _ from 'lodash';
 
 import { Table } from '../../db/db';
 import { missingCreatedAtTime } from '../../triggers/missing';
-import { ERC721NFT } from '../../types/erc721nft';
 import { Clients } from '../../types/processor';
+import { Record } from '../../types/record';
 
-const processorFunction = async (items: ERC721NFT, clients: Clients) => {
-  const nftsByBlockNumber = _.groupBy(items, 'createdAtEthereumBlockNumber');
-  const blockNumbers = Object.keys(nftsByBlockNumber);
+const processorFunction = (table: Table) => async (items: Record, clients: Clients) => {
+  const recordsByBlockNumber = _.groupBy(items, 'createdAtEthereumBlockNumber');
+  const blockNumbers = Object.keys(recordsByBlockNumber);
+  console.log(`Processing until block ${blockNumbers[blockNumbers.length - 1]}`)
   const timestampsResponse = await clients.blocks.fetchBlockTimestamps(blockNumbers);
   const responseByBlockNumber = _.keyBy(timestampsResponse, 'number');
-  const nftUpdates: Partial<ERC721NFT>[] = [];
+  const recordUpdates: Partial<Record>[] = [];
   blockNumbers.forEach((blockNumber) => {
     const timestampMillis = BigInt(responseByBlockNumber[blockNumber].timestamp) * BigInt(1000);
-    const nfts: ERC721NFT[] = nftsByBlockNumber[blockNumber] as any;
-    nfts.forEach(nft => nftUpdates.push({
-      id: nft.id,
+    const records: Record[] = recordsByBlockNumber[blockNumber] as any;
+    records.forEach(record => recordUpdates.push({
+      id: record.id,
       createdAtTime: new Date(parseInt(timestampMillis.toString())),
     }));
   })
-  await clients.db.update(Table.erc721nfts, nftUpdates);
+  await clients.db.update(table, recordUpdates);
 };
 
 export const addTimestampToERC721NFTs = {
   name: 'addTimestampToERC721NFTs',
-  trigger: missingCreatedAtTime,
-  processorFunction: processorFunction,
+  trigger: missingCreatedAtTime(Table.erc721nfts),
+  processorFunction: processorFunction(Table.erc721nfts),
+};
+
+export const addTimestampToERC721Transfers = {
+  name: 'addTimestampToERC721Transfers',
+  trigger: missingCreatedAtTime(Table.erc721Transfers),
+  processorFunction: processorFunction(Table.erc721Transfers),
 };

src/processors/default/createERC721NFTsFromTransfersProcessor.ts

@@ -4,25 +4,36 @@ import _ from 'lodash';
 import { Table } from '../../db/db';
 import { newERC721Transfers } from '../../triggers/newNFTContractEvent';
 import { formatAddress } from '../../types/address';
-import { ERC721NFT } from '../../types/erc721nft';
+import { ERC721NFT, ERC721Transfer } from '../../types/erc721nft';
 import { ERC721Contract, ETHEREUM_NULL_ADDRESS, NFTContractTypes } from '../../types/ethereum';
 import { Clients, Processor } from '../../types/processor';
 import { Cursor } from '../../types/trigger';
 
 const NAME = 'createERC721NFTsFromTransfers';
 
+const CHAIN = 'ethereum';
+
 const processorFunction = (contracts: ERC721Contract[]) =>
   async ({ newCursor, items }: { newCursor: Cursor, items: ethers.Event[] }, clients: Clients) => {
     const contractsByAddress = _.keyBy(contracts, 'address');
     const newNFTs: Partial<ERC721NFT>[] = [];
     const updates: Partial<ERC721NFT>[] = [];
+    const transfers: Partial<ERC721Transfer>[] = [];
     items.forEach((item): Partial<ERC721NFT> | undefined => {
       const address = item.address;
       const contract = contractsByAddress[address];
       const contractTypeName = contract.contractType;
       const contractType = NFTContractTypes[contractTypeName];
       const tokenId = BigInt((item.args!.tokenId as BigNumber).toString());
       const newMint = item.args!.from === ETHEREUM_NULL_ADDRESS;
+      transfers.push({
+        id: `${CHAIN}/${item.blockNumber}/${item.logIndex}`,
+        contractAddress: formatAddress(contract.address),
+        from: item.args!.from,
+        to: item.args!.to,
+        tokenId,
+        createdAtEthereumBlockNumber: '' + item.blockNumber,
+      });
       if (!newMint) {
         updates.push({
           id: contractType.buildNFTId(contract.address, tokenId),
@@ -39,8 +50,9 @@ const processorFunction = (contracts: ERC721Contract[]) =>
         owner: item.args!.to
       });
     });
-    await clients.db.update(Table.erc721nfts, updates);
+    await clients.db.insert(Table.erc721Transfers, transfers);
     await clients.db.insert(Table.erc721nfts, newNFTs.filter(n => !!n));
+    await clients.db.update(Table.erc721nfts, updates);
     await clients.db.updateProcessor(NAME, newCursor);
   };