@ar.io/sdk 3.4.1 → 3.5.0-alpha.2

package/lib/cjs/types/ant.js

@@ -50,6 +50,7 @@ exports.AntKeywordsSchema = zod_1.z.array(zod_1.z.string()); // TODO: add specif
 exports.AntRecordSchema = zod_1.z.object({
     transactionId: exports.ArweaveTxIdSchema.describe('The Target ID of the undername'),
     ttlSeconds: zod_1.z.number(),
+    priority: zod_1.z.number().optional(),
 });
 exports.AntRecordsSchema = zod_1.z.record(zod_1.z.string(), exports.AntRecordSchema);
 exports.AntControllersSchema = zod_1.z.array(exports.ArweaveTxIdSchema.describe('Controller address'));

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_test_1 = require("node:test");
+const zod_1 = require("zod");
+const ant_js_1 = require("./ant.js");
+const stub_address = 'valid-address'.padEnd(43, '1');
+(0, node_test_1.describe)('ANT Schemas', () => {
+    (0, node_test_1.it)('should validate AntStateSchema', () => {
+        const validState = {
+            Name: 'TestToken',
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            Denomination: 0,
+            Owner: stub_address,
+            Controllers: [stub_address],
+            Records: {
+                record1: {
+                    transactionId: stub_address,
+                    ttlSeconds: 3600,
+                },
+            },
+            Balances: {
+                [stub_address]: 1,
+            },
+            Logo: stub_address,
+            TotalSupply: 1,
+            Initialized: true,
+        };
+        const invalidState = {
+            Name: 'TestToken',
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            Denomination: 0,
+            Owner: stub_address,
+            Controllers: [stub_address],
+            Records: {
+                record1: {
+                    transactionId: 'invalid-id',
+                    ttlSeconds: '3600',
+                },
+            },
+            Balances: {
+                [stub_address]: 1,
+            },
+            Logo: stub_address,
+            TotalSupply: -1,
+            Initialized: true,
+        };
+        node_assert_1.strict.doesNotThrow(() => ant_js_1.AntStateSchema.parse(validState));
+        node_assert_1.strict.throws(() => ant_js_1.AntStateSchema.parse(invalidState), zod_1.z.ZodError);
+    });
+    (0, node_test_1.it)('should validate AntInfoSchema', () => {
+        const validInfo = {
+            Name: 'TestToken',
+            Owner: stub_address,
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            ['Total-Supply']: '1',
+            Logo: stub_address,
+            Denomination: '0',
+            Handlers: ant_js_1.AntHandlerNames,
+        };
+        const invalidInfo = {
+            Name: 'TestToken',
+            Owner: stub_address,
+            Ticker: 'TST',
+            ['Total-Supply']: 1000,
+            Logo: stub_address,
+            Denomination: '1',
+            Handlers: ant_js_1.AntHandlerNames,
+        };
+        node_assert_1.strict.doesNotThrow(() => ant_js_1.AntInfoSchema.parse(validInfo));
+        node_assert_1.strict.throws(() => ant_js_1.AntInfoSchema.parse(invalidInfo), zod_1.z.ZodError);
+    });
+    (0, node_test_1.it)('should validate isAoANTState', () => {
+        const validState = {
+            Name: 'TestToken',
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            Denomination: 0,
+            Owner: stub_address,
+            Controllers: [stub_address],
+            Records: {
+                record1: {
+                    transactionId: stub_address,
+                    ttlSeconds: 3600,
+                },
+            },
+            Balances: {
+                [stub_address]: 1,
+            },
+            Logo: stub_address,
+            TotalSupply: 0,
+            Initialized: true,
+        };
+        const invalidState = {
+            Name: 'TestToken',
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            Denomination: 0,
+            Owner: stub_address,
+            Controllers: [stub_address],
+            Records: {
+                record1: {
+                    transactionId: 'invalid-id',
+                    ttlSeconds: '3600',
+                },
+            },
+            Balances: {
+                [stub_address]: 1,
+            },
+            Logo: stub_address,
+            TotalSupply: -1,
+            Initialized: true,
+        };
+        node_assert_1.strict.strictEqual((0, ant_js_1.isAoANTState)(validState), true);
+        node_assert_1.strict.strictEqual((0, ant_js_1.isAoANTState)(invalidState), false);
+    });
+});

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

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

package/lib/cjs/utils/ant.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortANTRecords = void 0;
+/**
+ * Sorts ANT records by priority and then lexicographically.
+ *
+ * Note: javascript guarantees that the order of objects in an object is persistent. Still, adding index to each record is useful for enforcing against undername limits.
+ *
+ * Reference: https://github.com/ar-io/ar-io-node/blob/e0a9ec56559cad1b3e35d668563871afb8649913/docs/madr/003-arns-undername-limits.md
+ *
+ * @param antRecords - The ANT records to sort.
+ */
+const sortANTRecords = (antRecords) => {
+    const sortedEntries = Object.entries(antRecords).sort(([a, aRecord], [b, bRecord]) => {
+        // '@' is the root name and should be resolved first
+        if (a === '@') {
+            return -1;
+        }
+        if (b === '@') {
+            return 1;
+        }
+        // if a record has a priority, it should be resolved before any other record without a priority
+        if ('priority' in aRecord && !('priority' in bRecord)) {
+            return -1;
+        }
+        if (!('priority' in aRecord) && 'priority' in bRecord) {
+            return 1;
+        }
+        // if both records have a priority, sort by priority and fallback to lexicographic sorting
+        if (aRecord.priority !== undefined && bRecord.priority !== undefined) {
+            if (aRecord.priority === bRecord.priority) {
+                return a.localeCompare(b);
+            }
+            return aRecord.priority - bRecord.priority;
+        }
+        // all other records are sorted lexicographically
+        return a.localeCompare(b);
+    });
+    // now that they are sorted, add the index to each record - this is their position in the sorted list and is used to enforce undername limits
+    return Object.fromEntries(sortedEntries.map(([a, aRecord], index) => [a, { ...aRecord, index }]));
+};
+exports.sortANTRecords = sortANTRecords;

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_test_1 = require("node:test");
+const ant_js_1 = require("./ant.js");
+(0, node_test_1.describe)('sortANTRecordsByPriority', () => {
+    (0, node_test_1.it)('should sort records by priority and then lexicographically', () => {
+        const records = {
+            undername1: { priority: 1, transactionId: 'test', ttlSeconds: 1 },
+            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 },
+            '@': { transactionId: 'test', ttlSeconds: 1 }, // always first, even if no priority
+        };
+        const sorted = (0, ant_js_1.sortANTRecords)(records);
+        node_assert_1.strict.deepStrictEqual(sorted, {
+            '@': { transactionId: 'test', ttlSeconds: 1, index: 0 }, // always first, even if no priority
+            undername1: {
+                priority: 1,
+                transactionId: 'test',
+                ttlSeconds: 1,
+                index: 1,
+            },
+            undername2: {
+                priority: 2,
+                transactionId: 'test',
+                ttlSeconds: 1,
+                index: 2,
+            },
+            undername3: {
+                priority: 3,
+                transactionId: 'test',
+                ttlSeconds: 1,
+                index: 3,
+            },
+            undername4: {
+                priority: 3,
+                transactionId: 'test',
+                ttlSeconds: 1,
+                index: 4,
+            },
+            undername5: {
+                priority: 100,
+                transactionId: 'test',
+                ttlSeconds: 1,
+                index: 5,
+            },
+            noPriority: { transactionId: 'test', ttlSeconds: 1, index: 6 },
+        });
+    });
+    (0, node_test_1.it)('should always return @ as the first record, regardless of priority', () => {
+        const records = {
+            '@': { priority: 5, transactionId: 'test', ttlSeconds: 1 }, //  priorities set on '@' are ignored, they are always first
+            undername1: { priority: 2, transactionId: 'test', ttlSeconds: 1 },
+        };
+        const sorted = (0, ant_js_1.sortANTRecords)(records);
+        node_assert_1.strict.deepStrictEqual(sorted, {
+            '@': { priority: 5, transactionId: 'test', ttlSeconds: 1, index: 0 },
+            undername1: {
+                priority: 2,
+                transactionId: 'test',
+                ttlSeconds: 1,
+                index: 1,
+            },
+        });
+    });
+});

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_test_1 = require("node:test");
+const base64_js_1 = require("./base64.js");
+(0, node_test_1.describe)('b64utils', () => {
+    (0, node_test_1.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 = (0, base64_js_1.toB64Url)(Buffer.from(str));
+            const decoded = (0, base64_js_1.fromB64Url)(encoded);
+            node_assert_1.strict.deepStrictEqual(decoded, Buffer.from(str), `Failed for string: ${str}`);
+        }
+    });
+    (0, node_test_1.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 = (0, base64_js_1.toB64Url)(buf);
+            const decoded = (0, base64_js_1.fromB64Url)(encoded);
+            node_assert_1.strict.deepStrictEqual(decoded, buf, `Failed for buffer: ${buf.toString()}`);
+        }
+    });
+    (0, node_test_1.it)('should handle edge cases for base64url conversion', () => {
+        const edgeCases = [
+            '',
+            'A',
+            'AA',
+            'AAA',
+            '====',
+            '===',
+            '==',
+            '=',
+            'A===',
+            'AA==',
+            'AAA=',
+        ];
+        for (const testCase of edgeCases) {
+            const encoded = (0, base64_js_1.toB64Url)(Buffer.from(testCase));
+            const decoded = Buffer.from((0, base64_js_1.fromB64Url)(encoded)).toString();
+            node_assert_1.strict.strictEqual(decoded, testCase, `Failed for edge case: ${testCase}`);
+        }
+    });
+    (0, node_test_1.it)('should generate random text', () => {
+        const randomText = (0, base64_js_1.getRandomText)();
+        const randomText2 = (0, base64_js_1.getRandomText)();
+        node_assert_1.strict.strictEqual(randomText.length, 32);
+        node_assert_1.strict.strictEqual(randomText2.length, 32);
+        node_assert_1.strict.notStrictEqual(randomText, randomText2);
+        const smallRandomText = (0, base64_js_1.getRandomText)(16);
+        const smallRandomText2 = (0, base64_js_1.getRandomText)(16);
+        node_assert_1.strict.strictEqual(smallRandomText.length, 16);
+        node_assert_1.strict.strictEqual(smallRandomText2.length, 16);
+        node_assert_1.strict.notStrictEqual(smallRandomText, smallRandomText2);
+    });
+});

package/lib/cjs/utils/index.js

@@ -35,3 +35,4 @@ __exportStar(require("./base64.js"), exports);
 __exportStar(require("./json.js"), exports);
 __exportStar(require("./processes.js"), exports);
 __exportStar(require("./schema.js"), exports);
+__exportStar(require("./ant.js"), exports);

package/lib/cjs/utils/utils.test.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_test_1 = require("node:test");
+const arweave_js_1 = require("./arweave.js");
+const index_js_1 = require("./index.js");
+(0, node_test_1.describe)('pruneTags', () => {
+    (0, node_test_1.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 = (0, arweave_js_1.pruneTags)(tags);
+        node_assert_1.strict.deepEqual(prunedTags, [
+            { name: 'Tag1', value: 'value1' },
+            { name: 'Tag3', value: 'value3' },
+        ]);
+    });
+    (0, node_test_1.it)('should return empty array when all tags have undefined values', () => {
+        const tags = [
+            { name: 'Tag1', value: undefined },
+            { name: 'Tag2', value: undefined },
+        ];
+        const prunedTags = (0, arweave_js_1.pruneTags)(tags);
+        node_assert_1.strict.deepEqual(prunedTags, []);
+    });
+    (0, node_test_1.it)('should return same array when no tags have undefined values', () => {
+        const tags = [
+            { name: 'Tag1', value: 'value1' },
+            { name: 'Tag2', value: 'value2' },
+        ];
+        const prunedTags = (0, arweave_js_1.pruneTags)(tags);
+        node_assert_1.strict.deepEqual(prunedTags, tags);
+    });
+    (0, node_test_1.it)('should return empty array with no tags', () => {
+        const tags = [];
+        const prunedTags = (0, arweave_js_1.pruneTags)(tags);
+        node_assert_1.strict.deepEqual(prunedTags, []);
+    });
+});
+(0, node_test_1.describe)('errorMessageFromOutput', () => {
+    (0, node_test_1.it)('should return error message from Error field', () => {
+        const output = {
+            Error: 'Error message',
+        };
+        const errorMessage = (0, index_js_1.errorMessageFromOutput)(output);
+        node_assert_1.strict.equal(errorMessage, 'Error message');
+    });
+    (0, node_test_1.it)('should return error message from Error tag', () => {
+        const output = {
+            Messages: [
+                {
+                    Tags: [{ name: 'Error', value: 'Error message' }],
+                },
+            ],
+        };
+        const errorMessage = (0, index_js_1.errorMessageFromOutput)(output);
+        node_assert_1.strict.equal(errorMessage, 'Error message');
+    });
+    (0, node_test_1.it)('should return error message from Error tag if Error field is undefined', () => {
+        const output = {
+            Messages: [
+                {
+                    Tags: [{ name: 'Error', value: 'Error message' }],
+                },
+            ],
+        };
+        const errorMessage = (0, index_js_1.errorMessageFromOutput)(output);
+        node_assert_1.strict.equal(errorMessage, 'Error message');
+    });
+    (0, node_test_1.it)('should return undefined if no error message is present', () => {
+        const output = {
+            Messages: [
+                {
+                    Tags: [{ name: 'Tag1', value: 'value1' }],
+                },
+            ],
+        };
+        const errorMessage = (0, index_js_1.errorMessageFromOutput)(output);
+        node_assert_1.strict.equal(errorMessage, undefined);
+    });
+    (0, node_test_1.it)('should return error message with line number', () => {
+        const output = {
+            Error: '[string "aos"]:123: Error message',
+        };
+        const errorMessage = (0, index_js_1.errorMessageFromOutput)(output);
+        node_assert_1.strict.equal(errorMessage, 'Error message (line 123)');
+    });
+    (0, node_test_1.it)('should return error message with line number and remove unicode', () => {
+        const output = {
+            Error: '[string "aos"]:123: Error message\u001b[0m',
+        };
+        const errorMessage = (0, index_js_1.errorMessageFromOutput)(output);
+        node_assert_1.strict.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';
+    (0, node_test_1.it)('should display a clean error for a known error message', () => {
+        const output = {
+            Error: knownErrorMessages,
+        };
+        const errorMessage = (0, index_js_1.errorMessageFromOutput)(output);
+        node_assert_1.strict.equal(errorMessage, 'Already registered (line 128)');
+    });
+});

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '3.4.1';
+exports.version = '3.5.0-alpha.2';

package/lib/esm/types/ant.js

@@ -47,6 +47,7 @@ export const AntKeywordsSchema = z.array(z.string()); // TODO: add specific limi
 export const AntRecordSchema = z.object({
     transactionId: ArweaveTxIdSchema.describe('The Target ID of the undername'),
     ttlSeconds: z.number(),
+    priority: z.number().optional(),
 });
 export const AntRecordsSchema = z.record(z.string(), AntRecordSchema);
 export const AntControllersSchema = z.array(ArweaveTxIdSchema.describe('Controller address'));

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

@@ -0,0 +1,123 @@
+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_address = 'valid-address'.padEnd(43, '1');
+describe('ANT Schemas', () => {
+    it('should validate AntStateSchema', () => {
+        const validState = {
+            Name: 'TestToken',
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            Denomination: 0,
+            Owner: stub_address,
+            Controllers: [stub_address],
+            Records: {
+                record1: {
+                    transactionId: stub_address,
+                    ttlSeconds: 3600,
+                },
+            },
+            Balances: {
+                [stub_address]: 1,
+            },
+            Logo: stub_address,
+            TotalSupply: 1,
+            Initialized: true,
+        };
+        const invalidState = {
+            Name: 'TestToken',
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            Denomination: 0,
+            Owner: stub_address,
+            Controllers: [stub_address],
+            Records: {
+                record1: {
+                    transactionId: 'invalid-id',
+                    ttlSeconds: '3600',
+                },
+            },
+            Balances: {
+                [stub_address]: 1,
+            },
+            Logo: stub_address,
+            TotalSupply: -1,
+            Initialized: true,
+        };
+        assert.doesNotThrow(() => AntStateSchema.parse(validState));
+        assert.throws(() => AntStateSchema.parse(invalidState), z.ZodError);
+    });
+    it('should validate AntInfoSchema', () => {
+        const validInfo = {
+            Name: 'TestToken',
+            Owner: stub_address,
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            ['Total-Supply']: '1',
+            Logo: stub_address,
+            Denomination: '0',
+            Handlers: AntHandlerNames,
+        };
+        const invalidInfo = {
+            Name: 'TestToken',
+            Owner: stub_address,
+            Ticker: 'TST',
+            ['Total-Supply']: 1000,
+            Logo: stub_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_address,
+            Controllers: [stub_address],
+            Records: {
+                record1: {
+                    transactionId: stub_address,
+                    ttlSeconds: 3600,
+                },
+            },
+            Balances: {
+                [stub_address]: 1,
+            },
+            Logo: stub_address,
+            TotalSupply: 0,
+            Initialized: true,
+        };
+        const invalidState = {
+            Name: 'TestToken',
+            Ticker: 'TST',
+            Description: 'Test description',
+            Keywords: ['keyword1', 'keyword2', 'keyword3'],
+            Denomination: 0,
+            Owner: stub_address,
+            Controllers: [stub_address],
+            Records: {
+                record1: {
+                    transactionId: 'invalid-id',
+                    ttlSeconds: '3600',
+                },
+            },
+            Balances: {
+                [stub_address]: 1,
+            },
+            Logo: stub_address,
+            TotalSupply: -1,
+            Initialized: true,
+        };
+        assert.strictEqual(isAoANTState(validState), true);
+        assert.strictEqual(isAoANTState(invalidState), false);
+    });
+});