@kippurocks/libticketto-papi
Version:
A Kippu implementation of The Ticketto Protocol with Polkadot-API
257 lines (256 loc) • 10.4 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import { AttendancePolicyType, } from "@ticketto/types";
import { ss58Address } from "@polkadot-labs/hdkd-helpers";
import { currency, TOKEN, } from "./types.js";
import { inject, injectable } from "inversify";
import { Binary } from "polkadot-api";
import { TransactionSubmitter } from "./submitter.js";
import { TickettoModelConverter } from "./tickettoModel.js";
let KippuEventsCalls = class KippuEventsCalls {
accountProvider;
client;
contract;
submitter;
constructor(accountProvider, client, contract, submitter) {
this.accountProvider = accountProvider;
this.client = client;
this.contract = contract;
this.submitter = submitter;
}
intoContractAttendancePolicy(attendancePolicy) {
switch (attendancePolicy.type) {
case AttendancePolicyType.Single:
return {
type: "Single",
value: undefined,
};
case AttendancePolicyType.Multiple: {
return {
type: "Multiple",
value: {
max: attendancePolicy.max,
maybe_until: attendancePolicy.until,
},
};
}
case AttendancePolicyType.Unlimited: {
return {
type: "Unlimited",
value: {
maybe_until: attendancePolicy.until,
},
};
}
}
}
async createEvent(event) {
const origin = this.accountProvider.getAccountId();
const { UNIT } = await currency(this.client);
const data = {
name: Binary.fromText(event.name),
capacity: BigInt(event.capacity),
ticket_class: {
attendance_policy: this.intoContractAttendancePolicy(event.class.attendancePolicy),
price: {
asset: {
type: "Sibling",
value: {
id: 1000, // Asset Hub
pallet: 50, // pallet_assets
index: event.class.ticketprice.asset.id,
},
},
amount: BigInt(event.class.ticketprice.amount),
},
maybe_restrictions: {
cannot_resale: event.class.ticketRestrictions.cannotResale,
cannot_transfer: event.class.ticketRestrictions.cannotTransfer,
},
},
maybe_dates: event.dates,
};
const result = await this.contract.query("create_event", {
origin,
data,
value: UNIT,
});
if (!result.success) {
throw new Error("CannotCreateEvent");
}
const [eventId] = result.value.response;
const tx = this.contract.send("create_event", {
origin,
data,
value: UNIT,
gasLimit: result.value.gasRequired,
});
await this.submitter.signAndSubmit(tx);
return eventId;
}
async update(id, event) {
const origin = this.accountProvider.getAccountId();
const data = {
event_id: id,
maybe_name: event.name ? Binary.fromText(event.name) : undefined,
maybe_capacity: event.capacity ? BigInt(event.capacity) : undefined,
maybe_ticket_class: event.class
? {
attendance_policy: this.intoContractAttendancePolicy(event.class.attendancePolicy),
price: {
asset: {
type: "Sibling",
value: {
id: 1000, // Asset Hub
pallet: 50, // pallet_assets
index: event.class.ticketprice.asset.id,
},
},
amount: BigInt(event.class.ticketprice.amount),
},
maybe_restrictions: {
cannot_resale: event.class.ticketRestrictions.cannotResale,
cannot_transfer: event.class.ticketRestrictions.cannotTransfer,
},
}
: undefined,
maybe_dates: event.dates,
};
const result = await this.contract.query("update", {
origin,
data,
});
if (!result.success) {
throw new Error("CannotUpdateEvent");
}
const tx = this.contract.send("update", {
origin,
data,
gasLimit: result.value.gasRequired,
});
await this.submitter.signAndSubmit(tx);
}
async bumpState(id) {
const origin = this.accountProvider.getAccountId();
const result = await this.contract.query("bump_state", {
origin,
data: {
event_id: id,
},
});
if (!result.success) {
throw new Error(result.value.type);
}
const tx = this.contract.send("bump_state", {
origin,
data: {
event_id: id,
},
gasLimit: result.value.gasRequired,
});
await this.submitter.signAndSubmit(tx);
}
transferOrganiser(_id, _newOrganiser) {
// TODO: Requires an update in the contract.
//
// Won't do for now, because it implies updating the owner of potentially
// thousands of tickets.
throw new Error("Method not implemented.");
}
};
KippuEventsCalls = __decorate([
injectable(),
__param(0, inject(TOKEN.ACCUNT_PROVIDER)),
__param(1, inject(TOKEN.POLKADOT_CLIENT)),
__param(2, inject(TOKEN.EVENTS_CONTRACT)),
__param(3, inject(TOKEN.SUBMITTER)),
__metadata("design:paramtypes", [Object, Object, Object, TransactionSubmitter])
], KippuEventsCalls);
export { KippuEventsCalls };
let KippuEventsStorage = class KippuEventsStorage {
accountProvider;
api;
eventsContractAddress;
contract;
converter;
merchantId;
constructor(accountProvider, api, eventsContractAddress, contract, converter, merchantId) {
this.accountProvider = accountProvider;
this.api = api;
this.eventsContractAddress = eventsContractAddress;
this.contract = contract;
this.converter = converter;
this.merchantId = merchantId;
}
async get(id) {
const response = await this.contract.query("get", {
origin: this.accountProvider.getAccountId(),
data: {
event_id: id,
},
});
if (!response.success) {
return undefined;
}
const event = response.value.response;
if (event === undefined) {
return undefined;
}
const dates = event.dates
? event.dates.map(([s, e]) => [s, e])
: undefined;
const date = dates?.[0] ?? undefined;
return {
id,
name: event.name.asText(),
state: this.converter.intoTickettoEventState(event.state.type),
...(dates ? { dates } : {}),
...(date ? { date } : {}),
organiser: ss58Address(event.organiser.asBytes()),
capacity: event?.capacity ?? 0,
class: {
attendancePolicy: this.converter.intoTickettoAttendancePolicy(event.class.attendance_policy),
ticketprice: {
amount: event.class.price.amount,
asset: await this.converter.assetMetadata(event.class.price.asset),
},
ticketRestrictions: {
cannotResale: event.class.maybe_restrictions?.cannot_resale || false,
cannotTransfer: event.class.maybe_restrictions?.cannot_transfer || false,
},
},
};
}
async all() {
const events = await this.api.query.ListingsCatalog.CollectionAccount.getEntries(this.eventsContractAddress);
return Promise.all(events.map(({ keyArgs: [_, [__, id]] }) => this.get(id))).then((events) => events.filter((ev) => ev !== undefined));
}
async organizerOf(who) {
const events = await this.api.query.ListingsCatalog.CollectionAccount.getEntries(this.eventsContractAddress);
return Promise.all(events.map(({ keyArgs: [_, [m, eventId]] }) => m === this.merchantId ? this.get(eventId) : undefined)).then((evs) => evs.filter((ev) => ev?.organiser === who));
}
async ticketHolderOf(who) {
const keys = await this.api.query.ListingsCatalog.Account.getEntries(who);
return Promise.all(keys.map(({ keyArgs: [_, [m, eventId]] }) => m === this.merchantId ? this.get(eventId) : undefined)).then((evs) => evs.filter((ev) => ev !== undefined));
}
};
KippuEventsStorage = __decorate([
__param(0, inject(TOKEN.ACCUNT_PROVIDER)),
__param(1, inject(TOKEN.KREIVO_API)),
__param(2, inject(TOKEN.EVENTS_CONTRACT_ADDRESS)),
__param(3, inject(TOKEN.EVENTS_CONTRACT)),
__param(4, inject(TickettoModelConverter)),
__param(5, inject(TOKEN.MERCHANT_ID)),
__metadata("design:paramtypes", [Object, Object, String, Object, TickettoModelConverter, Number])
], KippuEventsStorage);
export { KippuEventsStorage };