emblem-vault-sdk 2.3.6 → 3.0.0-experimental

package/test/unit/AllowedOrdi.spec.js

@@ -0,0 +1,46 @@
+const { EmblemVaultSDK } = require('../../dist/index.js');
+const { expect } = require('chai');
+const fs = require('fs');
+const path = require('path');
+
+describe('Allowed Function for $ORDI', function() {
+    const sdk = new EmblemVaultSDK('DEMO_KEY');
+
+    it('Does not allow empty balance', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$ORDI');
+        expect(curatedContract.allowed(null, curatedContract)).to.be.false;
+        expect(curatedContract.allowed([], curatedContract)).to.be.false;
+    });
+
+    it('Requires specific balance', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$ORDI');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/ordi/balance.json")));
+        balanceValues[0].balance = curatedContract.balanceQty - 1;
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+        balanceValues[0].balance = curatedContract.balanceQty + 1;
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Requires specific name', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$ORDI');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/ordi/balance.json")));
+        balanceValues[0].name = `${curatedContract.balanceQty}`;
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+        balanceValues[0].name = '$ORDI';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+        balanceValues[0].name = `${curatedContract.balanceQty} $ORDI`;
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+
+    it('Allows non-ordi balance if not first', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$ORDI');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/ordi/balance-with-native.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+
+    it('Does not allow non-ordi balance as first value', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$ORDI');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/ordi/balance-with-native-first.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+});

package/test/unit/AllowedOxbt.spec.js

@@ -0,0 +1,46 @@
+const { EmblemVaultSDK } = require('../../dist/index.js');
+const { expect } = require('chai');
+const fs = require('fs');
+const path = require('path');
+
+describe('Allowed Function for $OXBT', function() {
+    const sdk = new EmblemVaultSDK('DEMO_KEY');
+
+    it('Does not allow empty balance', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$OXBT');
+        expect(curatedContract.allowed(null, curatedContract)).to.be.false;
+        expect(curatedContract.allowed([], curatedContract)).to.be.false;
+    });
+
+    it('Requires specific balance', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$OXBT');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/oxbt/balance.json")));
+        balanceValues[0].balance = curatedContract.balanceQty - 1;
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+        balanceValues[0].balance = curatedContract.balanceQty + 1;
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Requires specific name', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$OXBT');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/oxbt/balance.json")));
+        balanceValues[0].name = `${curatedContract.balanceQty}`;
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+        balanceValues[0].name = '$ORDI';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+        balanceValues[0].name = `${curatedContract.balanceQty} $OXBT`;
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+
+    it('Allows non-oxbt balance if not first', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$OXBT');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/oxbt/balance-with-native.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+
+    it('Does not allow non-oxbt balance as first value', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('$OXBT');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/oxbt/balance-with-native-first.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+});

package/test/unit/AllowedProjectCollection.spec.js

@@ -0,0 +1,51 @@
+const { EmblemVaultSDK } = require('../../dist/index.js');
+const { expect } = require('chai');
+const fs = require('fs');
+const path = require('path');
+
+describe('Allowed Function for project collections', function() {
+    const sdk = new EmblemVaultSDK('DEMO_KEY');
+
+    it('Does not allow empty balance', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('MegaPunks');
+        expect(curatedContract.allowed(null, curatedContract)).to.be.false;
+        expect(curatedContract.allowed([], curatedContract)).to.be.false;
+    });
+
+    it('Requires first asset to have coin matching collectionChain (case insensitive)', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('MegaPunks');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/megapunks/balance.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+        balanceValues[0].coin = balanceValues[0].coin.toUpperCase();
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+        balanceValues[0].coin = balanceValues[0].coin.toLowerCase();
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+        balanceValues[0].coin = 'invalid coin';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Requires project to match collection name', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('MegaPunks');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/megapunks/balance.json")));
+        balanceValues[0].project = 'invalid project';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Does not allow non collection assets if first', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('MegaPunks');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/megapunks/balance-with-non-megapunk-first.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Allows non collection assets if not first', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('MegaPunks');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/megapunks/balance-with-non-megapunk.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+
+    it('Allows valid balances', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('MegaPunks');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/megapunks/balance.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+});

package/test/unit/AllowedProtocolCollection.spec.js

@@ -0,0 +1,44 @@
+const { EmblemVaultSDK } = require('../../dist/index.js');
+const { expect } = require('chai');
+const fs = require('fs');
+const path = require('path');
+
+describe('Allowed Function for protocol collections', function() {
+    const sdk = new EmblemVaultSDK('DEMO_KEY');
+
+    it('Does not allow empty balance', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Dogeparty');
+        expect(curatedContract.allowed(null, curatedContract)).to.be.false;
+        expect(curatedContract.allowed([], curatedContract)).to.be.false;
+    });
+
+    it('Requires first asset to have coin matching collectionChain (case insensitive)', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Dogeparty');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/dogeparty/balance.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+        balanceValues[0].coin = balanceValues[0].coin.toUpperCase();
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+        balanceValues[0].coin = balanceValues[0].coin.toLowerCase();
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+        balanceValues[0].coin = 'invalid coin';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Does not allow non collection asset if first', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Dogeparty');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/dogeparty/balance-with-non-dogeparty-first.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Allows non collection assets if not first', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Dogeparty');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/dogeparty/balance-with-non-dogeparty.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+
+    it('Allows valid balances', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Dogeparty');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/dogeparty/balance.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+});

package/test/unit/AllowedStamps.spec.js

@@ -0,0 +1,78 @@
+const { EmblemVaultSDK } = require('../../dist/index.js');
+const { expect } = require('chai');
+const fs = require('fs');
+const path = require('path');
+
+describe('Allowed Function for Stamps', function() {
+    const sdk = new EmblemVaultSDK('DEMO_KEY');
+
+    it('Does not allow empty balance', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        expect(curatedContract.allowed(null, curatedContract)).to.be.false;
+        expect(curatedContract.allowed([], curatedContract)).to.be.false;
+    });
+
+    it('Requires asset name to include `stamps`', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/stamps/balance.json")));
+        balanceValues[0].name = 'invalid asset name';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Requires project name', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/stamps/balance.json")));
+        const originalProject = balanceValues[0].project;
+        // balanceValues[0].project = null;
+        delete balanceValues[0].project;
+        const result = curatedContract.allowed(balanceValues, curatedContract);
+        expect(result).to.be.false; // Check for any falsy value (false, null, undefined, 0, "")
+        // Restore the original project for future tests
+        balanceValues[0].project = originalProject;
+    });
+
+    it('Requires project name to be Stamps or Stampunks', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/stamps/balance.json")));
+        balanceValues[0].project = 'invalid project';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Allows case insensitive project name', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/stamps/balance.json")));
+        balanceValues[0].project = 'STAMPS';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+        balanceValues[0].project = 'STAMPUNKS';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+
+    it('Requires coin to be a native asset', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/stamps/balance.json")));
+        balanceValues[0].coin = 'invalid coin';
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+        for (var nativeAsset of curatedContract.nativeAssets) {
+            balanceValues[0].coin = nativeAsset;
+            expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+        }
+    });
+
+    it('Requires first asset to be a stamp', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/stamps/balance-with-non-stamps-first.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.false;
+    });
+
+    it('Allows non-stamps assets if not first', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/stamps/balance-with-non-stamps.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+
+    it('Allows valid balances', async () => {
+        const curatedContract = await sdk.fetchCuratedContractByName('Stamps');
+        const balanceValues = JSON.parse(fs.readFileSync(path.join(__dirname, "../fixtures/stamps/balance.json")));
+        expect(curatedContract.allowed(balanceValues, curatedContract)).to.be.true;
+    });
+});

package/test/unit/DarkfarmsMetadata.spec.js

@@ -0,0 +1,10 @@
+const { NFT_DATA } = require('../../dist/utils.js');
+const { expect } = require('chai');
+
+describe('Hardcoded Metadata for Darkfarms', function() {
+    it('NFT_DATA includes Darkfarms', async () => {
+        const token = NFT_DATA["BANKINISSAFE"];
+        expect(token).to.exist;
+        expect(token.projectName).to.equal("Darkfarms");
+    });
+});

package/test/unit/EmblemVaultSdk.spec.js

@@ -0,0 +1,188 @@
+/**
+ * Emblem Vault SDK Unit Tests
+ * Core functionality tests for the SDK
+ */
+
+const { EmblemVaultSDK } = require('../../dist/index');
+const { expect } = require('chai');
+
+// Test constants
+const API_KEY = 'DEMO_KEY';
+const TEST_ADDRESS = '0x0000000000000000000000000000000000000000';
+
+// We'll get the actual templates from the SDK rather than hardcoding them
+let mocks = {};
+
+/**
+ * Unit tests for the EmblemVaultSDK
+ * 
+ * Note: Tests that require live API calls have been moved to the integration test suite:
+ * - test/integration/ApiOperations.spec.js
+ * - test/integration/VaultCreation.spec.js
+ */
+describe('EmblemVaultSDK', () => {
+  describe('Non Writing Operations', () => {
+    let sdk = new EmblemVaultSDK(API_KEY);
+    
+    // before(() => {
+    //   sdk = new EmblemVaultSDK(API_KEY);
+    // });
+    
+    it('should create a valid SDK instance with an API key', () => {
+      expect(sdk).to.be.instanceOf(EmblemVaultSDK);
+    });
+
+    it('should throw an error when no API key is provided', () => {
+      expect(() => {
+        new EmblemVaultSDK('');
+      }).to.throw('API key is required');
+    });
+    
+    it('should get all asset metadata', () => {
+      const metadata = sdk.getAllAssetMetadata();
+      expect(metadata).to.be.an('array');
+      expect(metadata.length).to.be.greaterThan(0);
+      // Check that the metadata has the expected structure
+      expect(metadata[0]).to.have.property('projectName');
+    });
+    
+    it('should get all asset metadata using an override function', () => {
+      // Create a mock override function that returns predefined data
+      const mockData = [
+        { projectName: 'Project1', description: 'Description 1' },
+        { projectName: 'Project2', description: 'Description 2' },
+        { projectName: 'Project3', description: 'Description 3' }
+      ];
+      
+      const overrideFunc = () => mockData;
+      
+      // Call getAllAssetMetadata with the override function
+      const metadata = sdk.getAllAssetMetadata(overrideFunc);
+      
+      expect(metadata).to.be.an('array');
+      expect(metadata).to.deep.equal(mockData);
+      expect(metadata[0].projectName).to.equal('Project1');
+      expect(metadata[1].projectName).to.equal('Project2');
+      expect(metadata[2].projectName).to.equal('Project3');
+    });
+
+    it('should get asset metadata for a project', async () => {
+      // Create a mock override function that returns predefined data
+      // This is necessary because the real API might return unexpected data format
+      const mockData = {
+        "EVTESTCOMMON": {
+          "image": "https://emblem.finance/EVTESTCOMMON.gif",
+          "projectName": "Emblem Test"
+        },
+        "EVTESTEPIC": {
+          "image": "https://emblem.finance/EVTESTEPIC.gif",
+          "projectName": "Emblem Test"
+        },
+        "EVTESTLEGEND": {
+          "image": "https://emblem.finance/EVTESTLEGEND.jpg",
+          "projectName": "Emblem Test"
+        }
+      };
+      
+      const overrideFunc = () => mockData
+      
+      const metadata = await sdk.getAssetMetadata('Emblem Test', false, overrideFunc);
+      expect(metadata).to.be.an('array');
+      expect(metadata.length).to.equal(3);
+      expect(metadata[0].projectName).to.equal('Emblem Test');
+    });
+
+    it('should get asset metadata with case-insensitive matching by default', async () => {
+      // Create a mock override function that returns predefined data
+      const mockData = {
+        "EVTESTLEGEND": {
+          "image": "https://emblem.finance/EVTESTLEGEND.jpg",
+          "projectName": "CaseSensitive"
+        }
+      };
+      
+      const overrideFunc = () => mockData;
+      
+      // Call with different case but strict=false (default)
+      const metadata = await sdk.getAssetMetadata('casesensitive', false, overrideFunc);
+      
+      expect(metadata).to.be.an('array');
+      expect(metadata).to.have.lengthOf(1);
+      expect(metadata[0].projectName).to.equal('CaseSensitive');
+    });
+
+    it('should respect strict matching when specified', async () => {
+      // Create a mock override function that returns predefined data
+      const mockData = [
+        { projectName: 'CaseSensitive', description: 'This tests case sensitivity' }
+      ];
+      
+      const overrideFunc = async () => mockData;
+      
+      // Call with different case and strict=true
+      const metadata = await sdk.getAssetMetadata('casesensitive', true, overrideFunc);
+      
+      expect(metadata).to.be.an('array');
+      expect(metadata).to.have.lengthOf(0); // Should find nothing with strict matching
+    });
+
+    it('should get curated contracts', async () => {
+      const contracts = await sdk.fetchCuratedContracts();
+      expect(contracts).to.be.an('array');
+      expect(contracts.length).to.be.greaterThan(0);
+      
+      // Store contract templates for later tests
+      const emblemOpenContract = contracts.find(contract => contract.name === "EmblemOpen");
+      const bitcoinOrdinalsContract = contracts.find(contract => contract.name === "BitcoinOrdinals");
+      
+      if (emblemOpenContract) {
+        mocks.emblemopen_create_template = emblemOpenContract.generateCreateTemplate(emblemOpenContract);
+      }
+      
+      if (bitcoinOrdinalsContract) {
+        mocks.empty_create_template = bitcoinOrdinalsContract.generateCreateTemplate(bitcoinOrdinalsContract);
+      }
+    });
+  
+    it('should make template with functions', async () => {
+      const contracts = await sdk.fetchCuratedContracts();
+      expect(contracts[0]["generateVaultBody"]).to.be.a('function');
+    });
+  
+    it('should generate create template correctly for emblem open', async () => {
+      const contracts = await sdk.fetchCuratedContracts();
+      let contract = contracts.find(contract => contract.name === "EmblemOpen");
+      const template = contract?.generateCreateTemplate(contract);
+      
+      // Verify the template has the expected structure
+      expect(template).to.be.an('object');
+      expect(template).to.have.property('targetAsset');
+      expect(template.targetAsset).to.have.property('name');
+    });
+  
+    it('should generate create template correctly for empty', async () => {
+      const contracts = await sdk.fetchCuratedContracts();
+      let contract = contracts.find(contract => contract.name === "BitcoinOrdinals");
+      const template = contract?.generateCreateTemplate(contract);
+      
+      // Verify the template has the expected structure
+      expect(template).to.be.an('object');
+      expect(template).to.have.property('targetAsset');
+    });
+
+    it('should fetch metadata', async () => {
+      const metadata = await sdk.fetchMetadata("1337");
+      expect(metadata).to.be.an('object');
+      expect(metadata.name).to.equal("Patrick's Birthday Vault");
+    });
+
+    it('should fetch vaults of type', async () => {
+      const vaults = await sdk.fetchVaultsOfType("created", TEST_ADDRESS);
+      expect(vaults).to.be.an('array');
+      // todo: test for a non-zero value address
+      expect(vaults.length).to.be.at.least(0);
+    });
+  });
+  
+  // Note: Vault Creation tests have been moved to integration tests
+});