@1upmonster/duel 0.1.7 → 0.2.1

package/dist/generated/duel/accounts/queue.js

@@ -0,0 +1,45 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { assertAccountExists, assertAccountsExist, combineCodec, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getArrayDecoder, getArrayEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, transformEncoder } from '@solana/kit';
+import { getMatchEntryDecoder, getMatchEntryEncoder, getPendingMatchDecoder, getPendingMatchEncoder, getQueueEntryDecoder, getQueueEntryEncoder } from '../types';
+export const QUEUE_DISCRIMINATOR = new Uint8Array([204, 167, 6, 247, 20, 33, 2, 188]);
+export function getQueueDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(QUEUE_DISCRIMINATOR); }
+/** Gets the encoder for {@link QueueArgs} account data. */
+export function getQueueEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['authority', getAddressEncoder()], ['tenant', getAddressEncoder()], ['bump', getU8Encoder()], ['matchCounter', getU64Encoder()], ['entries', getArrayEncoder(getQueueEntryEncoder())], ['matches', getArrayEncoder(getMatchEntryEncoder())], ['pendingMatches', getArrayEncoder(getPendingMatchEncoder())]]), (value) => ({ ...value, discriminator: QUEUE_DISCRIMINATOR }));
+}
+/** Gets the decoder for {@link Queue} account data. */
+export function getQueueDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['authority', getAddressDecoder()], ['tenant', getAddressDecoder()], ['bump', getU8Decoder()], ['matchCounter', getU64Decoder()], ['entries', getArrayDecoder(getQueueEntryDecoder())], ['matches', getArrayDecoder(getMatchEntryDecoder())], ['pendingMatches', getArrayDecoder(getPendingMatchDecoder())]]);
+}
+/** Gets the codec for {@link Queue} account data. */
+export function getQueueCodec() {
+    return combineCodec(getQueueEncoder(), getQueueDecoder());
+}
+export function decodeQueue(encodedAccount) {
+    return decodeAccount(encodedAccount, getQueueDecoder());
+}
+export async function fetchQueue(rpc, address, config) {
+    const maybeAccount = await fetchMaybeQueue(rpc, address, config);
+    assertAccountExists(maybeAccount);
+    return maybeAccount;
+}
+export async function fetchMaybeQueue(rpc, address, config) {
+    const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+    return decodeQueue(maybeAccount);
+}
+export async function fetchAllQueue(rpc, addresses, config) {
+    const maybeAccounts = await fetchAllMaybeQueue(rpc, addresses, config);
+    assertAccountsExist(maybeAccounts);
+    return maybeAccounts;
+}
+export async function fetchAllMaybeQueue(rpc, addresses, config) {
+    const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeQueue(maybeAccount));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../../src/generated/duel/accounts/queue.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { assertAccountExists, assertAccountsExist, combineCodec, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getArrayDecoder, getArrayEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, transformEncoder, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';\nimport { getMatchEntryDecoder, getMatchEntryEncoder, getPendingMatchDecoder, getPendingMatchEncoder, getQueueEntryDecoder, getQueueEntryEncoder, type MatchEntry, type MatchEntryArgs, type PendingMatch, type PendingMatchArgs, type QueueEntry, type QueueEntryArgs } from '../types';\n\nexport const QUEUE_DISCRIMINATOR = new Uint8Array([204, 167, 6, 247, 20, 33, 2, 188]);\n\nexport function getQueueDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(QUEUE_DISCRIMINATOR); }\n\nexport type Queue = { discriminator: ReadonlyUint8Array; authority: Address; tenant: Address; bump: number; matchCounter: bigint; entries: Array<QueueEntry>; matches: Array<MatchEntry>; pendingMatches: Array<PendingMatch>;  };\n\nexport type QueueArgs = { authority: Address; tenant: Address; bump: number; matchCounter: number | bigint; entries: Array<QueueEntryArgs>; matches: Array<MatchEntryArgs>; pendingMatches: Array<PendingMatchArgs>;  };\n\n/** Gets the encoder for {@link QueueArgs} account data. */\nexport function getQueueEncoder(): Encoder<QueueArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['authority', getAddressEncoder()], ['tenant', getAddressEncoder()], ['bump', getU8Encoder()], ['matchCounter', getU64Encoder()], ['entries', getArrayEncoder(getQueueEntryEncoder())], ['matches', getArrayEncoder(getMatchEntryEncoder())], ['pendingMatches', getArrayEncoder(getPendingMatchEncoder())]]), (value) => ({ ...value, discriminator: QUEUE_DISCRIMINATOR }));\n}\n\n/** Gets the decoder for {@link Queue} account data. */\nexport function getQueueDecoder(): Decoder<Queue> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['authority', getAddressDecoder()], ['tenant', getAddressDecoder()], ['bump', getU8Decoder()], ['matchCounter', getU64Decoder()], ['entries', getArrayDecoder(getQueueEntryDecoder())], ['matches', getArrayDecoder(getMatchEntryDecoder())], ['pendingMatches', getArrayDecoder(getPendingMatchDecoder())]]);\n}\n\n/** Gets the codec for {@link Queue} account data. */\nexport function getQueueCodec(): Codec<QueueArgs, Queue> {\n    return combineCodec(getQueueEncoder(), getQueueDecoder());\n}\n\nexport function decodeQueue<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Queue, TAddress>;\nexport function decodeQueue<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Queue, TAddress>;\nexport function decodeQueue<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<Queue, TAddress> | MaybeAccount<Queue, TAddress> {\n  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getQueueDecoder());\n}\n\nexport async function fetchQueue<TAddress extends string = string>(\n  rpc: Parameters<typeof fetchEncodedAccount>[0],\n  address: Address<TAddress>,\n  config?: FetchAccountConfig,\n): Promise<Account<Queue, TAddress>> {\n  const maybeAccount = await fetchMaybeQueue(rpc, address, config);\n  assertAccountExists(maybeAccount);\n  return maybeAccount;\n}\n\nexport async function fetchMaybeQueue<TAddress extends string = string>(\n  rpc: Parameters<typeof fetchEncodedAccount>[0],\n  address: Address<TAddress>,\n  config?: FetchAccountConfig,\n): Promise<MaybeAccount<Queue, TAddress>> {\n  const maybeAccount = await fetchEncodedAccount(rpc, address, config);\n  return decodeQueue(maybeAccount);\n}\n\nexport async function fetchAllQueue(\n  rpc: Parameters<typeof fetchEncodedAccounts>[0],\n  addresses: Array<Address>,\n  config?: FetchAccountsConfig,\n): Promise<Account<Queue>[]> {\n  const maybeAccounts = await fetchAllMaybeQueue(rpc, addresses, config);\n  assertAccountsExist(maybeAccounts);\n  return maybeAccounts;\n}\n\nexport async function fetchAllMaybeQueue(\n  rpc: Parameters<typeof fetchEncodedAccounts>[0],\n  addresses: Array<Address>,\n  config?: FetchAccountsConfig,\n): Promise<MaybeAccount<Queue>[]> {\n  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);\n  return maybeAccounts.map((maybeAccount) => decodeQueue(maybeAccount));\n}"]}

package/dist/generated/duel/accounts/tenant.d.ts

@@ -0,0 +1,41 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { fetchEncodedAccount, fetchEncodedAccounts, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type Option, type OptionOrNullable, type ReadonlyUint8Array } from '@solana/kit';
+export declare const TENANT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getTenantDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type Tenant = {
+    discriminator: ReadonlyUint8Array;
+    authority: Address;
+    tenantProgramId: Address;
+    eloOffset: number;
+    eloSize: number;
+    eloWindow: bigint;
+    callbackProgramId: Option<Address>;
+    callbackDiscriminator: Option<ReadonlyUint8Array>;
+};
+export type TenantArgs = {
+    authority: Address;
+    tenantProgramId: Address;
+    eloOffset: number;
+    eloSize: number;
+    eloWindow: number | bigint;
+    callbackProgramId: OptionOrNullable<Address>;
+    callbackDiscriminator: OptionOrNullable<ReadonlyUint8Array>;
+};
+/** Gets the encoder for {@link TenantArgs} account data. */
+export declare function getTenantEncoder(): Encoder<TenantArgs>;
+/** Gets the decoder for {@link Tenant} account data. */
+export declare function getTenantDecoder(): Decoder<Tenant>;
+/** Gets the codec for {@link Tenant} account data. */
+export declare function getTenantCodec(): Codec<TenantArgs, Tenant>;
+export declare function decodeTenant<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Tenant, TAddress>;
+export declare function decodeTenant<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Tenant, TAddress>;
+export declare function fetchTenant<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Tenant, TAddress>>;
+export declare function fetchMaybeTenant<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Tenant, TAddress>>;
+export declare function fetchAllTenant(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<Tenant>[]>;
+export declare function fetchAllMaybeTenant(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<Tenant>[]>;

package/dist/generated/duel/accounts/tenant.js

@@ -0,0 +1,44 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { assertAccountExists, assertAccountsExist, combineCodec, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getBytesDecoder, getBytesEncoder, getOptionDecoder, getOptionEncoder, getStructDecoder, getStructEncoder, getU32Decoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, transformEncoder } from '@solana/kit';
+export const TENANT_DISCRIMINATOR = new Uint8Array([61, 43, 215, 51, 232, 242, 209, 170]);
+export function getTenantDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(TENANT_DISCRIMINATOR); }
+/** Gets the encoder for {@link TenantArgs} account data. */
+export function getTenantEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['authority', getAddressEncoder()], ['tenantProgramId', getAddressEncoder()], ['eloOffset', getU32Encoder()], ['eloSize', getU8Encoder()], ['eloWindow', getU64Encoder()], ['callbackProgramId', getOptionEncoder(getAddressEncoder())], ['callbackDiscriminator', getOptionEncoder(fixEncoderSize(getBytesEncoder(), 8))]]), (value) => ({ ...value, discriminator: TENANT_DISCRIMINATOR }));
+}
+/** Gets the decoder for {@link Tenant} account data. */
+export function getTenantDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['authority', getAddressDecoder()], ['tenantProgramId', getAddressDecoder()], ['eloOffset', getU32Decoder()], ['eloSize', getU8Decoder()], ['eloWindow', getU64Decoder()], ['callbackProgramId', getOptionDecoder(getAddressDecoder())], ['callbackDiscriminator', getOptionDecoder(fixDecoderSize(getBytesDecoder(), 8))]]);
+}
+/** Gets the codec for {@link Tenant} account data. */
+export function getTenantCodec() {
+    return combineCodec(getTenantEncoder(), getTenantDecoder());
+}
+export function decodeTenant(encodedAccount) {
+    return decodeAccount(encodedAccount, getTenantDecoder());
+}
+export async function fetchTenant(rpc, address, config) {
+    const maybeAccount = await fetchMaybeTenant(rpc, address, config);
+    assertAccountExists(maybeAccount);
+    return maybeAccount;
+}
+export async function fetchMaybeTenant(rpc, address, config) {
+    const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+    return decodeTenant(maybeAccount);
+}
+export async function fetchAllTenant(rpc, addresses, config) {
+    const maybeAccounts = await fetchAllMaybeTenant(rpc, addresses, config);
+    assertAccountsExist(maybeAccounts);
+    return maybeAccounts;
+}
+export async function fetchAllMaybeTenant(rpc, addresses, config) {
+    const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeTenant(maybeAccount));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenant.js","sourceRoot":"","sources":["../../../../src/generated/duel/accounts/tenant.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAwP,MAAM,aAAa,CAAC;AAE/pB,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAE1F,MAAM,UAAU,2BAA2B,KAAK,OAAO,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAM3H,4DAA4D;AAC5D,MAAM,UAAU,gBAAgB;IAC5B,OAAO,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,CAAC,eAAe,EAAE,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,mBAAmB,EAAE,gBAAgB,CAAC,iBAAiB,EAAE,CAAC,CAAC,EAAE,CAAC,uBAAuB,EAAE,gBAAgB,CAAC,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,CAAC,CAAC,CAAC;AACre,CAAC;AAED,wDAAwD;AACxD,MAAM,UAAU,gBAAgB;IAC5B,OAAO,gBAAgB,CAAC,CAAC,CAAC,eAAe,EAAE,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,mBAAmB,EAAE,gBAAgB,CAAC,iBAAiB,EAAE,CAAC,CAAC,EAAE,CAAC,uBAAuB,EAAE,gBAAgB,CAAC,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACnZ,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,cAAc;IAC1B,OAAO,YAAY,CAAC,gBAAgB,EAAE,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAChE,CAAC;AAID,MAAM,UAAU,YAAY,CAAmC,cAAwE;IACrI,OAAO,aAAa,CAAC,cAA+C,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC5F,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,GAA8C,EAC9C,OAA0B,EAC1B,MAA2B;IAE3B,MAAM,YAAY,GAAG,MAAM,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAClE,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAClC,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,GAA8C,EAC9C,OAA0B,EAC1B,MAA2B;IAE3B,MAAM,YAAY,GAAG,MAAM,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IACrE,OAAO,YAAY,CAAC,YAAY,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,GAA+C,EAC/C,SAAyB,EACzB,MAA4B;IAE5B,MAAM,aAAa,GAAG,MAAM,mBAAmB,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACxE,mBAAmB,CAAC,aAAa,CAAC,CAAC;IACnC,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,GAA+C,EAC/C,SAAyB,EACzB,MAA4B;IAE5B,MAAM,aAAa,GAAG,MAAM,oBAAoB,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACzE,OAAO,aAAa,CAAC,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC;AACzE,CAAC","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { assertAccountExists, assertAccountsExist, combineCodec, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getBytesDecoder, getBytesEncoder, getOptionDecoder, getOptionEncoder, getStructDecoder, getStructEncoder, getU32Decoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, transformEncoder, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type Option, type OptionOrNullable, type ReadonlyUint8Array } from '@solana/kit';\n\nexport const TENANT_DISCRIMINATOR = new Uint8Array([61, 43, 215, 51, 232, 242, 209, 170]);\n\nexport function getTenantDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(TENANT_DISCRIMINATOR); }\n\nexport type Tenant = { discriminator: ReadonlyUint8Array; authority: Address; tenantProgramId: Address; eloOffset: number; eloSize: number; eloWindow: bigint; callbackProgramId: Option<Address>; callbackDiscriminator: Option<ReadonlyUint8Array>;  };\n\nexport type TenantArgs = { authority: Address; tenantProgramId: Address; eloOffset: number; eloSize: number; eloWindow: number | bigint; callbackProgramId: OptionOrNullable<Address>; callbackDiscriminator: OptionOrNullable<ReadonlyUint8Array>;  };\n\n/** Gets the encoder for {@link TenantArgs} account data. */\nexport function getTenantEncoder(): Encoder<TenantArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['authority', getAddressEncoder()], ['tenantProgramId', getAddressEncoder()], ['eloOffset', getU32Encoder()], ['eloSize', getU8Encoder()], ['eloWindow', getU64Encoder()], ['callbackProgramId', getOptionEncoder(getAddressEncoder())], ['callbackDiscriminator', getOptionEncoder(fixEncoderSize(getBytesEncoder(), 8))]]), (value) => ({ ...value, discriminator: TENANT_DISCRIMINATOR }));\n}\n\n/** Gets the decoder for {@link Tenant} account data. */\nexport function getTenantDecoder(): Decoder<Tenant> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['authority', getAddressDecoder()], ['tenantProgramId', getAddressDecoder()], ['eloOffset', getU32Decoder()], ['eloSize', getU8Decoder()], ['eloWindow', getU64Decoder()], ['callbackProgramId', getOptionDecoder(getAddressDecoder())], ['callbackDiscriminator', getOptionDecoder(fixDecoderSize(getBytesDecoder(), 8))]]);\n}\n\n/** Gets the codec for {@link Tenant} account data. */\nexport function getTenantCodec(): Codec<TenantArgs, Tenant> {\n    return combineCodec(getTenantEncoder(), getTenantDecoder());\n}\n\nexport function decodeTenant<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Tenant, TAddress>;\nexport function decodeTenant<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Tenant, TAddress>;\nexport function decodeTenant<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<Tenant, TAddress> | MaybeAccount<Tenant, TAddress> {\n  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getTenantDecoder());\n}\n\nexport async function fetchTenant<TAddress extends string = string>(\n  rpc: Parameters<typeof fetchEncodedAccount>[0],\n  address: Address<TAddress>,\n  config?: FetchAccountConfig,\n): Promise<Account<Tenant, TAddress>> {\n  const maybeAccount = await fetchMaybeTenant(rpc, address, config);\n  assertAccountExists(maybeAccount);\n  return maybeAccount;\n}\n\nexport async function fetchMaybeTenant<TAddress extends string = string>(\n  rpc: Parameters<typeof fetchEncodedAccount>[0],\n  address: Address<TAddress>,\n  config?: FetchAccountConfig,\n): Promise<MaybeAccount<Tenant, TAddress>> {\n  const maybeAccount = await fetchEncodedAccount(rpc, address, config);\n  return decodeTenant(maybeAccount);\n}\n\nexport async function fetchAllTenant(\n  rpc: Parameters<typeof fetchEncodedAccounts>[0],\n  addresses: Array<Address>,\n  config?: FetchAccountsConfig,\n): Promise<Account<Tenant>[]> {\n  const maybeAccounts = await fetchAllMaybeTenant(rpc, addresses, config);\n  assertAccountsExist(maybeAccounts);\n  return maybeAccounts;\n}\n\nexport async function fetchAllMaybeTenant(\n  rpc: Parameters<typeof fetchEncodedAccounts>[0],\n  addresses: Array<Address>,\n  config?: FetchAccountsConfig,\n): Promise<MaybeAccount<Tenant>[]> {\n  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);\n  return maybeAccounts.map((maybeAccount) => decodeTenant(maybeAccount));\n}"]}

package/dist/generated/duel/errors/duel.d.ts

@@ -0,0 +1,33 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type Address, type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, type SolanaError } from '@solana/kit';
+/** InvalidTenant: Account does not belong to the specified Tenant Program */
+export declare const DUEL_ERROR__INVALID_TENANT = 6000;
+/** DataTooSmall: Account data too small for ELO read */
+export declare const DUEL_ERROR__DATA_TOO_SMALL = 6001;
+/** Unauthorized: Unauthorized access */
+export declare const DUEL_ERROR__UNAUTHORIZED = 6002;
+/** InvalidEloSize: Invalid ELO size (must be 1, 2, 4, or 8 bytes) */
+export declare const DUEL_ERROR__INVALID_ELO_SIZE = 6003;
+/** InvalidTicketStatus: Invalid ticket status for this operation */
+export declare const DUEL_ERROR__INVALID_TICKET_STATUS = 6004;
+/** InvalidTicketAccount: Invalid ticket account */
+export declare const DUEL_ERROR__INVALID_TICKET_ACCOUNT = 6005;
+/** MissingCallbackProgram: Missing or invalid callback program in remaining accounts */
+export declare const DUEL_ERROR__MISSING_CALLBACK_PROGRAM = 6006;
+export type DuelError = typeof DUEL_ERROR__DATA_TOO_SMALL | typeof DUEL_ERROR__INVALID_ELO_SIZE | typeof DUEL_ERROR__INVALID_TENANT | typeof DUEL_ERROR__INVALID_TICKET_ACCOUNT | typeof DUEL_ERROR__INVALID_TICKET_STATUS | typeof DUEL_ERROR__MISSING_CALLBACK_PROGRAM | typeof DUEL_ERROR__UNAUTHORIZED;
+export declare function getDuelErrorMessage(code: DuelError): string;
+export declare function isDuelError<TProgramErrorCode extends DuelError>(error: unknown, transactionMessage: {
+    instructions: Record<number, {
+        programAddress: Address;
+    }>;
+}, code?: TProgramErrorCode): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> & Readonly<{
+    context: Readonly<{
+        code: TProgramErrorCode;
+    }>;
+}>;

package/dist/generated/duel/errors/duel.js

@@ -0,0 +1,37 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { isProgramError } from '@solana/kit';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+/** InvalidTenant: Account does not belong to the specified Tenant Program */
+export const DUEL_ERROR__INVALID_TENANT = 0x1770; // 6000
+/** DataTooSmall: Account data too small for ELO read */
+export const DUEL_ERROR__DATA_TOO_SMALL = 0x1771; // 6001
+/** Unauthorized: Unauthorized access */
+export const DUEL_ERROR__UNAUTHORIZED = 0x1772; // 6002
+/** InvalidEloSize: Invalid ELO size (must be 1, 2, 4, or 8 bytes) */
+export const DUEL_ERROR__INVALID_ELO_SIZE = 0x1773; // 6003
+/** InvalidTicketStatus: Invalid ticket status for this operation */
+export const DUEL_ERROR__INVALID_TICKET_STATUS = 0x1774; // 6004
+/** InvalidTicketAccount: Invalid ticket account */
+export const DUEL_ERROR__INVALID_TICKET_ACCOUNT = 0x1775; // 6005
+/** MissingCallbackProgram: Missing or invalid callback program in remaining accounts */
+export const DUEL_ERROR__MISSING_CALLBACK_PROGRAM = 0x1776; // 6006
+let duelErrorMessages;
+if (process.env.NODE_ENV !== 'production') {
+    duelErrorMessages = { [DUEL_ERROR__DATA_TOO_SMALL]: `Account data too small for ELO read`, [DUEL_ERROR__INVALID_ELO_SIZE]: `Invalid ELO size (must be 1, 2, 4, or 8 bytes)`, [DUEL_ERROR__INVALID_TENANT]: `Account does not belong to the specified Tenant Program`, [DUEL_ERROR__INVALID_TICKET_ACCOUNT]: `Invalid ticket account`, [DUEL_ERROR__INVALID_TICKET_STATUS]: `Invalid ticket status for this operation`, [DUEL_ERROR__MISSING_CALLBACK_PROGRAM]: `Missing or invalid callback program in remaining accounts`, [DUEL_ERROR__UNAUTHORIZED]: `Unauthorized access` };
+}
+export function getDuelErrorMessage(code) {
+    if (process.env.NODE_ENV !== 'production') {
+        return duelErrorMessages[code];
+    }
+    return 'Error message not available in production bundles.';
+}
+export function isDuelError(error, transactionMessage, code) {
+    return isProgramError(error, transactionMessage, DUEL_PROGRAM_ADDRESS, code);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/generated/duel/errors/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './duel';

package/dist/generated/duel/errors/index.js

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './duel';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2R1ZWwvZXJyb3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGlzIGNvZGUgd2FzIEFVVE9HRU5FUkFURUQgdXNpbmcgdGhlIENvZGFtYSBsaWJyYXJ5LlxuICogUGxlYXNlIERPIE5PVCBFRElUIFRISVMgRklMRSwgaW5zdGVhZCB1c2UgdmlzaXRvcnNcbiAqIHRvIGFkZCBmZWF0dXJlcywgdGhlbiByZXJ1biBDb2RhbWEgdG8gdXBkYXRlIGl0LlxuICpcbiAqIEBzZWUgaHR0cHM6Ly9naXRodWIuY29tL2NvZGFtYS1pZGwvY29kYW1hXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9kdWVsJzsiXX0=

package/dist/generated/duel/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './accounts';
+export * from './errors';
+export * from './instructions';
+export * from './programs';
+export * from './types';

package/dist/generated/duel/index.js

@@ -0,0 +1,13 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './accounts';
+export * from './errors';
+export * from './instructions';
+export * from './programs';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2R1ZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGhpcyBjb2RlIHdhcyBBVVRPR0VORVJBVEVEIHVzaW5nIHRoZSBDb2RhbWEgbGlicmFyeS5cbiAqIFBsZWFzZSBETyBOT1QgRURJVCBUSElTIEZJTEUsIGluc3RlYWQgdXNlIHZpc2l0b3JzXG4gKiB0byBhZGQgZmVhdHVyZXMsIHRoZW4gcmVydW4gQ29kYW1hIHRvIHVwZGF0ZSBpdC5cbiAqXG4gKiBAc2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9jb2RhbWEtaWRsL2NvZGFtYVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vYWNjb3VudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnN0cnVjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9ncmFtcyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJzsiXX0=

package/dist/generated/duel/instructions/cancelTicket.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlySignerAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount } from '@solana/kit';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const CANCEL_TICKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getCancelTicketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type CancelTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? ReadonlySignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;
+export type CancelTicketInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+export type CancelTicketInstructionDataArgs = {};
+export declare function getCancelTicketInstructionDataEncoder(): FixedSizeEncoder<CancelTicketInstructionDataArgs>;
+export declare function getCancelTicketInstructionDataDecoder(): FixedSizeDecoder<CancelTicketInstructionData>;
+export declare function getCancelTicketInstructionDataCodec(): FixedSizeCodec<CancelTicketInstructionDataArgs, CancelTicketInstructionData>;
+export type CancelTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> = {
+    ticket?: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+};
+export declare function getCancelTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CancelTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>>;
+export type CancelTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> = {
+    ticket: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+};
+export declare function getCancelTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CancelTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: {
+    programAddress?: TProgramAddress;
+}): CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>;
+export type ParsedCancelTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        ticket: TAccountMetas[0];
+        tenant: TAccountMetas[1];
+        player: TAccountMetas[2];
+    };
+    data: CancelTicketInstructionData;
+};
+export declare function parseCancelTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCancelTicketInstruction<TProgram, TAccountMetas>;

package/dist/generated/duel/instructions/cancelTicket.js

@@ -0,0 +1,56 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export const CANCEL_TICKET_DISCRIMINATOR = new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143]);
+export function getCancelTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CANCEL_TICKET_DISCRIMINATOR); }
+export function getCancelTicketInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CANCEL_TICKET_DISCRIMINATOR }));
+}
+export function getCancelTicketInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getCancelTicketInstructionDataCodec() {
+    return combineCodec(getCancelTicketInstructionDataEncoder(), getCancelTicketInstructionDataDecoder());
+}
+export async function getCancelTicketInstructionAsync(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.ticket.value) {
+        accounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function getCancelTicketInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function parseCancelTicketInstruction(instruction) {
+    if (instruction.accounts.length < 3) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 3 });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCancelTicketInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cancelTicket.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/cancelTicket.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlySignerAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount } from '@solana/kit';\nimport { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { DUEL_PROGRAM_ADDRESS } from '../programs';\n\nexport const CANCEL_TICKET_DISCRIMINATOR = new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143]);\n\nexport function getCancelTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CANCEL_TICKET_DISCRIMINATOR); }\n\nexport type CancelTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? ReadonlySignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;\n\nexport type CancelTicketInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type CancelTicketInstructionDataArgs = {  };\n\nexport function getCancelTicketInstructionDataEncoder(): FixedSizeEncoder<CancelTicketInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CANCEL_TICKET_DISCRIMINATOR }));\n}\n\nexport function getCancelTicketInstructionDataDecoder(): FixedSizeDecoder<CancelTicketInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getCancelTicketInstructionDataCodec(): FixedSizeCodec<CancelTicketInstructionDataArgs, CancelTicketInstructionData> {\n    return combineCodec(getCancelTicketInstructionDataEncoder(), getCancelTicketInstructionDataDecoder());\n}\n\nexport type CancelTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {\n  ticket?: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\n}\n\nexport async function getCancelTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CancelTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): Promise<CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.ticket.value) {\naccounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"player\", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"tenant\", accounts.tenant.value))] });\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress } as CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);\n}\n\nexport type CancelTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {\n  ticket: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\n}\n\nexport function getCancelTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CancelTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress } as CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);\n}\n\nexport type ParsedCancelTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nticket: TAccountMetas[0];\ntenant: TAccountMetas[1];\nplayer: TAccountMetas[2];\n};\ndata: CancelTicketInstructionData; };\n\nexport function parseCancelTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCancelTicketInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 3) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 3 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCancelTicketInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/duel/instructions/closeTicket.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const CLOSE_TICKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getCloseTicketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type CloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;
+export type CloseTicketInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+export type CloseTicketInstructionDataArgs = {};
+export declare function getCloseTicketInstructionDataEncoder(): FixedSizeEncoder<CloseTicketInstructionDataArgs>;
+export declare function getCloseTicketInstructionDataDecoder(): FixedSizeDecoder<CloseTicketInstructionData>;
+export declare function getCloseTicketInstructionDataCodec(): FixedSizeCodec<CloseTicketInstructionDataArgs, CloseTicketInstructionData>;
+export type CloseTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> = {
+    ticket?: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+};
+export declare function getCloseTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>>;
+export type CloseTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> = {
+    ticket: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+};
+export declare function getCloseTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: {
+    programAddress?: TProgramAddress;
+}): CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>;
+export type ParsedCloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        ticket: TAccountMetas[0];
+        tenant: TAccountMetas[1];
+        player: TAccountMetas[2];
+    };
+    data: CloseTicketInstructionData;
+};
+export declare function parseCloseTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCloseTicketInstruction<TProgram, TAccountMetas>;

package/dist/generated/duel/instructions/closeTicket.js

@@ -0,0 +1,56 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export const CLOSE_TICKET_DISCRIMINATOR = new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117]);
+export function getCloseTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CLOSE_TICKET_DISCRIMINATOR); }
+export function getCloseTicketInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CLOSE_TICKET_DISCRIMINATOR }));
+}
+export function getCloseTicketInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getCloseTicketInstructionDataCodec() {
+    return combineCodec(getCloseTicketInstructionDataEncoder(), getCloseTicketInstructionDataDecoder());
+}
+export async function getCloseTicketInstructionAsync(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.ticket.value) {
+        accounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function getCloseTicketInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } };
+    const accounts = originalAccounts;
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function parseCloseTicketInstruction(instruction) {
+    if (instruction.accounts.length < 3) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 3 });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCloseTicketInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"closeTicket.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/closeTicket.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,yDAAyD,EAAE,WAAW,EAAE,gBAAgB,EAAgU,MAAM,aAAa,CAAC;AACtlB,OAAO,EAAE,qBAAqB,EAAE,wCAAwC,EAAmC,MAAM,6BAA6B,CAAC;AAC/I,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAI,UAAU,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAEhG,MAAM,UAAU,gCAAgC,KAAK,OAAO,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC;AAStI,MAAM,UAAU,oCAAoC;IAChD,OAAO,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,CAAC,eAAe,EAAE,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,aAAa,EAAE,0BAA0B,EAAE,CAAC,CAAC,CAAC;AAC/K,CAAC;AAED,MAAM,UAAU,oCAAoC;IAChD,OAAO,gBAAgB,CAAC,CAAC,CAAC,eAAe,EAAE,cAAc,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACvF,CAAC;AAED,MAAM,UAAU,kCAAkC;IAC9C,OAAO,YAAY,CAAC,oCAAoC,EAAE,EAAE,oCAAoC,EAAE,CAAC,CAAC;AACxG,CAAC;AAQD,MAAM,CAAC,KAAK,UAAU,8BAA8B,CAA6J,KAA4E,EAAE,MAA6C;IAC1U,mBAAmB;IACrB,MAAM,cAAc,GAAG,MAAM,EAAE,cAAc,IAAI,oBAAoB,CAAC;IAErE,qBAAqB;IACtB,MAAM,gBAAgB,GAAG,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,CAAA;IAC7M,MAAM,QAAQ,GAAG,gBAAqF,CAAC;IAGvG,0BAA0B;IAC1B,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAC7B,QAAQ,CAAC,MAAM,CAAC,KAAK,GAAG,MAAM,wBAAwB,CAAC,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,eAAe,EAAE,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,CAAC,MAAM,CAAC,wCAAwC,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,iBAAiB,EAAE,CAAC,MAAM,CAAC,wCAAwC,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC3W,CAAC;IAED,MAAM,cAAc,GAAG,qBAAqB,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;IAC1E,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,oCAAoC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,cAAc,EAA6F,CAAC,CAAC;AAC1U,CAAC;AAQD,MAAM,UAAU,yBAAyB,CAA6J,KAAuE,EAAE,MAA6C;IAC1T,mBAAmB;IACrB,MAAM,cAAc,GAAG,MAAM,EAAE,cAAc,IAAI,oBAAoB,CAAC;IAErE,qBAAqB;IACtB,MAAM,gBAAgB,GAAG,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,CAAA;IAC7M,MAAM,QAAQ,GAAG,gBAAqF,CAAC;IAKvG,MAAM,cAAc,GAAG,qBAAqB,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;IAC1E,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,oCAAoC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,cAAc,EAA6F,CAAC,CAAC;AAC1U,CAAC;AAUD,MAAM,UAAU,2BAA2B,CAAwE,WAAqH;IACtO,IAAI,WAAW,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,WAAW,CAAC,yDAAyD,EAAE,EAAE,kBAAkB,EAAE,WAAW,CAAC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,EAAE,CAAC,CAAC;IACjK,CAAC;IACD,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,MAAM,cAAc,GAAG,GAAG,EAAE;QAC1B,MAAM,WAAW,GAAI,WAAW,CAAC,QAA0B,CAAC,YAAY,CAAE,CAAC;QAC3E,YAAY,IAAI,CAAC,CAAC;QAClB,OAAO,WAAW,CAAC;IACrB,CAAC,CAAA;IACC,OAAO,EAAE,cAAc,EAAE,WAAW,CAAC,cAAc,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,EAAE,EAAE,IAAI,EAAE,oCAAoC,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;AAC3N,CAAC","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';\nimport { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { DUEL_PROGRAM_ADDRESS } from '../programs';\n\nexport const CLOSE_TICKET_DISCRIMINATOR = new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117]);\n\nexport function getCloseTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CLOSE_TICKET_DISCRIMINATOR); }\n\nexport type CloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;\n\nexport type CloseTicketInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type CloseTicketInstructionDataArgs = {  };\n\nexport function getCloseTicketInstructionDataEncoder(): FixedSizeEncoder<CloseTicketInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CLOSE_TICKET_DISCRIMINATOR }));\n}\n\nexport function getCloseTicketInstructionDataDecoder(): FixedSizeDecoder<CloseTicketInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getCloseTicketInstructionDataCodec(): FixedSizeCodec<CloseTicketInstructionDataArgs, CloseTicketInstructionData> {\n    return combineCodec(getCloseTicketInstructionDataEncoder(), getCloseTicketInstructionDataDecoder());\n}\n\nexport type CloseTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {\n  ticket?: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\n}\n\nexport async function getCloseTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): Promise<CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.ticket.value) {\naccounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"player\", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"tenant\", accounts.tenant.value))] });\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress } as CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);\n}\n\nexport type CloseTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {\n  ticket: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\n}\n\nexport function getCloseTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress } as CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);\n}\n\nexport type ParsedCloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nticket: TAccountMetas[0];\ntenant: TAccountMetas[1];\nplayer: TAccountMetas[2];\n};\ndata: CloseTicketInstructionData; };\n\nexport function parseCloseTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCloseTicketInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 3) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 3 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCloseTicketInstructionDataDecoder().decode(instruction.data) };\n}"]}