@ar.io/sdk 3.12.0-alpha.1 → 3.12.0

package/lib/esm/types/ant.test.js

@@ -1,148 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, it } from 'node:test';
-import { z } from 'zod';
-import { AntHandlerNames, AntInfoSchema, AntStateSchema, isAoANTState, } from './ant.js';
-const stub_arweave_address = 'valid-address'.padEnd(43, '1');
-const stub_eth_address = '0x8B5f221c8837d862b818799e6b19cc23CE23B0E5';
-describe('ANT Schemas', () => {
-    it('should validate AntStateSchema', () => {
-        const validState = {
-            Name: 'TestToken',
-            Ticker: 'TST',
-            Description: 'Test description',
-            Keywords: ['keyword1', 'keyword2', 'keyword3'],
-            Denomination: 0,
-            Owner: stub_arweave_address,
-            Controllers: [stub_arweave_address],
-            Records: {
-                record1: {
-                    transactionId: stub_arweave_address,
-                    ttlSeconds: 3600,
-                },
-            },
-            Balances: {
-                [stub_arweave_address]: 1,
-            },
-            Logo: stub_arweave_address,
-            TotalSupply: 1,
-            Initialized: true,
-        };
-        const invalidState = {
-            Name: 'TestToken',
-            Ticker: 'TST',
-            Description: 'Test description',
-            Keywords: ['keyword1', 'keyword2', 'keyword3'],
-            Denomination: 0,
-            Owner: stub_arweave_address,
-            Controllers: [stub_arweave_address],
-            Records: {
-                record1: {
-                    transactionId: 'invalid-id',
-                    ttlSeconds: '3600',
-                },
-            },
-            Balances: {
-                [stub_arweave_address]: 1,
-            },
-            Logo: stub_arweave_address,
-            TotalSupply: -1,
-            Initialized: true,
-        };
-        assert.doesNotThrow(() => AntStateSchema.parse(validState));
-        assert.throws(() => AntStateSchema.parse(invalidState), z.ZodError);
-    });
-    it('should validate AntStateSchema with ETH address', () => {
-        const validState = {
-            Name: 'TestToken',
-            Ticker: 'TST',
-            Description: 'Test description',
-            Keywords: ['keyword1', 'keyword2', 'keyword3'],
-            Denomination: 0,
-            Owner: stub_eth_address,
-            Controllers: [stub_eth_address],
-            Records: {
-                record1: {
-                    transactionId: stub_arweave_address,
-                    ttlSeconds: 3600,
-                },
-            },
-            Balances: {
-                [stub_eth_address]: 1,
-            },
-            Logo: stub_arweave_address,
-            TotalSupply: 1,
-            Initialized: true,
-        };
-        assert.doesNotThrow(() => AntStateSchema.parse(validState));
-    });
-    it('should validate AntInfoSchema', () => {
-        const validInfo = {
-            Name: 'TestToken',
-            Owner: stub_arweave_address,
-            Ticker: 'TST',
-            Description: 'Test description',
-            Keywords: ['keyword1', 'keyword2', 'keyword3'],
-            ['Total-Supply']: '1',
-            Logo: stub_arweave_address,
-            Denomination: '0',
-            Handlers: AntHandlerNames,
-        };
-        const invalidInfo = {
-            Name: 'TestToken',
-            Owner: stub_arweave_address,
-            Ticker: 'TST',
-            ['Total-Supply']: 1000,
-            Logo: stub_arweave_address,
-            Denomination: '1',
-            Handlers: AntHandlerNames,
-        };
-        assert.doesNotThrow(() => AntInfoSchema.parse(validInfo));
-        assert.throws(() => AntInfoSchema.parse(invalidInfo), z.ZodError);
-    });
-    it('should validate isAoANTState', () => {
-        const validState = {
-            Name: 'TestToken',
-            Ticker: 'TST',
-            Description: 'Test description',
-            Keywords: ['keyword1', 'keyword2', 'keyword3'],
-            Denomination: 0,
-            Owner: stub_arweave_address,
-            Controllers: [stub_arweave_address],
-            Records: {
-                record1: {
-                    transactionId: stub_arweave_address,
-                    ttlSeconds: 3600,
-                },
-            },
-            Balances: {
-                [stub_arweave_address]: 1,
-            },
-            Logo: stub_arweave_address,
-            TotalSupply: 0,
-            Initialized: true,
-        };
-        const invalidState = {
-            Name: 'TestToken',
-            Ticker: 'TST',
-            Description: 'Test description',
-            Keywords: ['keyword1', 'keyword2', 'keyword3'],
-            Denomination: 0,
-            Owner: stub_arweave_address,
-            Controllers: [stub_arweave_address],
-            Records: {
-                record1: {
-                    transactionId: 'invalid-id',
-                    ttlSeconds: '3600',
-                },
-            },
-            Balances: {
-                [stub_arweave_address]: 1,
-            },
-            Logo: stub_arweave_address,
-            TotalSupply: -1,
-            Initialized: true,
-        };
-        assert.strictEqual(isAoANTState(validState), true);
-        assert.strictEqual(isAoANTState(invalidState), false);
-    });
-});

package/lib/esm/types/token.test.js

@@ -1,81 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, it } from 'node:test';
-import { ARIOToken, mARIOToken } from './token.js';
-describe('ARIOToken', () => {
-    it('should throw an error on invalid input', () => {
-        assert.throws(() => new ARIOToken(-1));
-    });
-    it('should round at 6 decimal places', () => {
-        const token = new ARIOToken(1.123456789);
-        assert.strictEqual(token.valueOf(), 1.123457);
-    });
-    it('should convert to mARIOToken', () => {
-        const token = new ARIOToken(1);
-        const mToken = token.toMARIO();
-        assert.strictEqual(mToken.valueOf(), 1000000);
-    });
-    it('should print as a string', () => {
-        const token = new ARIOToken(1);
-        assert.strictEqual(`${token}`, '1');
-    });
-});
-describe('mARIOToken', () => {
-    it('should multiply by a number', () => {
-        const token = new mARIOToken(1);
-        const result = token.multiply(2);
-        assert.strictEqual(result.valueOf(), 2);
-    });
-    it('should multiply by another mARIOToken', () => {
-        const token = new mARIOToken(1);
-        const result = token.multiply(new mARIOToken(2));
-        assert.strictEqual(result.valueOf(), 2);
-    });
-    it('should divide by a number', () => {
-        const token = new mARIOToken(2);
-        const result = token.divide(2);
-        assert.strictEqual(result.valueOf(), 1);
-    });
-    it('should divide by another mARIOToken', () => {
-        const token = new mARIOToken(2);
-        const result = token.divide(new mARIOToken(2));
-        assert.strictEqual(result.valueOf(), 1);
-    });
-    it('should throw an error on division by zero', () => {
-        const token = new mARIOToken(2);
-        assert.throws(() => token.divide(0));
-    });
-    it('should round down on multiplication of a number', () => {
-        const token = new mARIOToken(1);
-        const result = token.multiply(1.5);
-        assert.strictEqual(result.valueOf(), 1);
-    });
-    it('should round down on division with a number', () => {
-        const token = new mARIOToken(2);
-        const result = token.divide(3);
-        assert.strictEqual(result.valueOf(), 0);
-    });
-    it('should round down on division with another mARIOToken', () => {
-        const token = new mARIOToken(2);
-        const result = token.divide(new mARIOToken(3));
-        assert.strictEqual(result.valueOf(), 0);
-    });
-    it('should add', () => {
-        const token = new mARIOToken(1);
-        const result = token.plus(new mARIOToken(1));
-        assert.strictEqual(result.valueOf(), 2);
-    });
-    it('should subtract', () => {
-        const token = new mARIOToken(2);
-        const result = token.minus(new mARIOToken(1));
-        assert.strictEqual(result.valueOf(), 1);
-    });
-    it('should convert to ARIO', () => {
-        const token = new mARIOToken(1000000);
-        const result = token.toARIO();
-        assert.strictEqual(result.valueOf(), 1);
-    });
-    it('should print as a string', () => {
-        const token = new mARIOToken(1);
-        assert.strictEqual(`${token}`, '1');
-    });
-});

package/lib/esm/utils/ant.test.js

@@ -1,109 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, it } from 'node:test';
-import { sortANTRecords } from './ant.js';
-describe('sortANTRecordsByPriority', () => {
-    it('should sort records by priority and then lexicographically', () => {
-        const records = {
-            undername01: { priority: 1, transactionId: 'test', ttlSeconds: 1 }, // same priority, lexicographic sorting applied to the name
-            undername1: { priority: 1, transactionId: 'test', ttlSeconds: 1 },
-            undername11: { priority: 1, transactionId: 'test', ttlSeconds: 1 }, // same priority, lexicographic sorting applied to the name
-            undername2: { priority: 2, transactionId: 'test', ttlSeconds: 1 },
-            undername3: { priority: 3, transactionId: 'test', ttlSeconds: 1 }, // colliding priorities default to lexicographic sorting
-            undername4: { priority: 3, transactionId: 'test', ttlSeconds: 1 },
-            undername5: { priority: 100, transactionId: 'test', ttlSeconds: 1 }, // priority does not represent the index or position of the record, just the order of resolution relative to other records
-            noPriority: { transactionId: 'test', ttlSeconds: 1 },
-            noPriority01: { transactionId: 'test', ttlSeconds: 1 },
-            noPriority1: { transactionId: 'test', ttlSeconds: 1 },
-            noPriority11: { transactionId: 'test', ttlSeconds: 1 },
-            '@': { transactionId: 'test', ttlSeconds: 1 }, // always first, even if no priority
-        };
-        const sorted = sortANTRecords(records);
-        assert.deepStrictEqual(sorted, {
-            '@': { transactionId: 'test', ttlSeconds: 1, index: 0 }, // always first, even if no priority
-            undername01: {
-                priority: 1,
-                transactionId: 'test',
-                ttlSeconds: 1,
-                index: 1,
-            },
-            undername1: {
-                priority: 1,
-                transactionId: 'test',
-                ttlSeconds: 1,
-                index: 2,
-            },
-            undername11: {
-                priority: 1,
-                transactionId: 'test',
-                ttlSeconds: 1,
-                index: 3,
-            },
-            undername2: {
-                priority: 2,
-                transactionId: 'test',
-                ttlSeconds: 1,
-                index: 4,
-            },
-            undername3: {
-                priority: 3,
-                transactionId: 'test',
-                ttlSeconds: 1,
-                index: 5,
-            },
-            undername4: {
-                priority: 3,
-                transactionId: 'test',
-                ttlSeconds: 1,
-                index: 6,
-            },
-            undername5: {
-                priority: 100,
-                transactionId: 'test',
-                ttlSeconds: 1,
-                index: 7,
-            },
-            noPriority: { transactionId: 'test', ttlSeconds: 1, index: 8 },
-            noPriority01: { transactionId: 'test', ttlSeconds: 1, index: 9 },
-            noPriority1: { transactionId: 'test', ttlSeconds: 1, index: 10 },
-            noPriority11: { transactionId: 'test', ttlSeconds: 1, index: 11 },
-        });
-    });
-    it('should always return @ as the first, regardless of priority', () => {
-        const scenarios = [
-            {
-                records: {
-                    '@': { priority: 5, transactionId: 'test', ttlSeconds: 1 }, //  priorities set on '@' are ignored, they are always first
-                    undername1: { priority: 2, transactionId: 'test', ttlSeconds: 1 },
-                },
-                expected: {
-                    '@': { priority: 5, transactionId: 'test', ttlSeconds: 1, index: 0 },
-                    undername1: {
-                        priority: 2,
-                        transactionId: 'test',
-                        ttlSeconds: 1,
-                        index: 1,
-                    },
-                },
-            },
-            {
-                records: {
-                    '@': { transactionId: 'test', ttlSeconds: 1 }, // priority 0 is missing, but '@' is always first
-                    undername1: { priority: 2, transactionId: 'test', ttlSeconds: 1 },
-                },
-                expected: {
-                    '@': { transactionId: 'test', ttlSeconds: 1, index: 0 },
-                    undername1: {
-                        priority: 2,
-                        transactionId: 'test',
-                        ttlSeconds: 1,
-                        index: 1,
-                    },
-                },
-            },
-        ];
-        for (const scenario of scenarios) {
-            const sorted = sortANTRecords(scenario.records);
-            assert.deepStrictEqual(sorted, scenario.expected);
-        }
-    });
-});

package/lib/esm/utils/b64.test.js

@@ -1,70 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, it } from 'node:test';
-import { fromB64Url, getRandomText, toB64Url } from './base64.js';
-describe('b64utils', () => {
-    it('should convert various strings to base64url and back', () => {
-        const testStrings = [
-            'Hello, World!',
-            'Test123!@#',
-            'Base64URLEncoding',
-            'Special_Chars+/',
-            '',
-            'A',
-            '1234567890',
-        ];
-        for (const str of testStrings) {
-            const encoded = toB64Url(Buffer.from(str));
-            const decoded = fromB64Url(encoded);
-            assert.deepStrictEqual(decoded, Buffer.from(str), `Failed for string: ${str}`);
-        }
-    });
-    it('should convert various buffers to base64url and back', () => {
-        const testBuffers = [
-            Buffer.from('Hello, World!'),
-            Buffer.from([0, 1, 2, 3, 4, 5]),
-            Buffer.from('Test123!@#'),
-            Buffer.from('Base64URLEncoding'),
-            Buffer.from('Special_Chars+/'),
-            Buffer.alloc(0),
-            Buffer.from('A'),
-            Buffer.from('1234567890'),
-        ];
-        for (const buf of testBuffers) {
-            const encoded = toB64Url(buf);
-            const decoded = fromB64Url(encoded);
-            assert.deepStrictEqual(decoded, buf, `Failed for buffer: ${buf.toString()}`);
-        }
-    });
-    it('should handle edge cases for base64url conversion', () => {
-        const edgeCases = [
-            '',
-            'A',
-            'AA',
-            'AAA',
-            '====',
-            '===',
-            '==',
-            '=',
-            'A===',
-            'AA==',
-            'AAA=',
-        ];
-        for (const testCase of edgeCases) {
-            const encoded = toB64Url(Buffer.from(testCase));
-            const decoded = Buffer.from(fromB64Url(encoded)).toString();
-            assert.strictEqual(decoded, testCase, `Failed for edge case: ${testCase}`);
-        }
-    });
-    it('should generate random text', () => {
-        const randomText = getRandomText();
-        const randomText2 = getRandomText();
-        assert.strictEqual(randomText.length, 32);
-        assert.strictEqual(randomText2.length, 32);
-        assert.notStrictEqual(randomText, randomText2);
-        const smallRandomText = getRandomText(16);
-        const smallRandomText2 = getRandomText(16);
-        assert.strictEqual(smallRandomText.length, 16);
-        assert.strictEqual(smallRandomText2.length, 16);
-        assert.notStrictEqual(smallRandomText, smallRandomText2);
-    });
-});

package/lib/esm/utils/url.test.js

@@ -1,19 +0,0 @@
-import assert from 'node:assert';
-import { test } from 'node:test';
-import { urlWithSearchParams } from './url.js';
-test('urlWithSearchParams prunes undefined values but keeps other falsey values', () => {
-    const result = urlWithSearchParams({
-        baseUrl: 'https://example.com',
-        params: {
-            number: 1,
-            string: 'string',
-            boolean: true,
-            empty: '',
-            zero: 0,
-            false: false,
-            null: null,
-            undef: undefined,
-        },
-    });
-    assert.strictEqual(result, 'https://example.com/?number=1&string=string&boolean=true&empty=&zero=0&false=false');
-});

package/lib/esm/utils/utils.test.js

@@ -1,192 +0,0 @@
-import { strict as assert } from 'node:assert';
-import { describe, it } from 'node:test';
-import { errorMessageFromOutput } from './ao.js';
-import { pruneTags, sortAndPaginateEpochDataIntoEligibleDistributions, } from './arweave.js';
-describe('pruneTags', () => {
-    it('should remove tags with undefined values', () => {
-        const tags = [
-            { name: 'Tag1', value: 'value1' },
-            { name: 'Tag2', value: undefined },
-            { name: 'Tag3', value: 'value3' },
-            { name: 'Tag4', value: undefined },
-        ];
-        const prunedTags = pruneTags(tags);
-        assert.deepEqual(prunedTags, [
-            { name: 'Tag1', value: 'value1' },
-            { name: 'Tag3', value: 'value3' },
-        ]);
-    });
-    it('should return empty array when all tags have undefined values', () => {
-        const tags = [
-            { name: 'Tag1', value: undefined },
-            { name: 'Tag2', value: undefined },
-        ];
-        const prunedTags = pruneTags(tags);
-        assert.deepEqual(prunedTags, []);
-    });
-    it('should return same array when no tags have undefined values', () => {
-        const tags = [
-            { name: 'Tag1', value: 'value1' },
-            { name: 'Tag2', value: 'value2' },
-        ];
-        const prunedTags = pruneTags(tags);
-        assert.deepEqual(prunedTags, tags);
-    });
-    it('should return empty array with no tags', () => {
-        const tags = [];
-        const prunedTags = pruneTags(tags);
-        assert.deepEqual(prunedTags, []);
-    });
-});
-describe('errorMessageFromOutput', () => {
-    it('should return error message from Error field', () => {
-        const output = {
-            Error: 'Error message',
-        };
-        const errorMessage = errorMessageFromOutput(output);
-        assert.equal(errorMessage, 'Error message');
-    });
-    it('should return error message from Error tag', () => {
-        const output = {
-            Messages: [
-                {
-                    Tags: [{ name: 'Error', value: 'Error message' }],
-                },
-            ],
-        };
-        const errorMessage = errorMessageFromOutput(output);
-        assert.equal(errorMessage, 'Error message');
-    });
-    it('should return error message from Error tag if Error field is undefined', () => {
-        const output = {
-            Messages: [
-                {
-                    Tags: [{ name: 'Error', value: 'Error message' }],
-                },
-            ],
-        };
-        const errorMessage = errorMessageFromOutput(output);
-        assert.equal(errorMessage, 'Error message');
-    });
-    it('should return undefined if no error message is present', () => {
-        const output = {
-            Messages: [
-                {
-                    Tags: [{ name: 'Tag1', value: 'value1' }],
-                },
-            ],
-        };
-        const errorMessage = errorMessageFromOutput(output);
-        assert.equal(errorMessage, undefined);
-    });
-    it('should return error message with line number', () => {
-        const output = {
-            Error: '[string "aos"]:123: Error message',
-        };
-        const errorMessage = errorMessageFromOutput(output);
-        assert.equal(errorMessage, 'Error message (line 123)');
-    });
-    it('should return error message with line number and remove unicode', () => {
-        const output = {
-            Error: '[string "aos"]:123: Error message\u001b[0m',
-        };
-        const errorMessage = errorMessageFromOutput(output);
-        assert.equal(errorMessage, 'Error message (line 123)');
-    });
-    const knownErrorMessages = '\u001b[31mError\u001b[90m handling message with Action = Register\u001b[0m\n\u001b[32m[string ".handlers"]:723: [string "aos"]:128: Already registered\u001b[0m\n\n\u001b[90mstack traceback:\n\t[string ".process"]:871: in function \'.process.handle\'\u001b[0m\n\n\u001b[31merror:\n\u001b[0m[string ".handlers"]:723: [string "aos"]:128: Already registered';
-    it('should display a clean error for a known error message', () => {
-        const output = {
-            Error: knownErrorMessages,
-        };
-        const errorMessage = errorMessageFromOutput(output);
-        assert.equal(errorMessage, 'Already registered (line 128)');
-    });
-});
-describe('sortAndPaginateEpochDataIntoEligibleDistributions', () => {
-    const mockEpochData = {
-        distributions: {
-            distributedTimestamp: 1234567890,
-            rewards: {
-                eligible: {
-                    gateway1: {
-                        operatorReward: 50,
-                        delegateRewards: {
-                            delegate1: 20,
-                            delegate2: 30,
-                        },
-                    },
-                    gateway2: {
-                        operatorReward: 70,
-                        delegateRewards: {
-                            delegate3: 40,
-                        },
-                    },
-                },
-            },
-        },
-    };
-    it('sorts rewards in descending order by eligibleReward', () => {
-        const result = sortAndPaginateEpochDataIntoEligibleDistributions(mockEpochData);
-        assert.deepEqual(result.items, [
-            {
-                type: 'operatorReward',
-                recipient: 'gateway2',
-                eligibleReward: 70,
-                cursorId: 'gateway2_gateway2',
-                gatewayAddress: 'gateway2',
-            },
-            {
-                type: 'operatorReward',
-                recipient: 'gateway1',
-                eligibleReward: 50,
-                cursorId: 'gateway1_gateway1',
-                gatewayAddress: 'gateway1',
-            },
-            {
-                type: 'delegateReward',
-                recipient: 'delegate3',
-                eligibleReward: 40,
-                cursorId: 'gateway2_delegate3',
-                gatewayAddress: 'gateway2',
-            },
-            {
-                type: 'delegateReward',
-                recipient: 'delegate2',
-                eligibleReward: 30,
-                cursorId: 'gateway1_delegate2',
-                gatewayAddress: 'gateway1',
-            },
-            {
-                type: 'delegateReward',
-                recipient: 'delegate1',
-                eligibleReward: 20,
-                cursorId: 'gateway1_delegate1',
-                gatewayAddress: 'gateway1',
-            },
-        ]);
-    });
-    it('supports sorting in ascending order', () => {
-        const result = sortAndPaginateEpochDataIntoEligibleDistributions(mockEpochData, {
-            sortOrder: 'asc',
-        });
-        assert.equal(result.items[0].eligibleReward, 20);
-        assert.equal(result.items[result.items.length - 1].eligibleReward, 70);
-    });
-    it('paginates results correctly', () => {
-        const result = sortAndPaginateEpochDataIntoEligibleDistributions(mockEpochData, {
-            limit: 2,
-        });
-        assert.equal(result.items.length, 2);
-        assert.equal(result.hasMore, true);
-        assert.equal(result.nextCursor, 'gateway2_delegate3');
-    });
-    it('resumes pagination from cursor', () => {
-        const firstPage = sortAndPaginateEpochDataIntoEligibleDistributions(mockEpochData, { limit: 2 });
-        const secondPage = sortAndPaginateEpochDataIntoEligibleDistributions(mockEpochData, {
-            limit: 2,
-            cursor: firstPage.nextCursor,
-        });
-        assert.equal(secondPage.items.length, 2);
-        assert.equal(secondPage.items[0].cursorId, 'gateway1_delegate2');
-    });
-});

package/lib/types/types/ant.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/types/token.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/utils/ant.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/utils/b64.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/utils/url.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/utils/utils.test.d.ts

@@ -1 +0,0 @@
-export {};