@nina-protocol/nina-db 0.0.106 → 0.0.107

package/dist/knexfile.js

@@ -2,6 +2,10 @@
  * @type { Object.<string, import("knex").Knex.Config> }
  */
 import "dotenv/config.js";
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 export default {
     development: {
         client: 'postgresql',

package/dist/migrations/20250714000001_release_publickey_mint_nullable.js

@@ -0,0 +1,18 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+export async function up(knex) {
+    await knex.schema.alterTable('releases', (table) => {
+        table.string('mint').nullable().alter();
+    });
+}
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+export async function down(knex) {
+    await knex.schema.alterTable('releases', (table) => {
+        table.string('mint').notNullable().alter();
+    });
+}

package/dist/migrations/20250723000000_add_releases_solana_address.js

@@ -0,0 +1,20 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+export const up = function (knex) {
+    return knex.schema.table('releases', table => {
+        table.string('solanaAddress').nullable();
+    }).then(() => {
+        return knex('releases').whereNotNull('mint').update('solanaAddress', knex.ref('publicKey'));
+    });
+};
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+export const down = function (knex) {
+    return knex.schema.table('releases', table => {
+        table.dropColumn('solanaAddress');
+    });
+};

package/dist/models/Release.js

@@ -13,39 +13,39 @@ import promiseRetry from 'promise-retry';
 import { customAlphabet } from 'nanoid';
 import { getTokenMetadata } from '@solana/spl-token';
 const ensureHttps = (uri) => {
-    if (!uri.startsWith('http://') && !uri.startsWith('https://')) {
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
         return `https://${uri}`;
     }
     return uri;
 };
-const alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
+const alphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
 const randomStringGenerator = customAlphabet(alphabet, 12);
 export default class Release extends Model {
-    static tableName = 'releases';
-    static idColumn = 'id';
+    static tableName = "releases";
+    static idColumn = "id";
     static jsonSchema = {
-        type: 'object',
-        required: ['publicKey', 'mint', 'metadata', 'datetime', 'slug', 'price'],
+        type: "object",
+        required: ["metadata", "datetime", "slug", "price"],
         properties: {
-            publicKey: { type: 'string' },
-            mint: { type: 'string' },
-            slug: { type: 'string' },
+            publicKey: { type: ["string"] },
+            mint: { type: "string" },
+            slug: { type: "string" },
             metadata: {
-                type: 'object',
-                required: ['name', 'symbol', 'description', 'image', 'properties',],
+                type: "object",
+                required: ["name", "symbol", "description", "image", "properties"],
                 properties: {
-                    name: { type: 'string' },
-                    symbol: { type: 'string' },
-                    description: { type: 'string' },
+                    name: { type: "string" },
+                    symbol: { type: "string" },
+                    description: { type: "string" },
                     properties: {
-                        type: 'object',
+                        type: "object",
                         properties: {
-                            artist: { type: 'string' },
-                            title: { type: 'string' },
-                            date: { type: 'string' },
-                            files: { type: 'array' },
-                            category: { type: 'string' },
-                            creators: { type: 'array' },
+                            artist: { type: "string" },
+                            title: { type: "string" },
+                            date: { type: "string" },
+                            files: { type: "array" },
+                            category: { type: "string" },
+                            creators: { type: "array" }
                         }
                     }
                 }
@@ -76,13 +76,13 @@ export default class Release extends Model {
                     return result;
                 }
                 catch (error) {
-                    console.log('error fetching release account', error);
+                    console.log("error fetching release account", error);
                     retry(error);
                 }
             }, {
                 retries: 50,
                 minTimeout: 500,
-                maxTimeout: 1500,
+                maxTimeout: 1500
             });
             let metadataAccount;
             if (programId === process.env.NINA_PROGRAM_V2_ID) {
@@ -92,14 +92,16 @@ export default class Release extends Model {
                 metadataAccount = (await metaplex.nfts().findAllByMintList({ mints: [releaseAccount.releaseMint] }, { commitment: 'confirmed' }))[0];
             }
             if (!metadataAccount) {
-                throw new Error('No metadata account found for release - is not a complete release');
+                throw new Error("No metadata account found for release - is not a complete release");
             }
             let json;
             try {
-                json = (await axios.get(ensureHttps(metadataAccount.uri.replace('www.', '').replace('arweave.net', 'gateway.irys.xyz')))).data;
+                json = (await axios.get(ensureHttps(metadataAccount.uri
+                    .replace("www.", "")
+                    .replace("arweave.net", "gateway.irys.xyz")))).data;
             }
             catch (error) {
-                json = (await axios.get(ensureHttps(metadataAccount.uri.replace('gateway.irys.xyz', 'arweave.net')))).data;
+                json = (await axios.get(ensureHttps(metadataAccount.uri.replace("gateway.irys.xyz", "arweave.net")))).data;
             }
             const slug = await this.generateSlug(json);
             let publisher = await Account.findOrCreate(releaseAccount.authority.toBase58());
@@ -116,21 +118,27 @@ export default class Release extends Model {
             if (hubPublicKey) {
                 const hub = await Hub.query().findOne({ publicKey: hubPublicKey });
                 await release.$query().patch({ hubId: hub.id });
-                await Hub.relatedQuery('releases').for(hub.id).patch({
-                    visible: true,
-                }).where({ id: release.id });
+                await Hub.relatedQuery("releases")
+                    .for(hub.id)
+                    .patch({
+                    visible: true
+                })
+                    .where({ id: release.id });
             }
             return release;
         }
         catch (error) {
-            console.log('error finding or creating release: ', error);
+            console.log("error finding or creating release: ", error);
             return null;
         }
     };
     static createRelease = async ({ publicKey, mint, metadata, datetime, publisherId, releaseAccount, programId }) => {
         const slug = await this.generateSlug(metadata);
-        const price = releaseAccount.account?.price?.toNumber() || releaseAccount?.price?.toNumber() || 0;
-        const paymentMint = releaseAccount.account?.paymentMint.toBase58() || releaseAccount?.paymentMint.toBase58();
+        const price = releaseAccount.account?.price?.toNumber() ||
+            releaseAccount?.price?.toNumber() ||
+            0;
+        const paymentMint = releaseAccount.account?.paymentMint.toBase58() ||
+            releaseAccount?.paymentMint.toBase58();
         const release = await Release.query().insertGraph({
             publicKey,
             mint,
@@ -146,7 +154,11 @@ export default class Release extends Model {
         if (metadata.properties.tags) {
             for await (let tag of metadata.properties.tags) {
                 const tagRecord = await Tag.findOrCreate(tag);
-                await Release.relatedQuery('tags').for(release.id).relate(tagRecord.id).onConflict(['tagId', 'releaseId']).ignore();
+                await Release.relatedQuery("tags")
+                    .for(release.id)
+                    .relate(tagRecord.id)
+                    .onConflict(["tagId", "releaseId"])
+                    .ignore();
             }
         }
         if (programId === process.env.NINA_PROGRAM_ID) {
@@ -159,19 +171,27 @@ export default class Release extends Model {
         const royaltyRecipients = releaseData.account?.royaltyRecipients || releaseData.royaltyRecipients;
         for await (let recipient of royaltyRecipients) {
             try {
-                if (recipient.recipientAuthority.toBase58() !== "11111111111111111111111111111111") {
+                if (recipient.recipientAuthority.toBase58() !==
+                    "11111111111111111111111111111111") {
                     const recipientAccount = await Account.findOrCreate(recipient.recipientAuthority.toBase58());
-                    const revenueShares = (await recipientAccount.$relatedQuery('revenueShares')).map(revenueShare => revenueShare.id);
-                    if (!revenueShares.includes(releaseRecord.id) && recipient.percentShare.toNumber() > 0) {
-                        await Account.relatedQuery('revenueShares').for(recipientAccount.id).relate(releaseRecord.id);
+                    const revenueShares = (await recipientAccount.$relatedQuery("revenueShares")).map((revenueShare) => revenueShare.id);
+                    if (!revenueShares.includes(releaseRecord.id) &&
+                        recipient.percentShare.toNumber() > 0) {
+                        await Account.relatedQuery("revenueShares")
+                            .for(recipientAccount.id)
+                            .relate(releaseRecord.id);
                     }
-                    else if (revenueShares.includes(releaseRecord.id) && recipient.percentShare.toNumber() === 0) {
-                        await Account.relatedQuery('revenueShares').for(recipientAccount.id).unrelate().where('id', releaseRecord.id);
+                    else if (revenueShares.includes(releaseRecord.id) &&
+                        recipient.percentShare.toNumber() === 0) {
+                        await Account.relatedQuery("revenueShares")
+                            .for(recipientAccount.id)
+                            .unrelate()
+                            .where("id", releaseRecord.id);
                     }
                 }
             }
             catch (error) {
-                console.log('error processing royaltyRecipients: ', error);
+                console.log("error processing royaltyRecipients: ", error);
             }
         }
     };
@@ -181,14 +201,15 @@ export default class Release extends Model {
             string = string.substring(0, 200);
         }
         const slug = string
-            .normalize('NFKD').replace(/[\u0300-\u036F]/g, '') // remove accents and convert to closest ascii equivalent
+            .normalize("NFKD")
+            .replace(/[\u0300-\u036F]/g, "") // remove accents and convert to closest ascii equivalent
             .toLowerCase() // convert to lowercase
-            .replace('-', '') // remove hyphens
-            .replace(/  +/g, ' ') // remove spaces 
-            .replace(/ /g, '-') // replace spaces with hyphens
-            .replace(/[^a-zA-Z0-9-]/g, '-') // replace non-alphanumeric characters with hyphens
-            .replace(/-+/g, '-') // replace multiple hyphens with single hyphen
-            .replace(/-$/, ''); // remove trailing hyphens
+            .replace("-", "") // remove hyphens
+            .replace(/  +/g, " ") // remove spaces
+            .replace(/ /g, "-") // replace spaces with hyphens
+            .replace(/[^a-zA-Z0-9-]/g, "-") // replace non-alphanumeric characters with hyphens
+            .replace(/-+/g, "-") // replace multiple hyphens with single hyphen
+            .replace(/-$/, ""); // remove trailing hyphens
         const existingRelease = await Release.query().findOne({ slug });
         if (existingRelease) {
             return `${slug}-${randomStringGenerator()}`;
@@ -196,13 +217,15 @@ export default class Release extends Model {
         return slug;
     };
     format = async () => {
-        const publisher = await this.$relatedQuery('publisher');
-        const publishedThroughHub = await this.$relatedQuery('publishedThroughHub');
+        const publisher = await this.$relatedQuery("publisher");
+        const publishedThroughHub = await this.$relatedQuery("publishedThroughHub");
         if (publishedThroughHub) {
             this.publishedThroughHub = publishedThroughHub.publicKey;
             this.hub = publishedThroughHub;
             delete this.hub.id;
-            const authority = await this.hub.$relatedQuery('authority').select('publicKey');
+            const authority = await this.hub
+                .$relatedQuery("authority")
+                .select("publicKey");
             this.hub.authority = authority.publicKey;
             delete this.hub.authorityId;
         }
@@ -212,93 +235,93 @@ export default class Release extends Model {
         delete this.publisherId;
         delete this.hubId;
         delete this.id;
-        stripHtmlIfNeeded(this.metadata, 'description');
+        stripHtmlIfNeeded(this.metadata, "description");
     };
     static relationMappings = () => ({
         publishedThroughHub: {
             relation: Model.BelongsToOneRelation,
             modelClass: Hub,
             join: {
-                from: 'releases.hubId',
-                to: 'hubs.id',
-            },
+                from: "releases.hubId",
+                to: "hubs.id"
+            }
         },
         publisher: {
             relation: Model.HasOneRelation,
             modelClass: Account,
             join: {
-                from: 'releases.publisherId',
-                to: 'accounts.id',
-            },
+                from: "releases.publisherId",
+                to: "accounts.id"
+            }
         },
         collectors: {
             relation: Model.ManyToManyRelation,
             modelClass: Account,
             join: {
-                from: 'releases.id',
+                from: "releases.id",
                 through: {
-                    from: 'releases_collected.releaseId',
-                    to: 'releases_collected.accountId',
+                    from: "releases_collected.releaseId",
+                    to: "releases_collected.accountId"
                 },
-                to: 'accounts.id',
-            },
+                to: "accounts.id"
+            }
         },
         exchanges: {
             relation: Model.HasManyRelation,
             modelClass: Exchange,
             join: {
-                from: 'releases.id',
-                to: 'exchanges.releaseId',
-            },
+                from: "releases.id",
+                to: "exchanges.releaseId"
+            }
         },
         hubs: {
             relation: Model.ManyToManyRelation,
             modelClass: Hub,
             join: {
-                from: 'releases.id',
+                from: "releases.id",
                 through: {
-                    from: 'hubs_releases.releaseId',
-                    to: 'hubs_releases.hubId',
-                    extra: ['hubReleasePublicKey'],
+                    from: "hubs_releases.releaseId",
+                    to: "hubs_releases.hubId",
+                    extra: ["hubReleasePublicKey"]
                 },
-                to: 'hubs.id',
-            },
+                to: "hubs.id"
+            }
         },
         posts: {
             relation: Model.ManyToManyRelation,
             modelClass: Post,
             join: {
-                from: 'releases.id',
+                from: "releases.id",
                 through: {
-                    from: 'posts_releases.releaseId',
-                    to: 'posts_releases.postId',
+                    from: "posts_releases.releaseId",
+                    to: "posts_releases.postId"
                 },
-                to: 'posts.id',
-            },
+                to: "posts.id"
+            }
         },
         revenueShareRecipients: {
             relation: Model.ManyToManyRelation,
             modelClass: Account,
             join: {
-                from: 'releases.id',
+                from: "releases.id",
                 through: {
-                    from: 'releases_revenue_share.releaseId',
-                    to: 'releases_revenue_share.accountId',
+                    from: "releases_revenue_share.releaseId",
+                    to: "releases_revenue_share.accountId"
                 },
-                to: 'accounts.id',
-            },
+                to: "accounts.id"
+            }
         },
         tags: {
             relation: Model.ManyToManyRelation,
             modelClass: Tag,
             join: {
-                from: 'releases.id',
+                from: "releases.id",
                 through: {
-                    from: 'tags_releases.releaseId',
-                    to: 'tags_releases.tagId',
+                    from: "tags_releases.releaseId",
+                    to: "tags_releases.tagId"
                 },
-                to: 'tags.id',
-            },
-        },
+                to: "tags.id"
+            }
+        }
     });
 }

package/dist/models/Transaction.js

@@ -20,6 +20,7 @@ class Transaction extends Model {
                 type: {
                     type: 'string',
                     enum: [
+                        'ReleaseInitAndPurchase',
                         'ReleaseInitV2',
                         'ReleaseUpdate',
                         'ExchangeAccept',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nina-protocol/nina-db",
-  "version": "0.0.106",
+  "version": "0.0.107",
   "description": "",
   "source": "src/index.js",
   "main": "dist/index.js",

package/src/knexfile.js

@@ -2,6 +2,11 @@
  * @type { Object.<string, import("knex").Knex.Config> }
  */
 import "dotenv/config.js";
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 export default {
   development: {

package/src/migrations/20250714000001_release_publickey_mint_nullable.js

@@ -0,0 +1,19 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+export async function up(knex) {
+  await knex.schema.alterTable('releases', (table) => {
+    table.string('mint').nullable().alter();
+  });
+}
+
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+export async function down(knex) {
+  await knex.schema.alterTable('releases', (table) => {
+    table.string('mint').notNullable().alter();
+  });
+} 

package/src/migrations/20250723000000_add_releases_solana_address.js

@@ -0,0 +1,21 @@
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+export const up = function(knex) {
+  return knex.schema.table('releases', table => {
+    table.string('solanaAddress').nullable();
+  }).then(() => {
+    return knex('releases').whereNotNull('mint').update('solanaAddress', knex.ref('publicKey'));
+  });
+};
+
+/**
+ * @param { import("knex").Knex } knex
+ * @returns { Promise<void> }
+ */
+export const down = function(knex) {
+  return knex.schema.table('releases', table => {
+    table.dropColumn('solanaAddress');
+  });
+};

package/src/models/Release.js

@@ -14,41 +14,41 @@ import { customAlphabet } from 'nanoid';
 import { getTokenMetadata } from '@solana/spl-token';
 
 const ensureHttps = (uri) => {
-  if (!uri.startsWith('http://') && !uri.startsWith('https://')) {
+  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
     return `https://${uri}`;
   }
   return uri;
 };
 
-const alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
+const alphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
 const randomStringGenerator = customAlphabet(alphabet, 12);
 export default class Release extends Model {
-  static tableName = 'releases';
-  
-  static idColumn = 'id';
+  static tableName = "releases";
+
+  static idColumn = "id";
   static jsonSchema = {
-    type: 'object',
-    required: ['publicKey', 'mint', 'metadata', 'datetime', 'slug', 'price'],
+    type: "object",
+    required: ["metadata", "datetime", "slug", "price"],
     properties: {
-      publicKey: { type: 'string' },
-      mint: { type: 'string' },
-      slug: { type: 'string' },
+      publicKey: { type: ["string"] },
+      mint: { type: "string" },
+      slug: { type: "string" },
       metadata: {
-        type: 'object',
-        required: ['name', 'symbol', 'description', 'image', 'properties',],
+        type: "object",
+        required: ["name", "symbol", "description", "image", "properties"],
         properties: {
-          name: { type: 'string' },
-          symbol: { type: 'string' },
-          description: { type: 'string' },
+          name: { type: "string" },
+          symbol: { type: "string" },
+          description: { type: "string" },
           properties: {
-            type: 'object',
+            type: "object",
             properties: {
-              artist: { type: 'string' },
-              title: { type: 'string' },
-              date: { type: 'string' },
-              files: { type: 'array' },
-              category: { type: 'string' },
-              creators: { type: 'array' },
+              artist: { type: "string" },
+              title: { type: "string" },
+              date: { type: "string" },
+              files: { type: "array" },
+              category: { type: "string" },
+              creators: { type: "array" }
             }
           }
         }
@@ -84,13 +84,14 @@ export default class Release extends Model {
             const result = await program.account[programModelName].fetch(new anchor.web3.PublicKey(publicKey), 'confirmed')
             return result
           } catch (error) {
-            console.log('error fetching release account', error)
-            retry(error)
+            console.log("error fetching release account", error);
+            retry(error);
           }
-        }, {
+        },
+        {
           retries: 50,
           minTimeout: 500,
-          maxTimeout: 1500,
+          maxTimeout: 1500
         }
       )
   
@@ -101,17 +102,35 @@ export default class Release extends Model {
         metadataAccount = (await metaplex.nfts().findAllByMintList({mints: [releaseAccount.releaseMint]}, { commitment: 'confirmed' }))[0];
       }
       if (!metadataAccount) {
-        throw new Error('No metadata account found for release - is not a complete release')
+        throw new Error(
+          "No metadata account found for release - is not a complete release"
+        );
       }
-      let json
+      let json;
       try {
-        json = (await axios.get(ensureHttps(metadataAccount.uri.replace('www.','').replace('arweave.net', 'gateway.irys.xyz')))).data
+        json = (
+          await axios.get(
+            ensureHttps(
+              metadataAccount.uri
+                .replace("www.", "")
+                .replace("arweave.net", "gateway.irys.xyz")
+            )
+          )
+        ).data;
       } catch (error) {
-        json = (await axios.get(ensureHttps(metadataAccount.uri.replace('gateway.irys.xyz', 'arweave.net')))).data
+        json = (
+          await axios.get(
+            ensureHttps(
+              metadataAccount.uri.replace("gateway.irys.xyz", "arweave.net")
+            )
+          )
+        ).data;
       }
-  
+
       const slug = await this.generateSlug(json);
-      let publisher = await Account.findOrCreate(releaseAccount.authority.toBase58());
+      let publisher = await Account.findOrCreate(
+        releaseAccount.authority.toBase58()
+      );
       release = await this.createRelease({
         publicKey,
         mint: programId === process.env.NINA_PROGRAM_V2_ID ? releaseAccount.mint.toBase58() : releaseAccount.releaseMint.toBase58(),
@@ -122,27 +141,34 @@ export default class Release extends Model {
         releaseAccount,
         programId,
       });
-  
+
       if (hubPublicKey) {
-  
-        const hub = await Hub.query().findOne({ publicKey: hubPublicKey })
-        await release.$query().patch({ hubId: hub.id })
-        await Hub.relatedQuery('releases').for(hub.id).patch({
-          visible: true,
-        }).where( {id: release.id });
+        const hub = await Hub.query().findOne({ publicKey: hubPublicKey });
+        await release.$query().patch({ hubId: hub.id });
+        await Hub.relatedQuery("releases")
+          .for(hub.id)
+          .patch({
+            visible: true
+          })
+          .where({ id: release.id });
       }
-  
-      return release;  
+
+      return release;
     } catch (error) {
-      console.log('error finding or creating release: ', error)
+      console.log("error finding or creating release: ", error);
       return null;
     }
-  }
+  };
 
   static createRelease = async ({publicKey, mint, metadata, datetime, publisherId, releaseAccount, programId}) => {
     const slug = await this.generateSlug(metadata);
-    const price = releaseAccount.account?.price?.toNumber() || releaseAccount?.price?.toNumber() || 0;
-    const paymentMint = releaseAccount.account?.paymentMint.toBase58() || releaseAccount?.paymentMint.toBase58();
+    const price =
+      releaseAccount.account?.price?.toNumber() ||
+      releaseAccount?.price?.toNumber() ||
+      0;
+    const paymentMint =
+      releaseAccount.account?.paymentMint.toBase58() ||
+      releaseAccount?.paymentMint.toBase58();
     const release = await Release.query().insertGraph({
       publicKey,
       mint,
@@ -158,7 +184,11 @@ export default class Release extends Model {
     if (metadata.properties.tags) {
       for await (let tag of metadata.properties.tags) {
         const tagRecord = await Tag.findOrCreate(tag);
-        await Release.relatedQuery('tags').for(release.id).relate(tagRecord.id).onConflict(['tagId', 'releaseId']).ignore();
+        await Release.relatedQuery("tags")
+          .for(release.id)
+          .relate(tagRecord.id)
+          .onConflict(["tagId", "releaseId"])
+          .ignore();
       }
     }
     if (programId === process.env.NINA_PROGRAM_ID) {
@@ -166,156 +196,177 @@ export default class Release extends Model {
     }
     tweetNewRelease(metadata, publisherId, slug);
     return release;
-  }
+  };
 
   static processRevenueShares = async (releaseData, releaseRecord) => {
-    const royaltyRecipients = releaseData.account?.royaltyRecipients || releaseData.royaltyRecipients
+    const royaltyRecipients =
+      releaseData.account?.royaltyRecipients || releaseData.royaltyRecipients;
     for await (let recipient of royaltyRecipients) {
       try {
-        if (recipient.recipientAuthority.toBase58() !== "11111111111111111111111111111111") {
-          const recipientAccount = await Account.findOrCreate(recipient.recipientAuthority.toBase58());
-          const revenueShares = (await recipientAccount.$relatedQuery('revenueShares')).map(revenueShare => revenueShare.id);
-          if (!revenueShares.includes(releaseRecord.id) && recipient.percentShare.toNumber() > 0) {
-            await Account.relatedQuery('revenueShares').for(recipientAccount.id).relate(releaseRecord.id);
-          } else if (revenueShares.includes(releaseRecord.id) && recipient.percentShare.toNumber() === 0) {
-            await Account.relatedQuery('revenueShares').for(recipientAccount.id).unrelate().where('id', releaseRecord.id);
+        if (
+          recipient.recipientAuthority.toBase58() !==
+          "11111111111111111111111111111111"
+        ) {
+          const recipientAccount = await Account.findOrCreate(
+            recipient.recipientAuthority.toBase58()
+          );
+          const revenueShares = (
+            await recipientAccount.$relatedQuery("revenueShares")
+          ).map((revenueShare) => revenueShare.id);
+          if (
+            !revenueShares.includes(releaseRecord.id) &&
+            recipient.percentShare.toNumber() > 0
+          ) {
+            await Account.relatedQuery("revenueShares")
+              .for(recipientAccount.id)
+              .relate(releaseRecord.id);
+          } else if (
+            revenueShares.includes(releaseRecord.id) &&
+            recipient.percentShare.toNumber() === 0
+          ) {
+            await Account.relatedQuery("revenueShares")
+              .for(recipientAccount.id)
+              .unrelate()
+              .where("id", releaseRecord.id);
           }
         }
       } catch (error) {
-        console.log('error processing royaltyRecipients: ', error)
+        console.log("error processing royaltyRecipients: ", error);
       }
     }
-  }
+  };
 
   static generateSlug = async (metadata) => {
-    let string = metadata.name
+    let string = metadata.name;
     if (string.length > 200) {
       string = string.substring(0, 200);
     }
     const slug = string
-      .normalize('NFKD').replace(/[\u0300-\u036F]/g, '') // remove accents and convert to closest ascii equivalent
+      .normalize("NFKD")
+      .replace(/[\u0300-\u036F]/g, "") // remove accents and convert to closest ascii equivalent
       .toLowerCase() // convert to lowercase
-      .replace('-', '') // remove hyphens
-      .replace(/  +/g, ' ') // remove spaces 
-      .replace(/ /g, '-') // replace spaces with hyphens
-      .replace(/[^a-zA-Z0-9-]/g, '-') // replace non-alphanumeric characters with hyphens
-      .replace(/-+/g,'-') // replace multiple hyphens with single hyphen
-      .replace(/-$/, '') // remove trailing hyphens
+      .replace("-", "") // remove hyphens
+      .replace(/  +/g, " ") // remove spaces
+      .replace(/ /g, "-") // replace spaces with hyphens
+      .replace(/[^a-zA-Z0-9-]/g, "-") // replace non-alphanumeric characters with hyphens
+      .replace(/-+/g, "-") // replace multiple hyphens with single hyphen
+      .replace(/-$/, ""); // remove trailing hyphens
 
     const existingRelease = await Release.query().findOne({ slug });
     if (existingRelease) {
       return `${slug}-${randomStringGenerator()}`;
     }
     return slug;
-    
-  }
+  };
 
   format = async () => {
-    const publisher = await this.$relatedQuery('publisher');
-    const publishedThroughHub = await this.$relatedQuery('publishedThroughHub');
+    const publisher = await this.$relatedQuery("publisher");
+    const publishedThroughHub = await this.$relatedQuery("publishedThroughHub");
     if (publishedThroughHub) {
       this.publishedThroughHub = publishedThroughHub.publicKey;
       this.hub = publishedThroughHub;
       delete this.hub.id;
-      const authority = await this.hub.$relatedQuery('authority').select('publicKey');
+      const authority = await this.hub
+        .$relatedQuery("authority")
+        .select("publicKey");
       this.hub.authority = authority.publicKey;
       delete this.hub.authorityId;
     }
     await publisher.format();
     this.publisher = publisher.publicKey;
     this.publisherAccount = publisher;
-    delete this.publisherId
-    delete this.hubId
-    delete this.id
+    delete this.publisherId;
+    delete this.hubId;
+    delete this.id;
 
-    stripHtmlIfNeeded(this.metadata, 'description');
-  }
+    stripHtmlIfNeeded(this.metadata, "description");
+  };
 
   static relationMappings = () => ({
     publishedThroughHub: {
       relation: Model.BelongsToOneRelation,
       modelClass: Hub,
       join: {
-        from: 'releases.hubId',
-        to: 'hubs.id',
-      },
+        from: "releases.hubId",
+        to: "hubs.id"
+      }
     },
     publisher: {
       relation: Model.HasOneRelation,
       modelClass: Account,
       join: {
-        from: 'releases.publisherId',
-        to: 'accounts.id',
-      },
+        from: "releases.publisherId",
+        to: "accounts.id"
+      }
     },
     collectors: {
       relation: Model.ManyToManyRelation,
       modelClass: Account,
       join: {
-        from: 'releases.id',
+        from: "releases.id",
         through: {
-          from: 'releases_collected.releaseId',
-          to: 'releases_collected.accountId',
+          from: "releases_collected.releaseId",
+          to: "releases_collected.accountId"
         },
-        to: 'accounts.id',
-      },
+        to: "accounts.id"
+      }
     },
     exchanges: {
       relation: Model.HasManyRelation,
       modelClass: Exchange,
       join: {
-        from: 'releases.id',
-        to: 'exchanges.releaseId',
-      },
+        from: "releases.id",
+        to: "exchanges.releaseId"
+      }
     },
     hubs: {
       relation: Model.ManyToManyRelation,
       modelClass: Hub,
       join: {
-        from: 'releases.id',
-        through : {
-          from: 'hubs_releases.releaseId',
-          to: 'hubs_releases.hubId',
-          extra: ['hubReleasePublicKey'],
+        from: "releases.id",
+        through: {
+          from: "hubs_releases.releaseId",
+          to: "hubs_releases.hubId",
+          extra: ["hubReleasePublicKey"]
         },
-        to: 'hubs.id',
-      },
+        to: "hubs.id"
+      }
     },
     posts: {
       relation: Model.ManyToManyRelation,
       modelClass: Post,
       join: {
-        from: 'releases.id',
-        through : {
-          from: 'posts_releases.releaseId',
-          to: 'posts_releases.postId',
+        from: "releases.id",
+        through: {
+          from: "posts_releases.releaseId",
+          to: "posts_releases.postId"
         },
-        to: 'posts.id',
-      },
+        to: "posts.id"
+      }
     },
     revenueShareRecipients: {
       relation: Model.ManyToManyRelation,
       modelClass: Account,
       join: {
-        from: 'releases.id',
+        from: "releases.id",
         through: {
-          from: 'releases_revenue_share.releaseId',
-          to: 'releases_revenue_share.accountId',
+          from: "releases_revenue_share.releaseId",
+          to: "releases_revenue_share.accountId"
         },
-        to: 'accounts.id',
-      },
+        to: "accounts.id"
+      }
     },
     tags: {
       relation: Model.ManyToManyRelation,
       modelClass: Tag,
       join: {
-        from: 'releases.id',
+        from: "releases.id",
         through: {
-          from: 'tags_releases.releaseId',
-          to: 'tags_releases.tagId',
+          from: "tags_releases.releaseId",
+          to: "tags_releases.tagId"
         },
-        to: 'tags.id',
-      },
-    },
-  })
+        to: "tags.id"
+      }
+    }
+  });
 }

package/src/models/Transaction.js

@@ -21,6 +21,7 @@ class Transaction extends Model {
         type: {
           type: 'string',
           enum: [
+            'ReleaseInitAndPurchase',
             'ReleaseInitV2',
             'ReleaseUpdate',
             'ExchangeAccept',