Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
const { ethers } = require('hardhat');
const { expect } = require('chai');
const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
const { generators } = require('../helpers/random');
const { capitalize } = require('../../scripts/helpers');
const { TYPES } = require('../../scripts/generate/templates/Arrays.opts');
// See https://en.cppreference.com/w/cpp/algorithm/lower_bound
const lowerBound = (array, value) => {
const i = array.findIndex(element => value <= element);
return i === -1 ? array.length : i;
};
// See https://en.cppreference.com/w/cpp/algorithm/upper_bound
const upperBound = (array, value) => {
const i = array.findIndex(element => value < element);
return i === -1 ? array.length : i;
};
const bigintSign = x => (x > 0n ? 1 : x < 0n ? -1 : 0);
const comparator = (a, b) => bigintSign(ethers.toBigInt(a) - ethers.toBigInt(b));
const hasDuplicates = array => array.some((v, i) => array.indexOf(v) != i);
describe('Arrays', function () {
const fixture = async () => {
return { mock: await ethers.deployContract('$Arrays') };
};
beforeEach(async function () {
Object.assign(this, await loadFixture(fixture));
});
describe('search', function () {
for (const [title, { array, tests }] of Object.entries({
'Even number of elements': {
array: [11n, 12n, 13n, 14n, 15n, 16n, 17n, 18n, 19n, 20n],
tests: {
'basic case': 16n,
'first element': 11n,
'last element': 20n,
'searched value is over the upper boundary': 32n,
'searched value is under the lower boundary': 2n,
},
},
'Odd number of elements': {
array: [11n, 12n, 13n, 14n, 15n, 16n, 17n, 18n, 19n, 20n, 21n],
tests: {
'basic case': 16n,
'first element': 11n,
'last element': 21n,
'searched value is over the upper boundary': 32n,
'searched value is under the lower boundary': 2n,
},
},
'Array with gap': {
array: [11n, 12n, 13n, 14n, 15n, 20n, 21n, 22n, 23n, 24n],
tests: {
'search value in gap': 17n,
},
},
'Array with duplicated elements': {
array: [0n, 10n, 10n, 10n, 10n, 10n, 10n, 10n, 20n],
tests: {
'search value is duplicated': 10n,
},
},
'Array with duplicated first element': {
array: [10n, 10n, 10n, 10n, 10n, 10n, 10n, 20n],
tests: {
'search value is duplicated first element': 10n,
},
},
'Array with duplicated last element': {
array: [0n, 10n, 10n, 10n, 10n, 10n, 10n, 10n],
tests: {
'search value is duplicated last element': 10n,
},
},
'Empty array': {
array: [],
tests: {
'always returns 0 for empty array': 10n,
},
},
})) {
describe(title, function () {
const fixture = async () => {
return { instance: await ethers.deployContract('Uint256ArraysMock', [array]) };
};
beforeEach(async function () {
Object.assign(this, await loadFixture(fixture));
});
for (const [name, input] of Object.entries(tests)) {
describe(name, function () {
it('[deprecated] findUpperBound', async function () {
// findUpperBound does not support duplicated
if (hasDuplicates(array)) {
await expect(this.instance.findUpperBound(input)).to.eventually.equal(upperBound(array, input) - 1);
} else {
await expect(this.instance.findUpperBound(input)).to.eventually.equal(lowerBound(array, input));
}
});
it('lowerBound', async function () {
await expect(this.instance.lowerBound(input)).to.eventually.equal(lowerBound(array, input));
await expect(this.instance.lowerBoundMemory(array, input)).to.eventually.equal(lowerBound(array, input));
});
it('upperBound', async function () {
await expect(this.instance.upperBound(input)).to.eventually.equal(upperBound(array, input));
await expect(this.instance.upperBoundMemory(array, input)).to.eventually.equal(upperBound(array, input));
});
});
}
});
}
});
for (const { name, isValueType } of TYPES) {
const elements = Array.from({ length: 10 }, generators[name]);
describe(name, function () {
const fixture = async () => {
return { instance: await ethers.deployContract(`${capitalize(name)}ArraysMock`, [elements]) };
};
beforeEach(async function () {
Object.assign(this, await loadFixture(fixture));
});
if (isValueType) {
describe('sort', function () {
for (const length of [0, 1, 2, 8, 32, 128]) {
describe(`${name}[] of length ${length}`, function () {
beforeEach(async function () {
this.array = Array.from({ length }, generators[name]);
});
afterEach(async function () {
const expected = Array.from(this.array).sort(comparator);
const reversed = Array.from(expected).reverse();
await expect(this.instance.sort(this.array)).to.eventually.deep.equal(expected);
await expect(this.instance.sortReverse(this.array)).to.eventually.deep.equal(reversed);
});
it('sort array', async function () {
// nothing to do here, beforeEach and afterEach already take care of everything.
});
if (length > 1) {
it('sort array for identical elements', async function () {
// duplicate the first value to all elements
this.array.fill(this.array.at(0));
});
it('sort already sorted array', async function () {
// pre-sort the elements
this.array.sort(comparator);
});
it('sort reversed array', async function () {
// pre-sort in reverse order
this.array.sort(comparator).reverse();
});
it('sort almost sorted array', async function () {
// pre-sort + rotate (move the last element to the front) for an almost sorted effect
this.array.sort(comparator);
this.array.unshift(this.array.pop());
});
}
});
}
});
for (const fn of ['slice', 'splice']) {
const array = Array.from({ length: 10 }, generators[name]);
describe(fn, function () {
const fragment = `$${fn}(${name}[] arr, uint256 start)`;
const rangeFragment = `$${fn}(${name}[] arr, uint256 start, uint256 end)`;
it(`${fn} from start to end`, async function () {
const start = 2;
const end = 7;
await expect(this.mock[rangeFragment](array, start, end)).to.eventually.deep.equal(
array.slice(start, end),
);
});
it(`${fn} from start to end of array`, async function () {
const start = 3;
await expect(this.mock[fragment](array, start)).to.eventually.deep.equal(array.slice(start));
});
it(`${fn} entire array`, async function () {
await expect(this.mock[fragment](array, 0)).to.eventually.deep.equal(array);
await expect(this.mock[rangeFragment](array, 0, array.length)).to.eventually.deep.equal(array);
});
it(`${fn} empty range`, async function () {
await expect(this.mock[rangeFragment](array, 5, 5)).to.eventually.deep.equal([]);
await expect(this.mock[rangeFragment](array, 7, 3)).to.eventually.deep.equal([]);
});
it(`${fn} with out of bounds indices`, async function () {
// start beyond array length
await expect(this.mock[fragment](array, array.length + 5)).to.eventually.deep.equal([]);
// end beyond array length (should be truncated)
const start = 5;
await expect(this.mock[rangeFragment](array, start, array.length + 10)).to.eventually.deep.equal(
array.slice(start),
);
});
it(`${fn} empty array`, async function () {
const emptyArray = [];
await expect(this.mock[fragment](emptyArray, 0)).to.eventually.deep.equal([]);
await expect(this.mock[fragment](emptyArray, 5)).to.eventually.deep.equal([]);
await expect(this.mock[rangeFragment](emptyArray, 0, 5)).to.eventually.deep.equal([]);
});
it(`${fn} single element`, async function () {
const singleArray = [array[0]];
await expect(this.mock[fragment](singleArray, 0)).to.eventually.deep.equal(singleArray);
await expect(this.mock[fragment](singleArray, 1)).to.eventually.deep.equal([]);
await expect(this.mock[rangeFragment](singleArray, 0, 1)).to.eventually.deep.equal(singleArray);
});
});
}
}
describe('unsafeAccess', function () {
describe('storage', function () {
for (const i in elements) {
it(`unsafeAccess within bounds #${i}`, async function () {
await expect(this.instance.unsafeAccess(i)).to.eventually.equal(elements[i]);
});
}
it('unsafeAccess outside bounds', async function () {
await expect(this.instance.unsafeAccess(elements.length)).to.not.be.rejected;
});
it('unsafeSetLength changes the length or the array', async function () {
const newLength = generators.uint256();
await expect(this.instance.length()).to.eventually.equal(elements.length);
await expect(this.instance.unsafeSetLength(newLength)).to.not.be.rejected;
await expect(this.instance.length()).to.eventually.equal(newLength);
});
});
describe('memory', function () {
const fragment = `$unsafeMemoryAccess(${name}[] arr, uint256 pos)`;
for (const i in elements) {
it(`unsafeMemoryAccess within bounds #${i}`, async function () {
await expect(this.mock[fragment](elements, i)).to.eventually.equal(elements[i]);
});
}
it('unsafeMemoryAccess outside bounds', async function () {
await expect(this.mock[fragment](elements, elements.length)).to.not.be.rejected;
});
it('unsafeMemoryAccess loop around', async function () {
for (let i = 251n; i < 256n; ++i) {
await expect(this.mock[fragment](elements, 2n ** i - 1n)).to.eventually.equal(
isValueType ? BigInt(elements.length) : generators[name].zero,
);
await expect(this.mock[fragment](elements, 2n ** i + 0n)).to.eventually.equal(elements[0]);
await expect(this.mock[fragment](elements, 2n ** i + 1n)).to.eventually.equal(elements[1]);
}
});
});
});
});
}
});