@ghostspeak/sdk
Version:
TypeScript SDK for GhostSpeak AI Agent Commerce Protocol - Production Ready Beta
1,459 lines (1,458 loc) • 293 kB
JavaScript
import { getAgentVerificationDataEncoder, getAgentVerificationDataDecoder, getAuditConfigEncoder, getComplianceStatusEncoder, getAuditEntryEncoder, getAuditConfigDecoder, getComplianceStatusDecoder, getAuditEntryDecoder, getReportTypeEncoder, getReportDataEncoder, getReportStatusEncoder, getSubmissionDetailsEncoder, getReportTypeDecoder, getReportDataDecoder, getReportStatusDecoder, getSubmissionDetailsDecoder, getCredentialStatusEncoder, getCrossChainStatusEncoder, getCredentialStatusDecoder, getCrossChainStatusDecoder, getCredentialKindEncoder, getCredentialKindDecoder, getVerificationMethodEncoder, getServiceEndpointEncoder, getVerificationMethodDecoder, getServiceEndpointDecoder, getEscrowStatusEncoder, getArbitratorDecisionEncoder, getEscrowStatusDecoder, getArbitratorDecisionDecoder, getProposalTypeEncoder, getProposalStatusEncoder, getVotingResultsEncoder, getExecutionParamsEncoder, getQuorumRequirementsEncoder, getProposalMetadataEncoder, getProposalTypeDecoder, getProposalStatusDecoder, getVotingResultsDecoder, getExecutionParamsDecoder, getQuorumRequirementsDecoder, getProposalMetadataDecoder, getMultisigTypeEncoder, getMultisigConfigEncoder, getEmergencyConfigEncoder, getMultisigTypeConfigEncoder, getPendingTransactionEncoder, getMultisigTypeDecoder, getMultisigConfigDecoder, getEmergencyConfigDecoder, getMultisigTypeConfigDecoder, getPendingTransactionDecoder, getSecurityPoliciesEncoder, getAccessAuditConfigEncoder, getEmergencyAccessConfigEncoder, getRoleEncoder, getPermissionEncoder, getAccessPolicyEncoder, getSecurityPoliciesDecoder, getAccessAuditConfigDecoder, getEmergencyAccessConfigDecoder, getRoleDecoder, getPermissionDecoder, getAccessPolicyDecoder, getReentrancyStateEncoder, getReentrancyStateDecoder, getTagScoreEncoder, getSourceScoreEncoder, getTagScoreDecoder, getSourceScoreDecoder, getAccessTierEncoder, getAccessTierDecoder, getPricingModelEncoder, getPricingModelDecoder, getSlashReasonEncoder, getSlashReasonDecoder, getReputationComponentEncoder, getReputationComponentDecoder } from './chunk-5QZVFUXB.js';
import { GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS, expectAddress, expectSome, getAccountMetaFactory } from './chunk-AWMGX3OX.js';
import { fixEncoderSize, getBytesEncoder, transformEncoder, getStructEncoder, getAddressEncoder, getU64Encoder, getI64Encoder, getU8Encoder, getOptionEncoder, getBooleanEncoder, addEncoderSizePrefix, getUtf8Encoder, getU32Encoder, getStructDecoder, fixDecoderSize, getAddressDecoder, getU64Decoder, getI64Decoder, getU8Decoder, getOptionDecoder, getBooleanDecoder, getBytesDecoder, addDecoderSizePrefix, getUtf8Decoder, getU32Decoder, combineCodec, decodeAccount, assertAccountExists, fetchEncodedAccount, assertAccountsExist, fetchEncodedAccounts, getArrayEncoder, getArrayDecoder, getU16Encoder, getU16Decoder, isProgramError, getProgramDerivedAddress } from '@solana/kit';
var AGENT_REPUTATION_AUTH_DISCRIMINATOR = new Uint8Array([
30,
249,
165,
44,
155,
194,
188,
175
]);
function getAgentReputationAuthDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
AGENT_REPUTATION_AUTH_DISCRIMINATOR
);
}
function getAgentReputationAuthEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["agent", getAddressEncoder()],
["authorizedSource", getAddressEncoder()],
["indexLimit", getU64Encoder()],
["currentIndex", getU64Encoder()],
["expiresAt", getI64Encoder()],
["network", getU8Encoder()],
["signature", fixEncoderSize(getBytesEncoder(), 64)],
[
"nonce",
getOptionEncoder(
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
)
],
["revoked", getBooleanEncoder()],
["createdAt", getI64Encoder()],
["lastUsedAt", getOptionEncoder(getI64Encoder())],
["totalReputationChange", getI64Encoder()],
["bump", getU8Encoder()]
]),
(value) => ({
...value,
discriminator: AGENT_REPUTATION_AUTH_DISCRIMINATOR
})
);
}
function getAgentReputationAuthDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["agent", getAddressDecoder()],
["authorizedSource", getAddressDecoder()],
["indexLimit", getU64Decoder()],
["currentIndex", getU64Decoder()],
["expiresAt", getI64Decoder()],
["network", getU8Decoder()],
["signature", fixDecoderSize(getBytesDecoder(), 64)],
[
"nonce",
getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
],
["revoked", getBooleanDecoder()],
["createdAt", getI64Decoder()],
["lastUsedAt", getOptionDecoder(getI64Decoder())],
["totalReputationChange", getI64Decoder()],
["bump", getU8Decoder()]
]);
}
function getAgentReputationAuthCodec() {
return combineCodec(
getAgentReputationAuthEncoder(),
getAgentReputationAuthDecoder()
);
}
function decodeAgentReputationAuth(encodedAccount) {
return decodeAccount(
encodedAccount,
getAgentReputationAuthDecoder()
);
}
async function fetchAgentReputationAuth(rpc, address, config) {
const maybeAccount = await fetchMaybeAgentReputationAuth(
rpc,
address,
config
);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeAgentReputationAuth(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeAgentReputationAuth(maybeAccount);
}
async function fetchAllAgentReputationAuth(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeAgentReputationAuth(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeAgentReputationAuth(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeAgentReputationAuth(maybeAccount)
);
}
var AGENT_TREE_CONFIG_DISCRIMINATOR = new Uint8Array([
145,
145,
156,
0,
197,
232,
130,
245
]);
function getAgentTreeConfigDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
AGENT_TREE_CONFIG_DISCRIMINATOR
);
}
function getAgentTreeConfigEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["treeCreator", getAddressEncoder()],
["treeDelegate", getAddressEncoder()],
["numMinted", getU64Encoder()],
["bump", getU8Encoder()]
]),
(value) => ({ ...value, discriminator: AGENT_TREE_CONFIG_DISCRIMINATOR })
);
}
function getAgentTreeConfigDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["treeCreator", getAddressDecoder()],
["treeDelegate", getAddressDecoder()],
["numMinted", getU64Decoder()],
["bump", getU8Decoder()]
]);
}
function getAgentTreeConfigCodec() {
return combineCodec(getAgentTreeConfigEncoder(), getAgentTreeConfigDecoder());
}
function decodeAgentTreeConfig(encodedAccount) {
return decodeAccount(
encodedAccount,
getAgentTreeConfigDecoder()
);
}
async function fetchAgentTreeConfig(rpc, address, config) {
const maybeAccount = await fetchMaybeAgentTreeConfig(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeAgentTreeConfig(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeAgentTreeConfig(maybeAccount);
}
async function fetchAllAgentTreeConfig(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeAgentTreeConfig(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeAgentTreeConfig(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeAgentTreeConfig(maybeAccount)
);
}
function getAgentTreeConfigSize() {
return 81;
}
var AGENT_VERIFICATION_DISCRIMINATOR = new Uint8Array([
128,
155,
95,
241,
66,
207,
166,
59
]);
function getAgentVerificationDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
AGENT_VERIFICATION_DISCRIMINATOR
);
}
function getAgentVerificationEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["agent", getAddressEncoder()],
["verifier", getAddressEncoder()],
["verificationData", getAgentVerificationDataEncoder()],
["createdAt", getI64Encoder()],
["expiresAt", getI64Encoder()],
["isActive", getBooleanEncoder()],
["bump", getU8Encoder()]
]),
(value) => ({ ...value, discriminator: AGENT_VERIFICATION_DISCRIMINATOR })
);
}
function getAgentVerificationDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["agent", getAddressDecoder()],
["verifier", getAddressDecoder()],
["verificationData", getAgentVerificationDataDecoder()],
["createdAt", getI64Decoder()],
["expiresAt", getI64Decoder()],
["isActive", getBooleanDecoder()],
["bump", getU8Decoder()]
]);
}
function getAgentVerificationCodec() {
return combineCodec(
getAgentVerificationEncoder(),
getAgentVerificationDecoder()
);
}
function decodeAgentVerification(encodedAccount) {
return decodeAccount(
encodedAccount,
getAgentVerificationDecoder()
);
}
async function fetchAgentVerification(rpc, address, config) {
const maybeAccount = await fetchMaybeAgentVerification(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeAgentVerification(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeAgentVerification(maybeAccount);
}
async function fetchAllAgentVerification(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeAgentVerification(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeAgentVerification(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeAgentVerification(maybeAccount)
);
}
var AUDIT_TRAIL_DISCRIMINATOR = new Uint8Array([
171,
223,
253,
181,
134,
88,
66,
26
]);
function getAuditTrailDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(AUDIT_TRAIL_DISCRIMINATOR);
}
function getAuditTrailEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["authority", getAddressEncoder()],
["trailId", getU64Encoder()],
["createdAt", getI64Encoder()],
["updatedAt", getI64Encoder()],
["version", getU8Encoder()],
["entries", getArrayEncoder(getAuditEntryEncoder())],
["config", getAuditConfigEncoder()],
["complianceStatus", getComplianceStatusEncoder()],
["hashChain", getArrayEncoder(fixEncoderSize(getBytesEncoder(), 32))],
["reserved", fixEncoderSize(getBytesEncoder(), 128)]
]),
(value) => ({ ...value, discriminator: AUDIT_TRAIL_DISCRIMINATOR })
);
}
function getAuditTrailDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["authority", getAddressDecoder()],
["trailId", getU64Decoder()],
["createdAt", getI64Decoder()],
["updatedAt", getI64Decoder()],
["version", getU8Decoder()],
["entries", getArrayDecoder(getAuditEntryDecoder())],
["config", getAuditConfigDecoder()],
["complianceStatus", getComplianceStatusDecoder()],
["hashChain", getArrayDecoder(fixDecoderSize(getBytesDecoder(), 32))],
["reserved", fixDecoderSize(getBytesDecoder(), 128)]
]);
}
function getAuditTrailCodec() {
return combineCodec(getAuditTrailEncoder(), getAuditTrailDecoder());
}
function decodeAuditTrail(encodedAccount) {
return decodeAccount(
encodedAccount,
getAuditTrailDecoder()
);
}
async function fetchAuditTrail(rpc, address, config) {
const maybeAccount = await fetchMaybeAuditTrail(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeAuditTrail(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeAuditTrail(maybeAccount);
}
async function fetchAllAuditTrail(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeAuditTrail(rpc, addresses, config);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeAuditTrail(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeAuditTrail(maybeAccount));
}
var AUTHORIZATION_USAGE_RECORD_DISCRIMINATOR = new Uint8Array([
109,
102,
102,
17,
210,
84,
85,
210
]);
function getAuthorizationUsageRecordDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
AUTHORIZATION_USAGE_RECORD_DISCRIMINATOR
);
}
function getAuthorizationUsageRecordEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["authorization", getAddressEncoder()],
["agent", getAddressEncoder()],
["authorizedSource", getAddressEncoder()],
["usageIndex", getU64Encoder()],
["reputationChange", getI64Encoder()],
["usedAt", getI64Encoder()],
[
"transactionSignature",
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
],
[
"metadata",
getOptionEncoder(
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
)
],
["bump", getU8Encoder()]
]),
(value) => ({
...value,
discriminator: AUTHORIZATION_USAGE_RECORD_DISCRIMINATOR
})
);
}
function getAuthorizationUsageRecordDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["authorization", getAddressDecoder()],
["agent", getAddressDecoder()],
["authorizedSource", getAddressDecoder()],
["usageIndex", getU64Decoder()],
["reputationChange", getI64Decoder()],
["usedAt", getI64Decoder()],
[
"transactionSignature",
addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())
],
[
"metadata",
getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
],
["bump", getU8Decoder()]
]);
}
function getAuthorizationUsageRecordCodec() {
return combineCodec(
getAuthorizationUsageRecordEncoder(),
getAuthorizationUsageRecordDecoder()
);
}
function decodeAuthorizationUsageRecord(encodedAccount) {
return decodeAccount(
encodedAccount,
getAuthorizationUsageRecordDecoder()
);
}
async function fetchAuthorizationUsageRecord(rpc, address, config) {
const maybeAccount = await fetchMaybeAuthorizationUsageRecord(
rpc,
address,
config
);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeAuthorizationUsageRecord(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeAuthorizationUsageRecord(maybeAccount);
}
async function fetchAllAuthorizationUsageRecord(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeAuthorizationUsageRecord(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeAuthorizationUsageRecord(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeAuthorizationUsageRecord(maybeAccount)
);
}
var COMPLIANCE_REPORT_DISCRIMINATOR = new Uint8Array([
75,
146,
78,
26,
130,
240,
228,
35
]);
function getComplianceReportDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
COMPLIANCE_REPORT_DISCRIMINATOR
);
}
function getComplianceReportEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["reportId", getU64Encoder()],
["reportType", getReportTypeEncoder()],
["generatedAt", getI64Encoder()],
["periodStart", getI64Encoder()],
["periodEnd", getI64Encoder()],
["reportData", getReportDataEncoder()],
["signature", fixEncoderSize(getBytesEncoder(), 64)],
["status", getReportStatusEncoder()],
["submissionDetails", getOptionEncoder(getSubmissionDetailsEncoder())],
["reserved", fixEncoderSize(getBytesEncoder(), 64)]
]),
(value) => ({ ...value, discriminator: COMPLIANCE_REPORT_DISCRIMINATOR })
);
}
function getComplianceReportDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["reportId", getU64Decoder()],
["reportType", getReportTypeDecoder()],
["generatedAt", getI64Decoder()],
["periodStart", getI64Decoder()],
["periodEnd", getI64Decoder()],
["reportData", getReportDataDecoder()],
["signature", fixDecoderSize(getBytesDecoder(), 64)],
["status", getReportStatusDecoder()],
["submissionDetails", getOptionDecoder(getSubmissionDetailsDecoder())],
["reserved", fixDecoderSize(getBytesDecoder(), 64)]
]);
}
function getComplianceReportCodec() {
return combineCodec(
getComplianceReportEncoder(),
getComplianceReportDecoder()
);
}
function decodeComplianceReport(encodedAccount) {
return decodeAccount(
encodedAccount,
getComplianceReportDecoder()
);
}
async function fetchComplianceReport(rpc, address, config) {
const maybeAccount = await fetchMaybeComplianceReport(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeComplianceReport(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeComplianceReport(maybeAccount);
}
async function fetchAllComplianceReport(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeComplianceReport(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeComplianceReport(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeComplianceReport(maybeAccount)
);
}
var CREDENTIAL_DISCRIMINATOR = new Uint8Array([
145,
44,
68,
220,
67,
46,
100,
135
]);
function getCredentialDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(CREDENTIAL_DISCRIMINATOR);
}
function getCredentialEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["template", getAddressEncoder()],
["subject", getAddressEncoder()],
["issuer", getAddressEncoder()],
["credentialId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["subjectDataHash", fixEncoderSize(getBytesEncoder(), 32)],
[
"subjectDataUri",
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
],
["status", getCredentialStatusEncoder()],
["signature", fixEncoderSize(getBytesEncoder(), 64)],
["issuedAt", getI64Encoder()],
["expiresAt", getOptionEncoder(getI64Encoder())],
["revokedAt", getOptionEncoder(getI64Encoder())],
["crossChainStatus", getCrossChainStatusEncoder()],
[
"crossmintCredentialId",
getOptionEncoder(
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
)
],
["sourceAccount", getOptionEncoder(getAddressEncoder())],
["bump", getU8Encoder()]
]),
(value) => ({ ...value, discriminator: CREDENTIAL_DISCRIMINATOR })
);
}
function getCredentialDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["template", getAddressDecoder()],
["subject", getAddressDecoder()],
["issuer", getAddressDecoder()],
["credentialId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["subjectDataHash", fixDecoderSize(getBytesDecoder(), 32)],
["subjectDataUri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["status", getCredentialStatusDecoder()],
["signature", fixDecoderSize(getBytesDecoder(), 64)],
["issuedAt", getI64Decoder()],
["expiresAt", getOptionDecoder(getI64Decoder())],
["revokedAt", getOptionDecoder(getI64Decoder())],
["crossChainStatus", getCrossChainStatusDecoder()],
[
"crossmintCredentialId",
getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
],
["sourceAccount", getOptionDecoder(getAddressDecoder())],
["bump", getU8Decoder()]
]);
}
function getCredentialCodec() {
return combineCodec(getCredentialEncoder(), getCredentialDecoder());
}
function decodeCredential(encodedAccount) {
return decodeAccount(
encodedAccount,
getCredentialDecoder()
);
}
async function fetchCredential(rpc, address, config) {
const maybeAccount = await fetchMaybeCredential(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeCredential(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeCredential(maybeAccount);
}
async function fetchAllCredential(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeCredential(rpc, addresses, config);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeCredential(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeCredential(maybeAccount));
}
var CREDENTIAL_TEMPLATE_DISCRIMINATOR = new Uint8Array([
229,
129,
99,
91,
179,
207,
66,
75
]);
function getCredentialTemplateDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
CREDENTIAL_TEMPLATE_DISCRIMINATOR
);
}
function getCredentialTemplateEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["credentialType", getAddressEncoder()],
["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["imageUri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["issuer", getAddressEncoder()],
["isActive", getBooleanEncoder()],
["totalIssued", getU64Encoder()],
["createdAt", getI64Encoder()],
[
"crossmintTemplateId",
getOptionEncoder(
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
)
],
["bump", getU8Encoder()]
]),
(value) => ({ ...value, discriminator: CREDENTIAL_TEMPLATE_DISCRIMINATOR })
);
}
function getCredentialTemplateDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["credentialType", getAddressDecoder()],
["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["imageUri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["issuer", getAddressDecoder()],
["isActive", getBooleanDecoder()],
["totalIssued", getU64Decoder()],
["createdAt", getI64Decoder()],
[
"crossmintTemplateId",
getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
],
["bump", getU8Decoder()]
]);
}
function getCredentialTemplateCodec() {
return combineCodec(
getCredentialTemplateEncoder(),
getCredentialTemplateDecoder()
);
}
function decodeCredentialTemplate(encodedAccount) {
return decodeAccount(
encodedAccount,
getCredentialTemplateDecoder()
);
}
async function fetchCredentialTemplate(rpc, address, config) {
const maybeAccount = await fetchMaybeCredentialTemplate(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeCredentialTemplate(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeCredentialTemplate(maybeAccount);
}
async function fetchAllCredentialTemplate(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeCredentialTemplate(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeCredentialTemplate(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeCredentialTemplate(maybeAccount)
);
}
var CREDENTIAL_TYPE_DISCRIMINATOR = new Uint8Array([
132,
171,
20,
181,
39,
219,
217,
112
]);
function getCredentialTypeDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
CREDENTIAL_TYPE_DISCRIMINATOR
);
}
function getCredentialTypeEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["authority", getAddressEncoder()],
["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["kind", getCredentialKindEncoder()],
["schemaUri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["isActive", getBooleanEncoder()],
["totalIssued", getU64Encoder()],
["createdAt", getI64Encoder()],
["bump", getU8Encoder()]
]),
(value) => ({ ...value, discriminator: CREDENTIAL_TYPE_DISCRIMINATOR })
);
}
function getCredentialTypeDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["authority", getAddressDecoder()],
["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["kind", getCredentialKindDecoder()],
["schemaUri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["isActive", getBooleanDecoder()],
["totalIssued", getU64Decoder()],
["createdAt", getI64Decoder()],
["bump", getU8Decoder()]
]);
}
function getCredentialTypeCodec() {
return combineCodec(getCredentialTypeEncoder(), getCredentialTypeDecoder());
}
function decodeCredentialType(encodedAccount) {
return decodeAccount(
encodedAccount,
getCredentialTypeDecoder()
);
}
async function fetchCredentialType(rpc, address, config) {
const maybeAccount = await fetchMaybeCredentialType(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeCredentialType(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeCredentialType(maybeAccount);
}
async function fetchAllCredentialType(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeCredentialType(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeCredentialType(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeCredentialType(maybeAccount)
);
}
var DID_DOCUMENT_DISCRIMINATOR = new Uint8Array([
109,
220,
168,
224,
33,
173,
192,
166
]);
function getDidDocumentDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
DID_DOCUMENT_DISCRIMINATOR
);
}
function getDidDocumentEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["did", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["controller", getAddressEncoder()],
["verificationMethods", getArrayEncoder(getVerificationMethodEncoder())],
["serviceEndpoints", getArrayEncoder(getServiceEndpointEncoder())],
[
"context",
getArrayEncoder(
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
)
],
[
"alsoKnownAs",
getArrayEncoder(
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
)
],
["createdAt", getI64Encoder()],
["updatedAt", getI64Encoder()],
["version", getU32Encoder()],
["deactivated", getBooleanEncoder()],
["deactivatedAt", getOptionEncoder(getI64Encoder())],
["bump", getU8Encoder()]
]),
(value) => ({ ...value, discriminator: DID_DOCUMENT_DISCRIMINATOR })
);
}
function getDidDocumentDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["did", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["controller", getAddressDecoder()],
["verificationMethods", getArrayDecoder(getVerificationMethodDecoder())],
["serviceEndpoints", getArrayDecoder(getServiceEndpointDecoder())],
[
"context",
getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
],
[
"alsoKnownAs",
getArrayDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
],
["createdAt", getI64Decoder()],
["updatedAt", getI64Decoder()],
["version", getU32Decoder()],
["deactivated", getBooleanDecoder()],
["deactivatedAt", getOptionDecoder(getI64Decoder())],
["bump", getU8Decoder()]
]);
}
function getDidDocumentCodec() {
return combineCodec(getDidDocumentEncoder(), getDidDocumentDecoder());
}
function decodeDidDocument(encodedAccount) {
return decodeAccount(
encodedAccount,
getDidDocumentDecoder()
);
}
async function fetchDidDocument(rpc, address, config) {
const maybeAccount = await fetchMaybeDidDocument(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeDidDocument(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeDidDocument(maybeAccount);
}
async function fetchAllDidDocument(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeDidDocument(rpc, addresses, config);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeDidDocument(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeDidDocument(maybeAccount));
}
var EXTERNAL_ID_MAPPING_DISCRIMINATOR = new Uint8Array([
180,
218,
64,
128,
181,
84,
116,
180
]);
function getExternalIdMappingDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
EXTERNAL_ID_MAPPING_DISCRIMINATOR
);
}
function getExternalIdMappingEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["ghostPubkey", getAddressEncoder()],
["platform", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["externalId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["createdAt", getI64Encoder()],
["verified", getBooleanEncoder()],
["verifiedAt", getOptionEncoder(getI64Encoder())],
["bump", getU8Encoder()]
]),
(value) => ({ ...value, discriminator: EXTERNAL_ID_MAPPING_DISCRIMINATOR })
);
}
function getExternalIdMappingDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["ghostPubkey", getAddressDecoder()],
["platform", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["externalId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["createdAt", getI64Decoder()],
["verified", getBooleanDecoder()],
["verifiedAt", getOptionDecoder(getI64Decoder())],
["bump", getU8Decoder()]
]);
}
function getExternalIdMappingCodec() {
return combineCodec(
getExternalIdMappingEncoder(),
getExternalIdMappingDecoder()
);
}
function decodeExternalIdMapping(encodedAccount) {
return decodeAccount(
encodedAccount,
getExternalIdMappingDecoder()
);
}
async function fetchExternalIdMapping(rpc, address, config) {
const maybeAccount = await fetchMaybeExternalIdMapping(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeExternalIdMapping(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeExternalIdMapping(maybeAccount);
}
async function fetchAllExternalIdMapping(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeExternalIdMapping(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeExternalIdMapping(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeExternalIdMapping(maybeAccount)
);
}
var GHOST_PROTECT_ESCROW_DISCRIMINATOR = new Uint8Array([
38,
0,
98,
160,
102,
4,
51,
160
]);
function getGhostProtectEscrowDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
GHOST_PROTECT_ESCROW_DISCRIMINATOR
);
}
function getGhostProtectEscrowEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["escrowId", getU64Encoder()],
["client", getAddressEncoder()],
["agent", getAddressEncoder()],
["amount", getU64Encoder()],
["tokenMint", getAddressEncoder()],
["status", getEscrowStatusEncoder()],
[
"jobDescription",
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
],
[
"deliveryProof",
getOptionEncoder(
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
)
],
["deadline", getI64Encoder()],
["createdAt", getI64Encoder()],
["completedAt", getOptionEncoder(getI64Encoder())],
[
"disputeReason",
getOptionEncoder(
addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
)
],
["arbitratorDecision", getOptionEncoder(getArbitratorDecisionEncoder())],
["bump", getU8Encoder()]
]),
(value) => ({
...value,
discriminator: GHOST_PROTECT_ESCROW_DISCRIMINATOR
})
);
}
function getGhostProtectEscrowDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["escrowId", getU64Decoder()],
["client", getAddressDecoder()],
["agent", getAddressDecoder()],
["amount", getU64Decoder()],
["tokenMint", getAddressDecoder()],
["status", getEscrowStatusDecoder()],
["jobDescription", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
[
"deliveryProof",
getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
],
["deadline", getI64Decoder()],
["createdAt", getI64Decoder()],
["completedAt", getOptionDecoder(getI64Decoder())],
[
"disputeReason",
getOptionDecoder(addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder()))
],
["arbitratorDecision", getOptionDecoder(getArbitratorDecisionDecoder())],
["bump", getU8Decoder()]
]);
}
function getGhostProtectEscrowCodec() {
return combineCodec(
getGhostProtectEscrowEncoder(),
getGhostProtectEscrowDecoder()
);
}
function decodeGhostProtectEscrow(encodedAccount) {
return decodeAccount(
encodedAccount,
getGhostProtectEscrowDecoder()
);
}
async function fetchGhostProtectEscrow(rpc, address, config) {
const maybeAccount = await fetchMaybeGhostProtectEscrow(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeGhostProtectEscrow(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeGhostProtectEscrow(maybeAccount);
}
async function fetchAllGhostProtectEscrow(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeGhostProtectEscrow(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeGhostProtectEscrow(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeGhostProtectEscrow(maybeAccount)
);
}
var GOVERNANCE_PROPOSAL_DISCRIMINATOR = new Uint8Array([
53,
107,
240,
190,
43,
73,
65,
143
]);
function getGovernanceProposalDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
GOVERNANCE_PROPOSAL_DISCRIMINATOR
);
}
function getGovernanceProposalEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["proposalId", getU64Encoder()],
["proposer", getAddressEncoder()],
["title", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["description", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
["proposalType", getProposalTypeEncoder()],
["createdAt", getI64Encoder()],
["votingStartsAt", getI64Encoder()],
["votingEndsAt", getI64Encoder()],
["executionTimestamp", getOptionEncoder(getI64Encoder())],
["status", getProposalStatusEncoder()],
["votingResults", getVotingResultsEncoder()],
["executionParams", getExecutionParamsEncoder()],
["quorumRequirements", getQuorumRequirementsEncoder()],
["metadata", getProposalMetadataEncoder()],
["reserved", fixEncoderSize(getBytesEncoder(), 64)]
]),
(value) => ({ ...value, discriminator: GOVERNANCE_PROPOSAL_DISCRIMINATOR })
);
}
function getGovernanceProposalDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["proposalId", getU64Decoder()],
["proposer", getAddressDecoder()],
["title", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["description", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
["proposalType", getProposalTypeDecoder()],
["createdAt", getI64Decoder()],
["votingStartsAt", getI64Decoder()],
["votingEndsAt", getI64Decoder()],
["executionTimestamp", getOptionDecoder(getI64Decoder())],
["status", getProposalStatusDecoder()],
["votingResults", getVotingResultsDecoder()],
["executionParams", getExecutionParamsDecoder()],
["quorumRequirements", getQuorumRequirementsDecoder()],
["metadata", getProposalMetadataDecoder()],
["reserved", fixDecoderSize(getBytesDecoder(), 64)]
]);
}
function getGovernanceProposalCodec() {
return combineCodec(
getGovernanceProposalEncoder(),
getGovernanceProposalDecoder()
);
}
function decodeGovernanceProposal(encodedAccount) {
return decodeAccount(
encodedAccount,
getGovernanceProposalDecoder()
);
}
async function fetchGovernanceProposal(rpc, address, config) {
const maybeAccount = await fetchMaybeGovernanceProposal(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeGovernanceProposal(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeGovernanceProposal(maybeAccount);
}
async function fetchAllGovernanceProposal(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeGovernanceProposal(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeGovernanceProposal(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeGovernanceProposal(maybeAccount)
);
}
var MULTISIG_DISCRIMINATOR = new Uint8Array([
224,
116,
121,
186,
68,
161,
79,
236
]);
function getMultisigDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(MULTISIG_DISCRIMINATOR);
}
function getMultisigEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["multisigId", getU64Encoder()],
["multisigType", getMultisigTypeEncoder()],
["threshold", getU8Encoder()],
["signers", getArrayEncoder(getAddressEncoder())],
["owner", getAddressEncoder()],
["createdAt", getI64Encoder()],
["updatedAt", getI64Encoder()],
["nonce", getU64Encoder()],
["pendingTransactions", getArrayEncoder(getPendingTransactionEncoder())],
["config", getMultisigConfigEncoder()],
["emergencyConfig", getEmergencyConfigEncoder()],
["typeConfig", getMultisigTypeConfigEncoder()],
["reserved", fixEncoderSize(getBytesEncoder(), 64)]
]),
(value) => ({ ...value, discriminator: MULTISIG_DISCRIMINATOR })
);
}
function getMultisigDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["multisigId", getU64Decoder()],
["multisigType", getMultisigTypeDecoder()],
["threshold", getU8Decoder()],
["signers", getArrayDecoder(getAddressDecoder())],
["owner", getAddressDecoder()],
["createdAt", getI64Decoder()],
["updatedAt", getI64Decoder()],
["nonce", getU64Decoder()],
["pendingTransactions", getArrayDecoder(getPendingTransactionDecoder())],
["config", getMultisigConfigDecoder()],
["emergencyConfig", getEmergencyConfigDecoder()],
["typeConfig", getMultisigTypeConfigDecoder()],
["reserved", fixDecoderSize(getBytesDecoder(), 64)]
]);
}
function getMultisigCodec() {
return combineCodec(getMultisigEncoder(), getMultisigDecoder());
}
function decodeMultisig(encodedAccount) {
return decodeAccount(
encodedAccount,
getMultisigDecoder()
);
}
async function fetchMultisig(rpc, address, config) {
const maybeAccount = await fetchMaybeMultisig(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeMultisig(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeMultisig(maybeAccount);
}
async function fetchAllMultisig(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeMultisig(rpc, addresses, config);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeMultisig(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeMultisig(maybeAccount));
}
var PROTOCOL_CONFIG_DISCRIMINATOR = new Uint8Array([
207,
91,
250,
28,
152,
179,
215,
209
]);
function getProtocolConfigDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
PROTOCOL_CONFIG_DISCRIMINATOR
);
}
function getProtocolConfigEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["authority", getAddressEncoder()],
["treasury", getAddressEncoder()],
["buybackPool", getAddressEncoder()],
["moderatorPool", getAddressEncoder()],
["escrowFeeBps", getU16Encoder()],
["agentRegistrationFee", getU64Encoder()],
["listingFee", getU64Encoder()],
["disputeFeeBps", getU16Encoder()],
["feesEnabled", getBooleanEncoder()],
["updatedAt", getI64Encoder()],
["bump", getU8Encoder()],
["reserved", fixEncoderSize(getBytesEncoder(), 64)]
]),
(value) => ({ ...value, discriminator: PROTOCOL_CONFIG_DISCRIMINATOR })
);
}
function getProtocolConfigDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["authority", getAddressDecoder()],
["treasury", getAddressDecoder()],
["buybackPool", getAddressDecoder()],
["moderatorPool", getAddressDecoder()],
["escrowFeeBps", getU16Decoder()],
["agentRegistrationFee", getU64Decoder()],
["listingFee", getU64Decoder()],
["disputeFeeBps", getU16Decoder()],
["feesEnabled", getBooleanDecoder()],
["updatedAt", getI64Decoder()],
["bump", getU8Decoder()],
["reserved", fixDecoderSize(getBytesDecoder(), 64)]
]);
}
function getProtocolConfigCodec() {
return combineCodec(getProtocolConfigEncoder(), getProtocolConfigDecoder());
}
function decodeProtocolConfig(encodedAccount) {
return decodeAccount(
encodedAccount,
getProtocolConfigDecoder()
);
}
async function fetchProtocolConfig(rpc, address, config) {
const maybeAccount = await fetchMaybeProtocolConfig(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeProtocolConfig(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeProtocolConfig(maybeAccount);
}
async function fetchAllProtocolConfig(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeProtocolConfig(
rpc,
addresses,
config
);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeProtocolConfig(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map(
(maybeAccount) => decodeProtocolConfig(maybeAccount)
);
}
function getProtocolConfigSize() {
return 230;
}
var RBAC_CONFIG_DISCRIMINATOR = new Uint8Array([
177,
94,
184,
202,
221,
112,
110,
38
]);
function getRbacConfigDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(RBAC_CONFIG_DISCRIMINATOR);
}
function getRbacConfigEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["authority", getAddressEncoder()],
["createdAt", getI64Encoder()],
["updatedAt", getI64Encoder()],
["version", getU8Encoder()],
["roles", getArrayEncoder(getRoleEncoder())],
["permissions", getArrayEncoder(getPermissionEncoder())],
["accessPolicies", getArrayEncoder(getAccessPolicyEncoder())],
["securityPolicies", getSecurityPoliciesEncoder()],
["auditConfig", getAccessAuditConfigEncoder()],
["emergencyAccess", getEmergencyAccessConfigEncoder()],
["reserved", fixEncoderSize(getBytesEncoder(), 128)]
]),
(value) => ({ ...value, discriminator: RBAC_CONFIG_DISCRIMINATOR })
);
}
function getRbacConfigDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["authority", getAddressDecoder()],
["createdAt", getI64Decoder()],
["updatedAt", getI64Decoder()],
["version", getU8Decoder()],
["roles", getArrayDecoder(getRoleDecoder())],
["permissions", getArrayDecoder(getPermissionDecoder())],
["accessPolicies", getArrayDecoder(getAccessPolicyDecoder())],
["securityPolicies", getSecurityPoliciesDecoder()],
["auditConfig", getAccessAuditConfigDecoder()],
["emergencyAccess", getEmergencyAccessConfigDecoder()],
["reserved", fixDecoderSize(getBytesDecoder(), 128)]
]);
}
function getRbacConfigCodec() {
return combineCodec(getRbacConfigEncoder(), getRbacConfigDecoder());
}
function decodeRbacConfig(encodedAccount) {
return decodeAccount(
encodedAccount,
getRbacConfigDecoder()
);
}
async function fetchRbacConfig(rpc, address, config) {
const maybeAccount = await fetchMaybeRbacConfig(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeRbacConfig(rpc, address, config) {
const maybeAccount = await fetchEncodedAccount(rpc, address, config);
return decodeRbacConfig(maybeAccount);
}
async function fetchAllRbacConfig(rpc, addresses, config) {
const maybeAccounts = await fetchAllMaybeRbacConfig(rpc, addresses, config);
assertAccountsExist(maybeAccounts);
return maybeAccounts;
}
async function fetchAllMaybeRbacConfig(rpc, addresses, config) {
const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
return maybeAccounts.map((maybeAccount) => decodeRbacConfig(maybeAccount));
}
var REENTRANCY_GUARD_DISCRIMINATOR = new Uint8Array([
207,
227,
141,
11,
194,
21,
193,
32
]);
function getReentrancyGuardDiscriminatorBytes() {
return fixEncoderSize(getBytesEncoder(), 8).encode(
REENTRANCY_GUARD_DISCRIMINATOR
);
}
function getReentrancyGuardEncoder() {
return transformEncoder(
getStructEncoder([
["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
["state", getReentrancyStateEncoder()],
["nonce", getU64Encoder()],
["lastInteraction", getI64Encoder()],
["authority", getAddressEncoder()],
["bump", getU8Encoder()]
]),
(value) => ({ ...value, discriminator: REENTRANCY_GUARD_DISCRIMINATOR })
);
}
function getReentrancyGuardDecoder() {
return getStructDecoder([
["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
["state", getReentrancyStateDecoder()],
["nonce", getU64Decoder()],
["lastInteraction", getI64Decoder()],
["authority", getAddressDecoder()],
["bump", getU8Decoder()]
]);
}
function getReentrancyGuardCodec() {
return combineCodec(getReentrancyGuardEncoder(), getReentrancyGuardDecoder());
}
function decodeReentrancyGuard(encodedAccount) {
return decodeAccount(
encodedAccount,
getReentrancyGuardDecoder()
);
}
async function fetchReentrancyGuard(rpc, address, config) {
const maybeAccount = await fetchMaybeReentrancyGuard(rpc, address, config);
assertAccountExists(maybeAccount);
return maybeAccount;
}
async function fetchMaybeReentrancyGuard(rpc, address, config) {
const maybeAccount = await fetchEncoded