@coral-xyz/anchor
Version:
Anchor client
419 lines • 17.2 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.IdlCoder = void 0;
const borsh = __importStar(require("@coral-xyz/borsh"));
const idl_js_1 = require("../../idl.js");
const error_js_1 = require("../../error.js");
class IdlCoder {
static fieldLayout(field, types = [], genericArgs) {
const fieldName = field.name;
switch (field.type) {
case "bool": {
return borsh.bool(fieldName);
}
case "u8": {
return borsh.u8(fieldName);
}
case "i8": {
return borsh.i8(fieldName);
}
case "u16": {
return borsh.u16(fieldName);
}
case "i16": {
return borsh.i16(fieldName);
}
case "u32": {
return borsh.u32(fieldName);
}
case "i32": {
return borsh.i32(fieldName);
}
case "f32": {
return borsh.f32(fieldName);
}
case "u64": {
return borsh.u64(fieldName);
}
case "i64": {
return borsh.i64(fieldName);
}
case "f64": {
return borsh.f64(fieldName);
}
case "u128": {
return borsh.u128(fieldName);
}
case "i128": {
return borsh.i128(fieldName);
}
case "u256": {
return borsh.u256(fieldName);
}
case "i256": {
return borsh.i256(fieldName);
}
case "bytes": {
return borsh.vecU8(fieldName);
}
case "string": {
return borsh.str(fieldName);
}
case "pubkey": {
return borsh.publicKey(fieldName);
}
default: {
if ("option" in field.type) {
return borsh.option(IdlCoder.fieldLayout({ type: field.type.option }, types, genericArgs), fieldName);
}
if ("vec" in field.type) {
return borsh.vec(IdlCoder.fieldLayout({ type: field.type.vec }, types, genericArgs), fieldName);
}
if ("array" in field.type) {
let [type, len] = field.type.array;
len = IdlCoder.resolveArrayLen(len, genericArgs);
return borsh.array(IdlCoder.fieldLayout({ type }, types, genericArgs), len, fieldName);
}
if ("defined" in field.type) {
if (!types) {
throw new error_js_1.IdlError("User defined types not provided");
}
const definedName = field.type.defined.name;
const typeDef = types.find((t) => t.name === definedName);
if (!typeDef) {
throw new error_js_1.IdlError(`Type not found: ${field.name}`);
}
return IdlCoder.typeDefLayout({
typeDef,
types,
genericArgs: genericArgs !== null && genericArgs !== void 0 ? genericArgs : field.type.defined.generics,
name: fieldName,
});
}
if ("generic" in field.type) {
const genericArg = genericArgs === null || genericArgs === void 0 ? void 0 : genericArgs.at(0);
if ((genericArg === null || genericArg === void 0 ? void 0 : genericArg.kind) !== "type") {
throw new error_js_1.IdlError(`Invalid generic field: ${field.name}`);
}
return IdlCoder.fieldLayout({ ...field, type: genericArg.type }, types);
}
throw new error_js_1.IdlError(`Not yet implemented: ${JSON.stringify(field.type)}`);
}
}
}
/**
* Get the type layout of the given defined type(struct or enum).
*/
static typeDefLayout({ typeDef, types, name, genericArgs, }) {
switch (typeDef.type.kind) {
case "struct": {
const fieldLayouts = (0, idl_js_1.handleDefinedFields)(typeDef.type.fields, () => [], (fields) => fields.map((f) => {
const genArgs = genericArgs
? IdlCoder.resolveGenericArgs({
type: f.type,
typeDef,
genericArgs,
})
: genericArgs;
return IdlCoder.fieldLayout(f, types, genArgs);
}), (fields) => fields.map((f, i) => {
const genArgs = genericArgs
? IdlCoder.resolveGenericArgs({
type: f,
typeDef,
genericArgs,
})
: genericArgs;
return IdlCoder.fieldLayout({ name: i.toString(), type: f }, types, genArgs);
}));
return borsh.struct(fieldLayouts, name);
}
case "enum": {
const variants = typeDef.type.variants.map((variant) => {
const fieldLayouts = (0, idl_js_1.handleDefinedFields)(variant.fields, () => [], (fields) => fields.map((f) => {
const genArgs = genericArgs
? IdlCoder.resolveGenericArgs({
type: f.type,
typeDef,
genericArgs,
})
: genericArgs;
return IdlCoder.fieldLayout(f, types, genArgs);
}), (fields) => fields.map((f, i) => {
const genArgs = genericArgs
? IdlCoder.resolveGenericArgs({
type: f,
typeDef,
genericArgs,
})
: genericArgs;
return IdlCoder.fieldLayout({ name: i.toString(), type: f }, types, genArgs);
}));
return borsh.struct(fieldLayouts, variant.name);
});
if (name !== undefined) {
// Buffer-layout lib requires the name to be null (on construction)
// when used as a field.
return borsh.rustEnum(variants).replicate(name);
}
return borsh.rustEnum(variants, name);
}
case "type": {
return IdlCoder.fieldLayout({ type: typeDef.type.alias, name }, types);
}
}
}
/**
* Get the type of the size in bytes. Returns `1` for variable length types.
*/
static typeSize(ty, idl, genericArgs) {
var _a;
switch (ty) {
case "bool":
return 1;
case "u8":
return 1;
case "i8":
return 1;
case "i16":
return 2;
case "u16":
return 2;
case "u32":
return 4;
case "i32":
return 4;
case "f32":
return 4;
case "u64":
return 8;
case "i64":
return 8;
case "f64":
return 8;
case "u128":
return 16;
case "i128":
return 16;
case "u256":
return 32;
case "i256":
return 32;
case "bytes":
return 1;
case "string":
return 1;
case "pubkey":
return 32;
default:
if ("option" in ty) {
return 1 + IdlCoder.typeSize(ty.option, idl, genericArgs);
}
if ("coption" in ty) {
return 4 + IdlCoder.typeSize(ty.coption, idl, genericArgs);
}
if ("vec" in ty) {
return 1;
}
if ("array" in ty) {
let [type, len] = ty.array;
len = IdlCoder.resolveArrayLen(len, genericArgs);
return IdlCoder.typeSize(type, idl, genericArgs) * len;
}
if ("defined" in ty) {
const typeDef = (_a = idl.types) === null || _a === void 0 ? void 0 : _a.find((t) => t.name === ty.defined.name);
if (!typeDef) {
throw new error_js_1.IdlError(`Type not found: ${JSON.stringify(ty)}`);
}
const typeSize = (type) => {
const genArgs = genericArgs !== null && genericArgs !== void 0 ? genericArgs : ty.defined.generics;
const args = genArgs
? IdlCoder.resolveGenericArgs({
type,
typeDef,
genericArgs: genArgs,
})
: genArgs;
return IdlCoder.typeSize(type, idl, args);
};
switch (typeDef.type.kind) {
case "struct": {
return (0, idl_js_1.handleDefinedFields)(typeDef.type.fields, () => [0], (fields) => fields.map((f) => typeSize(f.type)), (fields) => fields.map((f) => typeSize(f))).reduce((acc, size) => acc + size, 0);
}
case "enum": {
const variantSizes = typeDef.type.variants.map((variant) => {
return (0, idl_js_1.handleDefinedFields)(variant.fields, () => [0], (fields) => fields.map((f) => typeSize(f.type)), (fields) => fields.map((f) => typeSize(f))).reduce((acc, size) => acc + size, 0);
});
return Math.max(...variantSizes) + 1;
}
case "type": {
return IdlCoder.typeSize(typeDef.type.alias, idl, genericArgs);
}
}
}
if ("generic" in ty) {
const genericArg = genericArgs === null || genericArgs === void 0 ? void 0 : genericArgs.at(0);
if ((genericArg === null || genericArg === void 0 ? void 0 : genericArg.kind) !== "type") {
throw new error_js_1.IdlError(`Invalid generic: ${ty.generic}`);
}
return IdlCoder.typeSize(genericArg.type, idl, genericArgs);
}
throw new Error(`Invalid type ${JSON.stringify(ty)}`);
}
}
/**
* Resolve the generic array length or return the constant-sized array length.
*/
static resolveArrayLen(len, genericArgs) {
if (typeof len === "number")
return len;
if (genericArgs) {
const genericLen = genericArgs.find((g) => g.kind === "const");
if ((genericLen === null || genericLen === void 0 ? void 0 : genericLen.kind) === "const") {
len = +genericLen.value;
}
}
if (typeof len !== "number") {
throw new error_js_1.IdlError("Generic array length did not resolve");
}
return len;
}
/**
* Recursively resolve generic arguments i.e. replace all generics with the
* actual type that they hold based on the initial `genericArgs` given.
*/
static resolveGenericArgs({ type, typeDef, genericArgs, isDefined, }) {
if (typeof type !== "object")
return null;
for (const index in typeDef.generics) {
const defGeneric = typeDef.generics[index];
if ("generic" in type && defGeneric.name === type.generic) {
return [genericArgs[index]];
}
if ("option" in type) {
const args = IdlCoder.resolveGenericArgs({
type: type.option,
typeDef,
genericArgs,
isDefined,
});
if (!args || !isDefined)
return args;
if (args[0].kind === "type") {
return [
{
kind: "type",
type: { option: args[0].type },
},
];
}
}
if ("vec" in type) {
const args = IdlCoder.resolveGenericArgs({
type: type.vec,
typeDef,
genericArgs,
isDefined,
});
if (!args || !isDefined)
return args;
if (args[0].kind === "type") {
return [
{
kind: "type",
type: { vec: args[0].type },
},
];
}
}
if ("array" in type) {
const [elTy, len] = type.array;
const isGenericLen = typeof len === "object";
const args = IdlCoder.resolveGenericArgs({
type: elTy,
typeDef,
genericArgs,
isDefined,
}) || [];
// Check all generics for matching const generic length
if (isGenericLen) {
const matchingGeneric = typeDef.generics.findIndex((g) => g.name === len.generic);
if (matchingGeneric !== -1) {
args.push(genericArgs[matchingGeneric]);
}
}
if (args.length > 0) {
if (!isDefined)
return args;
if (args[0].kind === "type" && args[1].kind === "const") {
return [
{
kind: "type",
type: { array: [args[0].type, +args[1].value] },
},
];
}
}
// Only generic len
if (isGenericLen && defGeneric.name === len.generic) {
const arg = genericArgs[index];
if (!isDefined)
return [arg];
return [
{
kind: "type",
type: { array: [elTy, +arg.value] },
},
];
}
// Non-generic
return null;
}
if ("defined" in type) {
if (!type.defined.generics)
return null;
return type.defined.generics
.flatMap((g) => {
switch (g.kind) {
case "type":
return IdlCoder.resolveGenericArgs({
type: g.type,
typeDef,
genericArgs,
isDefined: true,
});
case "const":
return [g];
}
})
.filter((g) => g !== null);
}
}
return null;
}
}
exports.IdlCoder = IdlCoder;
//# sourceMappingURL=idl.js.map