@aboutcircles/sdk-utils 0.1.0

package/dist/tests/abi.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=abi.test.d.ts.map

package/dist/tests/abi.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.test.d.ts","sourceRoot":"","sources":["../../src/tests/abi.test.ts"],"names":[],"mappings":""}

package/dist/tests/abi.test.js

@@ -0,0 +1,508 @@
+import { describe, test, expect } from 'bun:test';
+import { encodeFunctionData, decodeFunctionResult } from '../abi';
+import { encodeFunctionData as viemEncodeFunctionData, decodeFunctionResult as viemDecodeFunctionResult } from 'viem/utils';
+describe('encodeFunctionData', () => {
+    test('encodes function with no inputs', () => {
+        const abi = [
+            {
+                name: 'name',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [],
+                outputs: [{ type: 'string', name: '' }],
+            },
+        ];
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'name',
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'name',
+        });
+        expect(custom).toBe(viem);
+        expect(custom).toBe('0x06fdde03');
+    });
+    test('encodes function with single address input', () => {
+        const abi = [
+            {
+                name: 'balanceOf',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [{ type: 'address', name: 'account' }],
+                outputs: [{ type: 'uint256', name: '' }],
+            },
+        ];
+        const address = '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed';
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'balanceOf',
+            args: [address],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'balanceOf',
+            args: [address],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes function with uint256 input', () => {
+        const abi = [
+            {
+                name: 'transfer',
+                type: 'function',
+                stateMutability: 'nonpayable',
+                inputs: [
+                    { type: 'address', name: 'to' },
+                    { type: 'uint256', name: 'amount' },
+                ],
+                outputs: [{ type: 'bool', name: '' }],
+            },
+        ];
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'transfer',
+            args: ['0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed', 1000n],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'transfer',
+            args: ['0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed', 1000n],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes function with bool input', () => {
+        const abi = [
+            {
+                name: 'setApprovalForAll',
+                type: 'function',
+                stateMutability: 'nonpayable',
+                inputs: [
+                    { type: 'address', name: 'operator' },
+                    { type: 'bool', name: 'approved' },
+                ],
+                outputs: [],
+            },
+        ];
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'setApprovalForAll',
+            args: ['0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed', true],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'setApprovalForAll',
+            args: ['0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed', true],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes function with bytes32 input', () => {
+        const abi = [
+            {
+                name: 'setData',
+                type: 'function',
+                stateMutability: 'nonpayable',
+                inputs: [{ type: 'bytes32', name: 'data' }],
+                outputs: [],
+            },
+        ];
+        const bytes32Value = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'setData',
+            args: [bytes32Value],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'setData',
+            args: [bytes32Value],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes function with multiple uint types', () => {
+        const abi = [
+            {
+                name: 'multiUint',
+                type: 'function',
+                stateMutability: 'pure',
+                inputs: [
+                    { type: 'uint8', name: 'a' },
+                    { type: 'uint16', name: 'b' },
+                    { type: 'uint256', name: 'c' },
+                ],
+                outputs: [],
+            },
+        ];
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'multiUint',
+            args: [255, 65535, 123456789n],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'multiUint',
+            args: [255, 65535, 123456789n],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes function with string input', () => {
+        const abi = [
+            {
+                name: 'setName',
+                type: 'function',
+                stateMutability: 'nonpayable',
+                inputs: [{ type: 'string', name: 'newName' }],
+                outputs: [],
+            },
+        ];
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'setName',
+            args: ['Hello World'],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'setName',
+            args: ['Hello World'],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes function with fixed array input', () => {
+        const abi = [
+            {
+                name: 'setValues',
+                type: 'function',
+                stateMutability: 'nonpayable',
+                inputs: [{ type: 'uint256[3]', name: 'values' }],
+                outputs: [],
+            },
+        ];
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'setValues',
+            args: [[1n, 2n, 3n]],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'setValues',
+            args: [[1n, 2n, 3n]],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes function with dynamic array input', () => {
+        const abi = [
+            {
+                name: 'setDynamicValues',
+                type: 'function',
+                stateMutability: 'nonpayable',
+                inputs: [{ type: 'uint256[]', name: 'values' }],
+                outputs: [],
+            },
+        ];
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'setDynamicValues',
+            args: [[1n, 2n, 3n, 4n, 5n]],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'setDynamicValues',
+            args: [[1n, 2n, 3n, 4n, 5n]],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes function with mixed static and dynamic inputs', () => {
+        const abi = [
+            {
+                name: 'complexFunction',
+                type: 'function',
+                stateMutability: 'nonpayable',
+                inputs: [
+                    { type: 'address', name: 'addr' },
+                    { type: 'uint256', name: 'amount' },
+                    { type: 'string', name: 'message' },
+                ],
+                outputs: [],
+            },
+        ];
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'complexFunction',
+            args: ['0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed', 1000n, 'test'],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'complexFunction',
+            args: ['0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed', 1000n, 'test'],
+        });
+        expect(custom).toBe(viem);
+    });
+    test('encodes operateFlowMatrix function with complex nested tuples', () => {
+        const abi = [
+            {
+                type: 'function',
+                name: 'operateFlowMatrix',
+                inputs: [
+                    { name: '_flowVertices', type: 'address[]' },
+                    {
+                        name: '_flow',
+                        type: 'tuple[]',
+                        components: [
+                            { name: 'streamSinkId', type: 'uint16' },
+                            { name: 'amount', type: 'uint192' },
+                        ],
+                    },
+                    {
+                        name: '_streams',
+                        type: 'tuple[]',
+                        components: [
+                            { name: 'sourceCoordinate', type: 'uint16' },
+                            { name: 'flowEdgeIds', type: 'uint16[]' },
+                            { name: 'data', type: 'bytes' },
+                        ],
+                    },
+                    { name: '_packedCoordinates', type: 'bytes' },
+                ],
+                outputs: [],
+                stateMutability: 'nonpayable',
+            },
+        ];
+        const flowVertices = [
+            '0x1786712d8cbf16cb6bb1bcee04b499f0ab8a8b83',
+            '0xa63abf03d5c6ef8d56e1432277573c47cbe8a8a6',
+            '0xafeeb1c2ff5ee3757f106743142d2cd719116c72',
+            '0xc7d3df890952a327af94d5ba6fdc1bf145188a1b',
+            '0xcbdf2a2b2c7417ce9f10943d44d590058418ac00',
+            '0xd910d745a5b3da2e487864f39c777ef1362780a8',
+            '0xdcc6f30bc1b06b7523c364beffbf879475d140b6',
+            '0xf48554937f18885c7f15c432c596b5843648231d',
+        ];
+        const flow = [
+            { streamSinkId: 0, amount: 47518455000000000000n },
+            { streamSinkId: 1, amount: 47518455000000000000n },
+            { streamSinkId: 0, amount: 82656000000000000n },
+            { streamSinkId: 0, amount: 82656000000000000n },
+            { streamSinkId: 1, amount: 82656000000000000n },
+        ];
+        const streams = [
+            {
+                sourceCoordinate: 0,
+                flowEdgeIds: [1, 4],
+                data: '0x',
+            },
+        ];
+        const packedCoordinates = '0x000000000007000500070003000200000001000600010004000400040003';
+        const custom = encodeFunctionData({
+            abi,
+            functionName: 'operateFlowMatrix',
+            args: [flowVertices, flow, streams, packedCoordinates],
+        });
+        const viem = viemEncodeFunctionData({
+            abi,
+            functionName: 'operateFlowMatrix',
+            args: [flowVertices, flow, streams, packedCoordinates],
+        });
+        expect(custom).toBe(viem);
+    });
+});
+describe('decodeFunctionResult', () => {
+    test('decodes uint256 result', () => {
+        const abi = [
+            {
+                name: 'balanceOf',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [{ type: 'address', name: 'account' }],
+                outputs: [{ type: 'uint256', name: 'balance' }],
+            },
+        ];
+        const data = '0x00000000000000000000000000000000000000000000000000000000000003e8';
+        const custom = decodeFunctionResult({
+            abi,
+            functionName: 'balanceOf',
+            data,
+        });
+        const viem = viemDecodeFunctionResult({
+            abi,
+            functionName: 'balanceOf',
+            data,
+        });
+        expect(custom).toBe(viem);
+        expect(custom).toBe(1000n);
+    });
+    test('decodes address result', () => {
+        const abi = [
+            {
+                name: 'owner',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [],
+                outputs: [{ type: 'address', name: '' }],
+            },
+        ];
+        const data = '0x0000000000000000000000005aaeb6053f3e94c9b9a09f33669435e7ef1beaed';
+        const custom = decodeFunctionResult({
+            abi,
+            functionName: 'owner',
+            data,
+        });
+        const viem = viemDecodeFunctionResult({
+            abi,
+            functionName: 'owner',
+            data,
+        });
+        expect(custom).toBe(viem);
+        expect(custom).toBe('0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed');
+    });
+    test('decodes bool result', () => {
+        const abi = [
+            {
+                name: 'isApproved',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [],
+                outputs: [{ type: 'bool', name: '' }],
+            },
+        ];
+        const data = '0x0000000000000000000000000000000000000000000000000000000000000001';
+        const custom = decodeFunctionResult({
+            abi,
+            functionName: 'isApproved',
+            data,
+        });
+        const viem = viemDecodeFunctionResult({
+            abi,
+            functionName: 'isApproved',
+            data,
+        });
+        expect(custom).toBe(viem);
+        expect(custom).toBe(true);
+    });
+    test('decodes string result', () => {
+        const abi = [
+            {
+                name: 'name',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [],
+                outputs: [{ type: 'string', name: '' }],
+            },
+        ];
+        const data = '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000b48656c6c6f20576f726c64000000000000000000000000000000000000000000';
+        const custom = decodeFunctionResult({
+            abi,
+            functionName: 'name',
+            data,
+        });
+        const viem = viemDecodeFunctionResult({
+            abi,
+            functionName: 'name',
+            data,
+        });
+        expect(custom).toBe(viem);
+        expect(custom).toBe('Hello World');
+    });
+    test('decodes bytes32 result', () => {
+        const abi = [
+            {
+                name: 'getData',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [],
+                outputs: [{ type: 'bytes32', name: '' }],
+            },
+        ];
+        const data = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+        const custom = decodeFunctionResult({
+            abi,
+            functionName: 'getData',
+            data,
+        });
+        const viem = viemDecodeFunctionResult({
+            abi,
+            functionName: 'getData',
+            data,
+        });
+        expect(custom).toBe(viem);
+    });
+    test('decodes multiple outputs (tuple)', () => {
+        const abi = [
+            {
+                name: 'getInfo',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [],
+                outputs: [
+                    { type: 'address', name: 'addr' },
+                    { type: 'uint256', name: 'amount' },
+                    { type: 'bool', name: 'active' },
+                ],
+            },
+        ];
+        const data = '0x0000000000000000000000005aaeb6053f3e94c9b9a09f33669435e7ef1beaed00000000000000000000000000000000000000000000000000000000000003e80000000000000000000000000000000000000000000000000000000000000001';
+        const custom = decodeFunctionResult({
+            abi,
+            functionName: 'getInfo',
+            data,
+        });
+        const viem = viemDecodeFunctionResult({
+            abi,
+            functionName: 'getInfo',
+            data,
+        });
+        expect(custom).toEqual(viem);
+        expect(custom).toEqual([
+            '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed',
+            1000n,
+            true,
+        ]);
+    });
+    test('decodes dynamic array result', () => {
+        const abi = [
+            {
+                name: 'getValues',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [],
+                outputs: [{ type: 'uint256[]', name: '' }],
+            },
+        ];
+        const data = '0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000c8';
+        const custom = decodeFunctionResult({
+            abi,
+            functionName: 'getValues',
+            data,
+        });
+        const viem = viemDecodeFunctionResult({
+            abi,
+            functionName: 'getValues',
+            data,
+        });
+        expect(custom).toEqual(viem);
+        expect(custom).toEqual([10n, 20n, 200n]);
+    });
+    test('decodes fixed array result', () => {
+        const abi = [
+            {
+                name: 'getFixedValues',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [],
+                outputs: [{ type: 'uint256[3]', name: '' }],
+            },
+        ];
+        const data = '0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003';
+        const custom = decodeFunctionResult({
+            abi,
+            functionName: 'getFixedValues',
+            data,
+        });
+        const viem = viemDecodeFunctionResult({
+            abi,
+            functionName: 'getFixedValues',
+            data,
+        });
+        expect(custom).toEqual(viem);
+        expect(custom).toEqual([1n, 2n, 3n]);
+    });
+});

package/dist/tests/checksumAddress.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checksumAddress.test.d.ts.map

package/dist/tests/checksumAddress.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksumAddress.test.d.ts","sourceRoot":"","sources":["../../src/tests/checksumAddress.test.ts"],"names":[],"mappings":""}

package/dist/tests/checksumAddress.test.js

@@ -0,0 +1,93 @@
+import { describe, test, expect } from 'bun:test';
+import { checksumAddress } from '../abi';
+describe('checksumAddress', () => {
+    test('checksums lowercase address correctly', () => {
+        const lowercase = '0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed';
+        const expected = '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed';
+        expect(checksumAddress(lowercase)).toBe(expected);
+    });
+    test('checksums uppercase address correctly', () => {
+        const uppercase = '0X5AAEB6053F3E94C9B9A09F33669435E7EF1BEAED';
+        const expected = '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed';
+        expect(checksumAddress(uppercase)).toBe(expected);
+    });
+    test('checksums mixed case address correctly', () => {
+        const mixedCase = '0x5aAeB6053f3E94c9b9a09F33669435e7Ef1beAED';
+        const expected = '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed';
+        expect(checksumAddress(mixedCase)).toBe(expected);
+    });
+    test('handles address without 0x prefix', () => {
+        const withoutPrefix = '5aaeb6053f3e94c9b9a09f33669435e7ef1beaed';
+        const expected = '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed';
+        expect(checksumAddress(withoutPrefix)).toBe(expected);
+    });
+    test('checksums all-zero address', () => {
+        const zeroAddress = '0x0000000000000000000000000000000000000000';
+        const expected = '0x0000000000000000000000000000000000000000';
+        expect(checksumAddress(zeroAddress)).toBe(expected);
+    });
+    test('checksums real Ethereum addresses correctly', () => {
+        // Real addresses with known checksums
+        const testCases = [
+            {
+                input: '0xfb6916095ca1df60bb79ce92ce3ea74c37c5d359',
+                expected: '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
+            },
+            {
+                input: '0xdbf03b407c01e7cd3cbea99509d93f8dddc8c6fb',
+                expected: '0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB',
+            },
+            {
+                input: '0xd1220a0cf47c7b9be7a2e6ba89f429762e7b9adb',
+                expected: '0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb',
+            },
+            {
+                input: '0xc7d3df890952a327af94d5ba6fdc1bf145188a1b',
+                expected: '0xc7d3dF890952a327Af94D5Ba6fdC1Bf145188a1b',
+            },
+            {
+                input: '0xcbdf2a2b2c7417ce9f10943d44d590058418ac00',
+                expected: '0xCbdf2A2b2C7417CE9f10943d44D590058418Ac00',
+            },
+        ];
+        testCases.forEach(({ input, expected }) => {
+            expect(checksumAddress(input)).toBe(expected);
+        });
+    });
+    test('is idempotent - checksumming a checksummed address returns the same', () => {
+        const checksummed = '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed';
+        expect(checksumAddress(checksummed)).toBe(checksummed);
+        expect(checksumAddress(checksumAddress(checksummed))).toBe(checksummed);
+    });
+    test('handles addresses from contract deployments', () => {
+        // Common contract addresses
+        const contracts = [
+            {
+                input: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', // USDC
+                expected: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+            },
+            {
+                input: '0xdac17f958d2ee523a2206206994597c13d831ec7', // USDT
+                expected: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+            },
+        ];
+        contracts.forEach(({ input, expected }) => {
+            expect(checksumAddress(input)).toBe(expected);
+        });
+    });
+    test('validates EIP-55 checksumming algorithm', () => {
+        // Test vectors from EIP-55
+        const eip55TestVectors = [
+            '0x52908400098527886E0F7030069857D2E4169EE7',
+            '0x8617E340B3D01FA5F11F306F4090FD50E238070D',
+            '0xde709f2102306220921060314715629080e2fb77',
+            '0x27b1fdb04752bbc536007a920d24acb045561c26',
+        ];
+        eip55TestVectors.forEach((address) => {
+            // These addresses are already checksummed according to EIP-55
+            // So checksumming them should return the same address
+            const result = checksumAddress(address.toLowerCase());
+            expect(result).toBe(address);
+        });
+    });
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@aboutcircles/sdk-utils",
+  "version": "0.1.0",
+  "description": "Utility functions for Circles SDK including demurrage calculations and conversions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --format esm --splitting && tsc --emitDeclarationOnly",
+    "dev": "tsc --build --watch",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "circles",
+    "demurrage",
+    "converter",
+    "utils"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@aboutcircles/sdk-types": "*",
+    "multiformats": "^13.4.1"
+  }
+}